Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

import "IFactRegistry.sol";
import "IIdentity.sol";
import "Output.sol";
import "StarknetGovernance.sol";
import "StarknetMessaging.sol";
import "StarknetOperator.sol";
import "StarknetState.sol";
import "OnchainDataFactTreeEncoder.sol";
import "GovernedFinalizable.sol";
import "ContractInitializer.sol";
import "ProxySupport.sol";
import "NamedStorage.sol";

contract Starknet is
    IIdentity,
    StarknetMessaging,
    StarknetGovernance,
    GovernedFinalizable,
    StarknetOperator,
    ContractInitializer,
    ProxySupport
{
    using StarknetState for StarknetState.State;

    // Logs the new state following a state update.
    event LogStateUpdate(uint256 globalRoot, int256 blockNumber);

    // Logs a stateTransitionFact that was used to update the state.
    event LogStateTransitionFact(bytes32 stateTransitionFact);

    // Random storage slot tags.
    string internal constant PROGRAM_HASH_TAG = "STARKNET_1.0_INIT_PROGRAM_HASH_UINT";
    string internal constant VERIFIER_ADDRESS_TAG = "STARKNET_1.0_INIT_VERIFIER_ADDRESS";
    string internal constant STATE_STRUCT_TAG = "STARKNET_1.0_INIT_STARKNET_STATE_STRUCT";

    // The hash of the StarkNet config.
    string internal constant CONFIG_HASH_TAG = "STARKNET_1.0_STARKNET_CONFIG_HASH";

    function setProgramHash(uint256 newProgramHash) external notFinalized onlyGovernance {
        programHash(newProgramHash);
    }

    function setConfigHash(uint256 newConfigHash) external notFinalized onlyGovernance {
        configHash(newConfigHash);
    }

    function setMessageCancellationDelay(uint256 delayInSeconds)
        external
        notFinalized
        onlyGovernance
    {
        messageCancellationDelay(delayInSeconds);
    }

    // State variable "programHash" read-access function.
    function programHash() public view returns (uint256) {
        return NamedStorage.getUintValue(PROGRAM_HASH_TAG);
    }

    // State variable "programHash" write-access function.
    function programHash(uint256 value) internal {
        NamedStorage.setUintValue(PROGRAM_HASH_TAG, value);
    }

    // State variable "verifier" access function.
    function verifier() internal view returns (address) {
        return NamedStorage.getAddressValue(VERIFIER_ADDRESS_TAG);
    }

    // State variable "configHash" write-access function.
    function configHash(uint256 value) internal {
        NamedStorage.setUintValue(CONFIG_HASH_TAG, value);
    }

    // State variable "configHash" read-access function.
    function configHash() public view returns (uint256) {
        return NamedStorage.getUintValue(CONFIG_HASH_TAG);
    }

    function setVerifierAddress(address value) internal {
        NamedStorage.setAddressValueOnce(VERIFIER_ADDRESS_TAG, value);
    }

    // State variable "state" access function.
    function state() internal pure returns (StarknetState.State storage stateStruct) {
        bytes32 location = keccak256(abi.encodePacked(STATE_STRUCT_TAG));
        assembly {
            stateStruct_slot := location
        }
    }

    function isInitialized() internal view override returns (bool) {
        return programHash() != 0;
    }

    function numOfSubContracts() internal pure override returns (uint256) {
        return 0;
    }

    function validateInitData(bytes calldata data) internal pure override {
        require(data.length == 5 * 32, "ILLEGAL_INIT_DATA_SIZE");
        uint256 programHash_ = abi.decode(data[:32], (uint256));
        require(programHash_ != 0, "BAD_INITIALIZATION");
    }

    function processSubContractAddresses(bytes calldata subContractAddresses) internal override {}

    function initializeContractState(bytes calldata data) internal override {
        (
            uint256 programHash_,
            address verifier_,
            uint256 configHash_,
            StarknetState.State memory initialState
        ) = abi.decode(data, (uint256, address, uint256, StarknetState.State));

        programHash(programHash_);
        setVerifierAddress(verifier_);
        state().copy(initialState);
        configHash(configHash_);
        messageCancellationDelay(5 days);
    }

    /**
      Returns a string that identifies the contract.
    */
    function identify() external pure override returns (string memory) {
        return "StarkWare_Starknet_2022_2";
    }

    /**
      Returns the current state root.
    */
    function stateRoot() external view returns (uint256) {
        return state().globalRoot;
    }

    /**
      Returns the current block number.
    */
    function stateBlockNumber() external view returns (int256) {
        return state().blockNumber;
    }

    /**
      Updates the state of the StarkNet, based on a proof of the
      StarkNet OS that the state transition is valid.

      Arguments:
        programOutput - The main part of the StarkNet OS program output.
        data_availability_fact - An encoding of the on-chain data associated
        with the 'programOutput'.
    */
    function updateState(
        uint256[] calldata programOutput,
        uint256 onchainDataHash,
        uint256 onchainDataSize
    ) external onlyOperator {
        // Validate program output.
        StarknetOutput.validate(programOutput);

        // Validate config hash.
        require(
            configHash() == programOutput[StarknetOutput.CONFIG_HASH_OFFSET],
            "INVALID_CONFIG_HASH"
        );

        bytes32 stateTransitionFact = OnchainDataFactTreeEncoder.encodeFactWithOnchainData(
            programOutput,
            OnchainDataFactTreeEncoder.DataAvailabilityFact(onchainDataHash, onchainDataSize)
        );
        bytes32 sharpFact = keccak256(abi.encode(programHash(), stateTransitionFact));
        require(IFactRegistry(verifier()).isValid(sharpFact), "NO_STATE_TRANSITION_PROOF");
        emit LogStateTransitionFact(stateTransitionFact);

        // Process L2 -> L1 messages.
        uint256 outputOffset = StarknetOutput.HEADER_SIZE;
        outputOffset += StarknetOutput.processMessages(
            // isL2ToL1=
            true,
            programOutput[outputOffset:],
            l2ToL1Messages()
        );

        // Process L1 -> L2 messages.
        outputOffset += StarknetOutput.processMessages(
            // isL2ToL1=
            false,
            programOutput[outputOffset:],
            l1ToL2Messages()
        );

        require(outputOffset == programOutput.length, "STARKNET_OUTPUT_TOO_LONG");

        // Perform state update.
        state().update(programOutput);
        StarknetState.State storage state_ = state();
        emit LogStateUpdate(state_.globalRoot, state_.blockNumber);
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

/*
  This contract provides means to block direct call of an external function.
  A derived contract (e.g. MainDispatcherBase) should decorate sensitive functions with the
  notCalledDirectly modifier, thereby preventing it from being called directly, and allowing only calling
  using delegate_call.

  This Guard contract uses pseudo-random slot, So each deployed contract would have its own guard.
*/
abstract contract BlockDirectCall {
    bytes32 immutable UNIQUE_SAFEGUARD_SLOT; // NOLINT naming-convention.

    constructor() internal {
        // The slot is pseudo-random to allow hierarchy of contracts with guarded functions.
        bytes32 slot = keccak256(abi.encode(this, block.timestamp, gasleft()));
        UNIQUE_SAFEGUARD_SLOT = slot;
        assembly {
            sstore(slot, 42)
        }
    }

    modifier notCalledDirectly() {
        {
            // Prevent too many local variables in stack.
            uint256 safeGuardValue;
            bytes32 slot = UNIQUE_SAFEGUARD_SLOT;
            assembly {
                safeGuardValue := sload(slot)
            }
            require(safeGuardValue == 0, "DIRECT_CALL_DISALLOWED");
        }
        _;
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

/*
  Common Utility librarries.
  I. Addresses (extending address).
*/
library Addresses {
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function performEthTransfer(address recipient, uint256 amount) internal {
        (bool success, ) = recipient.call{value: amount}(""); // NOLINT: low-level-calls.
        require(success, "ETH_TRANSFER_FAILED");
    }

    /*
      Safe wrapper around ERC20/ERC721 calls.
      This is required because many deployed ERC20 contracts don't return a value.
      See https://github.com/ethereum/solidity/issues/4116.
    */
    function safeTokenContractCall(address tokenAddress, bytes memory callData) internal {
        require(isContract(tokenAddress), "BAD_TOKEN_ADDRESS");
        // NOLINTNEXTLINE: low-level-calls.
        (bool success, bytes memory returndata) = tokenAddress.call(callData);
        require(success, string(returndata));

        if (returndata.length > 0) {
            require(abi.decode(returndata, (bool)), "TOKEN_OPERATION_FAILED");
        }
    }

    /*
      Validates that the passed contract address is of a real contract,
      and that its id hash (as infered fromn identify()) matched the expected one.
    */
    function validateContractId(address contractAddress, bytes32 expectedIdHash) internal {
        require(isContract(contractAddress), "ADDRESS_NOT_CONTRACT");
        (bool success, bytes memory returndata) = contractAddress.call( // NOLINT: low-level-calls.
            abi.encodeWithSignature("identify()")
        );
        require(success, "FAILED_TO_IDENTIFY_CONTRACT");
        string memory realContractId = abi.decode(returndata, (string));
        require(
            keccak256(abi.encodePacked(realContractId)) == expectedIdHash,
            "UNEXPECTED_CONTRACT_IDENTIFIER"
        );
    }
}

/*
  II. StarkExTypes - Common data types.
*/
library StarkExTypes {
    // Structure representing a list of verifiers (validity/availability).
    // A statement is valid only if all the verifiers in the list agree on it.
    // Adding a verifier to the list is immediate - this is used for fast resolution of
    // any soundness issues.
    // Removing from the list is time-locked, to ensure that any user of the system
    // not content with the announced removal has ample time to leave the system before it is
    // removed.
    struct ApprovalChainData {
        address[] list;
        // Represents the time after which the verifier with the given address can be removed.
        // Removal of the verifier with address A is allowed only in the case the value
        // of unlockedForRemovalTime[A] != 0 and unlockedForRemovalTime[A] < (current time).
        mapping(address => uint256) unlockedForRemovalTime;
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

/**
  Interface for contract initialization.
  The functions it exposes are the app specific parts of the contract initialization,
  and are called by the ProxySupport contract that implement the generic part of behind-proxy
  initialization.
*/
abstract contract ContractInitializer {
    function numOfSubContracts() internal pure virtual returns (uint256);

    function isInitialized() internal view virtual returns (bool);

    function validateInitData(bytes calldata data) internal pure virtual;

    function processSubContractAddresses(bytes calldata subContractAddresses) internal virtual;

    function initializeContractState(bytes calldata data) internal virtual;
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "MGovernance.sol";

/*
  Implements Generic Governance, applicable for both proxy and main contract, and possibly others.
  Notes:
   The use of the same function names by both the Proxy and a delegated implementation
   is not possible since calling the implementation functions is done via the default function
   of the Proxy. For this reason, for example, the implementation of MainContract (MainGovernance)
   exposes mainIsGovernor, which calls the internal _isGovernor method.
*/
abstract contract Governance is MGovernance {
    event LogNominatedGovernor(address nominatedGovernor);
    event LogNewGovernorAccepted(address acceptedGovernor);
    event LogRemovedGovernor(address removedGovernor);
    event LogNominationCancelled();

    function getGovernanceInfo() internal view virtual returns (GovernanceInfoStruct storage);

    /*
      Current code intentionally prevents governance re-initialization.
      This may be a problem in an upgrade situation, in a case that the upgrade-to implementation
      performs an initialization (for real) and within that calls initGovernance().

      Possible workarounds:
      1. Clearing the governance info altogether by changing the MAIN_GOVERNANCE_INFO_TAG.
         This will remove existing main governance information.
      2. Modify the require part in this function, so that it will exit quietly
         when trying to re-initialize (uncomment the lines below).
    */
    function initGovernance() internal {
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        require(!gub.initialized, "ALREADY_INITIALIZED");
        gub.initialized = true; // to ensure addGovernor() won't fail.
        // Add the initial governer.
        addGovernor(msg.sender);
    }

    function _isGovernor(address testGovernor) internal view override returns (bool) {
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        return gub.effectiveGovernors[testGovernor];
    }

    /*
      Cancels the nomination of a governor candidate.
    */
    function _cancelNomination() internal onlyGovernance {
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        gub.candidateGovernor = address(0x0);
        emit LogNominationCancelled();
    }

    function _nominateNewGovernor(address newGovernor) internal onlyGovernance {
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        require(!_isGovernor(newGovernor), "ALREADY_GOVERNOR");
        gub.candidateGovernor = newGovernor;
        emit LogNominatedGovernor(newGovernor);
    }

    /*
      The addGovernor is called in two cases:
      1. by _acceptGovernance when a new governor accepts its role.
      2. by initGovernance to add the initial governor.
      The difference is that the init path skips the nominate step
      that would fail because of the onlyGovernance modifier.
    */
    function addGovernor(address newGovernor) private {
        require(!_isGovernor(newGovernor), "ALREADY_GOVERNOR");
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        gub.effectiveGovernors[newGovernor] = true;
    }

    function _acceptGovernance() internal {
        // The new governor was proposed as a candidate by the current governor.
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        require(msg.sender == gub.candidateGovernor, "ONLY_CANDIDATE_GOVERNOR");

        // Update state.
        addGovernor(gub.candidateGovernor);
        gub.candidateGovernor = address(0x0);

        // Send a notification about the change of governor.
        emit LogNewGovernorAccepted(msg.sender);
    }

    /*
      Remove a governor from office.
    */
    function _removeGovernor(address governorForRemoval) internal onlyGovernance {
        require(msg.sender != governorForRemoval, "GOVERNOR_SELF_REMOVE");
        GovernanceInfoStruct storage gub = getGovernanceInfo();
        require(_isGovernor(governorForRemoval), "NOT_GOVERNOR");
        gub.effectiveGovernors[governorForRemoval] = false;
        emit LogRemovedGovernor(governorForRemoval);
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "MGovernance.sol";
import "NamedStorage.sol";

/**
  A Governor controlled finalizable contract.
  The inherited contract (the one that is GovernedFinalizable) implements the Governance.
*/
abstract contract GovernedFinalizable is MGovernance {
    string constant STORAGE_TAG = "STARKWARE_CONTRACTS_GOVERENED_FINALIZABLE_1.0_TAG";

    function isFinalized() public view returns (bool) {
        return NamedStorage.getBoolValue(STORAGE_TAG);
    }

    modifier notFinalized() {
        require(!isFinalized(), "FINALIZED");
        _;
    }

    function finalize() external onlyGovernance {
        NamedStorage.setBoolValue(STORAGE_TAG, true);
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

/*
  The Fact Registry design pattern is a way to separate cryptographic verification from the
  business logic of the contract flow.

  A fact registry holds a hash table of verified "facts" which are represented by a hash of claims
  that the registry hash check and found valid. This table may be queried by accessing the
  isValid() function of the registry with a given hash.

  In addition, each fact registry exposes a registry specific function for submitting new claims
  together with their proofs. The information submitted varies from one registry to the other
  depending of the type of fact requiring verification.

  For further reading on the Fact Registry design pattern see this
  `StarkWare blog post <https://medium.com/starkware/the-fact-registry-a64aafb598b6>`_.
*/
interface IFactRegistry {
    /*
      Returns true if the given fact was previously registered in the contract.
    */
    function isValid(bytes32 fact) external view returns (bool);
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

interface IIdentity {
    /*
      Allows a caller to ensure that the provided address is of the expected type and version.
    */
    function identify() external pure returns (string memory);
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "IStarknetMessagingEvents.sol";

interface IStarknetMessaging is IStarknetMessagingEvents {
    /**
      Sends a message to an L2 contract.

      Returns the hash of the message.
    */
    function sendMessageToL2(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload
    ) external returns (bytes32);

    /**
      Consumes a message that was sent from an L2 contract.

      Returns the hash of the message.
    */
    function consumeMessageFromL2(uint256 fromAddress, uint256[] calldata payload)
        external
        returns (bytes32);

    /**
      Starts the cancellation of an L1 to L2 message.
      A message can be canceled messageCancellationDelay() seconds after this function is called.

      Note: This function may only be called for a message that is currently pending and the caller
      must be the sender of the that message.
    */
    function startL1ToL2MessageCancellation(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external;

    /**
      Cancels an L1 to L2 message, this function should be called messageCancellationDelay() seconds
      after the call to startL1ToL2MessageCancellation().
    */
    function cancelL1ToL2Message(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external;
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

interface IStarknetMessagingEvents {
    // This event needs to be compatible with the one defined in Output.sol.
    event LogMessageToL1(uint256 indexed fromAddress, address indexed toAddress, uint256[] payload);

    // An event that is raised when a message is sent from L1 to L2.
    event LogMessageToL2(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );

    // An event that is raised when a message from L2 to L1 is consumed.
    event ConsumedMessageToL1(
        uint256 indexed fromAddress,
        address indexed toAddress,
        uint256[] payload
    );

    // An event that is raised when a message from L1 to L2 is consumed.
    event ConsumedMessageToL2(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );

    // An event that is raised when a message from L1 to L2 Cancellation is started.
    event MessageToL2CancellationStarted(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );

    // An event that is raised when a message from L1 to L2 is canceled.
    event MessageToL2Canceled(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

struct GovernanceInfoStruct {
    mapping(address => bool) effectiveGovernors;
    address candidateGovernor;
    bool initialized;
}

abstract contract MGovernance {
    function _isGovernor(address testGovernor) internal view virtual returns (bool);

    /*
      Allows calling the function only by a Governor.
    */
    modifier onlyGovernance() {
        require(_isGovernor(msg.sender), "ONLY_GOVERNANCE");
        _;
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "MGovernance.sol";

abstract contract MOperator {
    event LogOperatorAdded(address operator);
    event LogOperatorRemoved(address operator);

    function isOperator(address testedOperator) public view virtual returns (bool);

    modifier onlyOperator() {
        require(isOperator(msg.sender), "ONLY_OPERATOR");
        _;
    }

    function registerOperator(address newOperator) external virtual;

    function unregisterOperator(address removedOperator) external virtual;

    function getOperators() internal view virtual returns (mapping(address => bool) storage);
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

/*
  Library to provide basic storage, in storage location out of the low linear address space.

  New types of storage variables should be added here upon need.
*/
library NamedStorage {
    function bytes32ToUint256Mapping(string memory tag_)
        internal
        pure
        returns (mapping(bytes32 => uint256) storage randomVariable)
    {
        bytes32 location = keccak256(abi.encodePacked(tag_));
        assembly {
            randomVariable_slot := location
        }
    }

    function bytes32ToAddressMapping(string memory tag_)
        internal
        pure
        returns (mapping(bytes32 => address) storage randomVariable)
    {
        bytes32 location = keccak256(abi.encodePacked(tag_));
        assembly {
            randomVariable_slot := location
        }
    }

    function addressToBoolMapping(string memory tag_)
        internal
        pure
        returns (mapping(address => bool) storage randomVariable)
    {
        bytes32 location = keccak256(abi.encodePacked(tag_));
        assembly {
            randomVariable_slot := location
        }
    }

    function getUintValue(string memory tag_) internal view returns (uint256 retVal) {
        bytes32 slot = keccak256(abi.encodePacked(tag_));
        assembly {
            retVal := sload(slot)
        }
    }

    function setUintValue(string memory tag_, uint256 value) internal {
        bytes32 slot = keccak256(abi.encodePacked(tag_));
        assembly {
            sstore(slot, value)
        }
    }

    function setUintValueOnce(string memory tag_, uint256 value) internal {
        require(getUintValue(tag_) == 0, "ALREADY_SET");
        setUintValue(tag_, value);
    }

    function getAddressValue(string memory tag_) internal view returns (address retVal) {
        bytes32 slot = keccak256(abi.encodePacked(tag_));
        assembly {
            retVal := sload(slot)
        }
    }

    function setAddressValue(string memory tag_, address value) internal {
        bytes32 slot = keccak256(abi.encodePacked(tag_));
        assembly {
            sstore(slot, value)
        }
    }

    function setAddressValueOnce(string memory tag_, address value) internal {
        require(getAddressValue(tag_) == address(0x0), "ALREADY_SET");
        setAddressValue(tag_, value);
    }

    function getBoolValue(string memory tag_) internal view returns (bool retVal) {
        bytes32 slot = keccak256(abi.encodePacked(tag_));
        assembly {
            retVal := sload(slot)
        }
    }

    function setBoolValue(string memory tag_, bool value) internal {
        bytes32 slot = keccak256(abi.encodePacked(tag_));
        assembly {
            sstore(slot, value)
        }
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

library OnchainDataFactTreeEncoder {
    struct DataAvailabilityFact {
        uint256 onchainDataHash;
        uint256 onchainDataSize;
    }

    // The number of additional words appended to the public input when using the
    // OnchainDataFactTreeEncoder format.
    uint256 internal constant ONCHAIN_DATA_FACT_ADDITIONAL_WORDS = 2;

    /*
      Encodes a GPS fact Merkle tree where the root has two children.
      The left child contains the data we care about and the right child contains
      on-chain data for the fact.
    */
    function encodeFactWithOnchainData(
        uint256[] calldata programOutput,
        DataAvailabilityFact memory factData
    ) internal pure returns (bytes32) {
        // The state transition fact is computed as a Merkle tree, as defined in
        // GpsOutputParser.
        //
        // In our case the fact tree looks as follows:
        //   The root has two children.
        //   The left child is a leaf that includes the main part - the information regarding
        //   the state transition required by this contract.
        //   The right child contains the onchain-data which shouldn't be accessed by this
        //   contract, so we are only given its hash and length
        //   (it may be a leaf or an inner node, this has no effect on this contract).

        // Compute the hash without the two additional fields.
        uint256 mainPublicInputLen = programOutput.length;
        bytes32 mainPublicInputHash = keccak256(abi.encodePacked(programOutput));

        // Compute the hash of the fact Merkle tree.
        bytes32 hashResult = keccak256(
            abi.encodePacked(
                mainPublicInputHash,
                mainPublicInputLen,
                factData.onchainDataHash,
                mainPublicInputLen + factData.onchainDataSize
            )
        );
        // Add one to the hash to indicate it represents an inner node, rather than a leaf.
        return bytes32(uint256(hashResult) + 1);
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "MOperator.sol";
import "MGovernance.sol";

/**
  The Operator of the contract is the entity entitled to submit state update requests
  by calling :sol:func:`updateState`.

  An Operator may be instantly appointed or removed by the contract Governor
  (see :sol:mod:`Governance`). Typically, the Operator is the hot wallet of the service
  submitting proofs for state updates.
*/
abstract contract Operator is MGovernance, MOperator {
    function registerOperator(address newOperator) external override onlyGovernance {
        getOperators()[newOperator] = true;
        emit LogOperatorAdded(newOperator);
    }

    function unregisterOperator(address removedOperator) external override onlyGovernance {
        getOperators()[removedOperator] = false;
        emit LogOperatorRemoved(removedOperator);
    }

    function isOperator(address testedOperator) public view override returns (bool) {
        return getOperators()[testedOperator];
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

library CommitmentTreeUpdateOutput {
    /**
      Returns the previous commitment tree root.
    */
    function getPrevRoot(uint256[] calldata commitmentTreeUpdateData)
        internal
        pure
        returns (uint256)
    {
        return commitmentTreeUpdateData[0];
    }

    /**
      Returns the new commitment tree root.
    */
    function getNewRoot(uint256[] calldata commitmentTreeUpdateData)
        internal
        pure
        returns (uint256)
    {
        return commitmentTreeUpdateData[1];
    }
}

library StarknetOutput {
    uint256 internal constant MERKLE_UPDATE_OFFSET = 0;
    uint256 internal constant BLOCK_NUMBER_OFFSET = 2;
    uint256 internal constant CONFIG_HASH_OFFSET = 3;
    uint256 internal constant HEADER_SIZE = 4;

    uint256 constant MESSAGE_TO_L1_FROM_ADDRESS_OFFSET = 0;
    uint256 constant MESSAGE_TO_L1_TO_ADDRESS_OFFSET = 1;
    uint256 constant MESSAGE_TO_L1_PAYLOAD_SIZE_OFFSET = 2;
    uint256 constant MESSAGE_TO_L1_PREFIX_SIZE = 3;

    uint256 constant MESSAGE_TO_L2_FROM_ADDRESS_OFFSET = 0;
    uint256 constant MESSAGE_TO_L2_TO_ADDRESS_OFFSET = 1;
    uint256 constant MESSAGE_TO_L2_NONCE_OFFSET = 2;
    uint256 constant MESSAGE_TO_L2_SELECTOR_OFFSET = 3;
    uint256 constant MESSAGE_TO_L2_PAYLOAD_SIZE_OFFSET = 4;
    uint256 constant MESSAGE_TO_L2_PREFIX_SIZE = 5;

    // An event that is raised when a message is sent from L2 to L1.
    event LogMessageToL1(uint256 indexed fromAddress, address indexed toAddress, uint256[] payload);

    // An event that is raised when a message from L1 to L2 is consumed.
    event ConsumedMessageToL2(
        address indexed fromAddress,
        uint256 indexed toAddress,
        uint256 indexed selector,
        uint256[] payload,
        uint256 nonce
    );

    /**
      Does a sanity check of the output_data length.
    */
    function validate(uint256[] calldata output_data) internal pure {
        require(output_data.length > HEADER_SIZE, "STARKNET_OUTPUT_TOO_SHORT");
    }

    /**
      Returns a slice of the 'output_data' with the commitment tree update information.
    */
    function getMerkleUpdate(uint256[] calldata output_data)
        internal
        pure
        returns (uint256[] calldata)
    {
        return output_data[MERKLE_UPDATE_OFFSET:MERKLE_UPDATE_OFFSET + 2];
    }

    /**
      Processes a message segment from the program output.
      The format of a message segment is the length of the messages in words followed
      by the concatenation of all the messages.

      The 'messages' mapping is updated according to the messages and the direction ('isL2ToL1').
    */
    function processMessages(
        bool isL2ToL1,
        uint256[] calldata programOutputSlice,
        mapping(bytes32 => uint256) storage messages
    ) internal returns (uint256) {
        uint256 messageSegmentSize = programOutputSlice[0];
        require(messageSegmentSize < 2**30, "INVALID_MESSAGE_SEGMENT_SIZE");

        uint256 offset = 1;
        uint256 messageSegmentEnd = offset + messageSegmentSize;

        uint256 payloadSizeOffset = (
            isL2ToL1 ? MESSAGE_TO_L1_PAYLOAD_SIZE_OFFSET : MESSAGE_TO_L2_PAYLOAD_SIZE_OFFSET
        );
        while (offset < messageSegmentEnd) {
            uint256 payloadLengthOffset = offset + payloadSizeOffset;
            require(payloadLengthOffset < programOutputSlice.length, "MESSAGE_TOO_SHORT");

            uint256 payloadLength = programOutputSlice[payloadLengthOffset];
            require(payloadLength < 2**30, "INVALID_PAYLOAD_LENGTH");

            uint256 endOffset = payloadLengthOffset + 1 + payloadLength;
            require(endOffset <= programOutputSlice.length, "TRUNCATED_MESSAGE_PAYLOAD");

            if (isL2ToL1) {
                bytes32 messageHash = keccak256(
                    abi.encodePacked(programOutputSlice[offset:endOffset])
                );

                emit LogMessageToL1(
                    // from=
                    programOutputSlice[offset + MESSAGE_TO_L1_FROM_ADDRESS_OFFSET],
                    // to=
                    address(programOutputSlice[offset + MESSAGE_TO_L1_TO_ADDRESS_OFFSET]),
                    // payload=
                    (uint256[])(programOutputSlice[offset + MESSAGE_TO_L1_PREFIX_SIZE:endOffset])
                );
                messages[messageHash] += 1;
            } else {
                {
                    bytes32 messageHash = keccak256(
                        abi.encodePacked(programOutputSlice[offset:endOffset])
                    );

                    require(messages[messageHash] > 0, "INVALID_MESSAGE_TO_CONSUME");
                    messages[messageHash] -= 1;
                }

                uint256 nonce = programOutputSlice[offset + MESSAGE_TO_L2_NONCE_OFFSET];
                emit ConsumedMessageToL2(
                    // from=
                    address(programOutputSlice[offset + MESSAGE_TO_L2_FROM_ADDRESS_OFFSET]),
                    // to=
                    programOutputSlice[offset + MESSAGE_TO_L2_TO_ADDRESS_OFFSET],
                    // selector=
                    programOutputSlice[offset + MESSAGE_TO_L2_SELECTOR_OFFSET],
                    // payload=
                    (uint256[])(programOutputSlice[offset + MESSAGE_TO_L2_PREFIX_SIZE:endOffset]),
                    // nonce =
                    nonce
                );
            }

            offset = endOffset;
        }
        require(offset == messageSegmentEnd, "INVALID_MESSAGE_SEGMENT_SIZE");

        return offset;
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "Governance.sol";
import "Common.sol";
import "BlockDirectCall.sol";
import "ContractInitializer.sol";

/**
  This contract contains the code commonly needed for a contract to be deployed behind
  an upgradability proxy.
  It perform the required semantics of the proxy pattern,
  but in a generic manner.
  Instantiation of the Governance and of the ContractInitializer, that are the app specific
  part of initialization, has to be done by the using contract.
*/
abstract contract ProxySupport is Governance, BlockDirectCall, ContractInitializer {
    using Addresses for address;

    // The two function below (isFrozen & initialize) needed to bind to the Proxy.
    function isFrozen() external view virtual returns (bool) {
        return false;
    }

    /*
      The initialize() function serves as an alternative constructor for a proxied deployment.

      Flow and notes:
      1. This function cannot be called directly on the deployed contract, but only via
         delegate call.
      2. If an EIC is provided - init is passed onto EIC and the standard init flow is skipped.
         This true for both first intialization or a later one.
      3. The data passed to this function is as follows:
         [sub_contracts addresses, eic address, initData].

         When calling on an initialized contract (no EIC scenario), initData.length must be 0.
    */
    function initialize(bytes calldata data) external notCalledDirectly {
        uint256 eicOffset = 32 * numOfSubContracts();
        uint256 expectedBaseSize = eicOffset + 32;
        require(data.length >= expectedBaseSize, "INIT_DATA_TOO_SMALL");
        address eicAddress = abi.decode(data[eicOffset:expectedBaseSize], (address));

        bytes calldata subContractAddresses = data[:eicOffset];

        processSubContractAddresses(subContractAddresses);

        bytes calldata initData = data[expectedBaseSize:];

        // EIC Provided - Pass initData to EIC and the skip standard init flow.
        if (eicAddress != address(0x0)) {
            callExternalInitializer(eicAddress, initData);
            return;
        }

        if (isInitialized()) {
            require(initData.length == 0, "UNEXPECTED_INIT_DATA");
        } else {
            // Contract was not initialized yet.
            validateInitData(initData);
            initializeContractState(initData);
            initGovernance();
        }
    }

    function callExternalInitializer(address externalInitializerAddr, bytes calldata eicData)
        private
    {
        require(externalInitializerAddr.isContract(), "EIC_NOT_A_CONTRACT");

        // NOLINTNEXTLINE: low-level-calls, controlled-delegatecall.
        (bool success, bytes memory returndata) = externalInitializerAddr.delegatecall(
            abi.encodeWithSelector(this.initialize.selector, eicData)
        );
        require(success, string(returndata));
        require(returndata.length == 0, string(returndata));
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "Governance.sol";

contract StarknetGovernance is Governance {
    string constant STARKNET_GOVERNANCE_INFO_TAG = "STARKNET_1.0_GOVERNANCE_INFO";

    /*
      Returns the GovernanceInfoStruct associated with the governance tag.
    */
    function getGovernanceInfo() internal view override returns (GovernanceInfoStruct storage gub) {
        bytes32 location = keccak256(abi.encodePacked(STARKNET_GOVERNANCE_INFO_TAG));
        assembly {
            gub_slot := location
        }
    }

    function starknetIsGovernor(address testGovernor) external view returns (bool) {
        return _isGovernor(testGovernor);
    }

    function starknetNominateNewGovernor(address newGovernor) external {
        _nominateNewGovernor(newGovernor);
    }

    function starknetRemoveGovernor(address governorForRemoval) external {
        _removeGovernor(governorForRemoval);
    }

    function starknetAcceptGovernance() external {
        _acceptGovernance();
    }

    function starknetCancelNomination() external {
        _cancelNomination();
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "IStarknetMessaging.sol";
import "NamedStorage.sol";

/**
  Implements sending messages to L2 by adding them to a pipe and consuming messages from L2 by
  removing them from a different pipe. A deriving contract can handle the former pipe and add items
  to the latter pipe while interacting with L2.
*/
contract StarknetMessaging is IStarknetMessaging {
    /**
      Random slot storage elements and accessors.
    */
    string constant L1L2_MESSAGE_MAP_TAG = "STARKNET_1.0_MSGING_L1TOL2_MAPPPING_V2";
    string constant L2L1_MESSAGE_MAP_TAG = "STARKNET_1.0_MSGING_L2TOL1_MAPPPING";

    string constant L1L2_MESSAGE_NONCE_TAG = "STARKNET_1.0_MSGING_L1TOL2_NONCE";

    string constant L1L2_MESSAGE_CANCELLATION_MAP_TAG = (
        "STARKNET_1.0_MSGING_L1TOL2_CANCELLATION_MAPPPING"
    );

    string constant L1L2_MESSAGE_CANCELLATION_DELAY_TAG = (
        "STARKNET_1.0_MSGING_L1TOL2_CANCELLATION_DELAY"
    );

    function l1ToL2Messages(bytes32 msgHash) external view returns (uint256) {
        return l1ToL2Messages()[msgHash];
    }

    function l2ToL1Messages(bytes32 msgHash) external view returns (uint256) {
        return l2ToL1Messages()[msgHash];
    }

    function l1ToL2Messages() internal pure returns (mapping(bytes32 => uint256) storage) {
        return NamedStorage.bytes32ToUint256Mapping(L1L2_MESSAGE_MAP_TAG);
    }

    function l2ToL1Messages() internal pure returns (mapping(bytes32 => uint256) storage) {
        return NamedStorage.bytes32ToUint256Mapping(L2L1_MESSAGE_MAP_TAG);
    }

    function l1ToL2MessageNonce() public view returns (uint256) {
        return NamedStorage.getUintValue(L1L2_MESSAGE_NONCE_TAG);
    }

    function messageCancellationDelay() public view returns (uint256) {
        return NamedStorage.getUintValue(L1L2_MESSAGE_CANCELLATION_DELAY_TAG);
    }

    function messageCancellationDelay(uint256 delayInSeconds) internal {
        NamedStorage.setUintValue(L1L2_MESSAGE_CANCELLATION_DELAY_TAG, delayInSeconds);
    }

    /**
      Returns the timestamp at the time cancelL1ToL2Message was called with a message
      matching 'msgHash'.

      The function returns 0 if cancelL1ToL2Message was never called.
    */
    function l1ToL2MessageCancellations(bytes32 msgHash) external view returns (uint256) {
        return l1ToL2MessageCancellations()[msgHash];
    }

    function l1ToL2MessageCancellations()
        internal
        pure
        returns (mapping(bytes32 => uint256) storage)
    {
        return NamedStorage.bytes32ToUint256Mapping(L1L2_MESSAGE_CANCELLATION_MAP_TAG);
    }

    /**
      Returns the hash of an L1 -> L2 message from msg.sender.
    */
    function getL1ToL2MsgHash(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) internal returns (bytes32) {
        return
            keccak256(
                abi.encodePacked(
                    uint256(msg.sender),
                    toAddress,
                    nonce,
                    selector,
                    payload.length,
                    payload
                )
            );
    }

    /**
      Sends a message to an L2 contract.
    */
    function sendMessageToL2(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload
    ) external override returns (bytes32) {
        uint256 nonce = l1ToL2MessageNonce();
        NamedStorage.setUintValue(L1L2_MESSAGE_NONCE_TAG, nonce + 1);
        emit LogMessageToL2(msg.sender, toAddress, selector, payload, nonce);
        bytes32 msgHash = getL1ToL2MsgHash(toAddress, selector, payload, nonce);
        l1ToL2Messages()[msgHash] += 1;

        return msgHash;
    }

    /**
      Consumes a message that was sent from an L2 contract.

      Returns the hash of the message.
    */
    function consumeMessageFromL2(uint256 fromAddress, uint256[] calldata payload)
        external
        override
        returns (bytes32)
    {
        bytes32 msgHash = keccak256(
            abi.encodePacked(fromAddress, uint256(msg.sender), payload.length, payload)
        );

        require(l2ToL1Messages()[msgHash] > 0, "INVALID_MESSAGE_TO_CONSUME");
        emit ConsumedMessageToL1(fromAddress, msg.sender, payload);
        l2ToL1Messages()[msgHash] -= 1;
        return msgHash;
    }

    function startL1ToL2MessageCancellation(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external override {
        emit MessageToL2CancellationStarted(msg.sender, toAddress, selector, payload, nonce);
        bytes32 msgHash = getL1ToL2MsgHash(toAddress, selector, payload, nonce);
        uint256 msgCount = l1ToL2Messages()[msgHash];
        require(msgCount > 0, "NO_MESSAGE_TO_CANCEL");
        l1ToL2MessageCancellations()[msgHash] = block.timestamp;
    }

    function cancelL1ToL2Message(
        uint256 toAddress,
        uint256 selector,
        uint256[] calldata payload,
        uint256 nonce
    ) external override {
        emit MessageToL2Canceled(msg.sender, toAddress, selector, payload, nonce);
        bytes32 msgHash = getL1ToL2MsgHash(toAddress, selector, payload, nonce);
        uint256 msgCount = l1ToL2Messages()[msgHash];
        require(msgCount > 0, "NO_MESSAGE_TO_CANCEL");

        uint256 requestTime = l1ToL2MessageCancellations()[msgHash];
        require(requestTime != 0, "MESSAGE_CANCELLATION_NOT_REQUESTED");

        uint256 cancelAllowedTime = requestTime + messageCancellationDelay();
        require(cancelAllowedTime >= requestTime, "CANCEL_ALLOWED_TIME_OVERFLOW");
        require(block.timestamp >= cancelAllowedTime, "MESSAGE_CANCELLATION_NOT_ALLOWED_YET");

        l1ToL2Messages()[msgHash] = msgCount - 1;
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "Operator.sol";
import "NamedStorage.sol";

abstract contract StarknetOperator is Operator {
    string constant OPERATORS_MAPPING_TAG = "STARKNET_1.0_ROLES_OPERATORS_MAPPING_TAG";

    function getOperators() internal view override returns (mapping(address => bool) storage) {
        return NamedStorage.addressToBoolMapping(OPERATORS_MAPPING_TAG);
    }
}

/*
  Copyright 2019-2022 StarkWare Industries Ltd.

  Licensed under the Apache License, Version 2.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.starkware.co/open-source-license/

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT 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.
pragma solidity ^0.6.12;

import "Output.sol";

library StarknetState {
    struct State {
        uint256 globalRoot;
        int256 blockNumber;
    }

    function copy(State storage state, State memory stateFrom) internal {
        state.globalRoot = stateFrom.globalRoot;
        state.blockNumber = stateFrom.blockNumber;
    }

    /**
      Validates that the 'blockNumber' and the previous root are consistent with the
      current state and updates the state.
    */
    function update(State storage state, uint256[] calldata starknetOutput) internal {
        // Check the blockNumber first as the error is less ambiguous then INVALID_PREVIOUS_ROOT.
        state.blockNumber += 1;
        require(
            uint256(state.blockNumber) == starknetOutput[StarknetOutput.BLOCK_NUMBER_OFFSET],
            "INVALID_BLOCK_NUMBER"
        );

        uint256[] calldata commitment_tree_update = StarknetOutput.getMerkleUpdate(starknetOutput);
        require(
            state.globalRoot == CommitmentTreeUpdateOutput.getPrevRoot(commitment_tree_update),
            "INVALID_PREVIOUS_ROOT"
        );
        state.globalRoot = CommitmentTreeUpdateOutput.getNewRoot(commitment_tree_update);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromAddress","type":"uint256"},{"indexed":true,"internalType":"address","name":"toAddress","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"}],"name":"ConsumedMessageToL1","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"toAddress","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"selector","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"ConsumedMessageToL2","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromAddress","type":"uint256"},{"indexed":true,"internalType":"address","name":"toAddress","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"}],"name":"LogMessageToL1","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"toAddress","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"selector","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"LogMessageToL2","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"acceptedGovernor","type":"address"}],"name":"LogNewGovernorAccepted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nominatedGovernor","type":"address"}],"name":"LogNominatedGovernor","type":"event"},{"anonymous":false,"inputs":[],"name":"LogNominationCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"LogOperatorAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"LogOperatorRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"removedGovernor","type":"address"}],"name":"LogRemovedGovernor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"stateTransitionFact","type":"bytes32"}],"name":"LogStateTransitionFact","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"globalRoot","type":"uint256"},{"indexed":false,"internalType":"int256","name":"blockNumber","type":"int256"}],"name":"LogStateUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"toAddress","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"selector","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"MessageToL2Canceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"toAddress","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"selector","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"payload","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"MessageToL2CancellationStarted","type":"event"},{"inputs":[{"internalType":"uint256","name":"toAddress","type":"uint256"},{"internalType":"uint256","name":"selector","type":"uint256"},{"internalType":"uint256[]","name":"payload","type":"uint256[]"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"cancelL1ToL2Message","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"configHash","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"fromAddress","type":"uint256"},{"internalType":"uint256[]","name":"payload","type":"uint256[]"}],"name":"consumeMessageFromL2","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finalize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"identify","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isFinalized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isFrozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"testedOperator","type":"address"}],"name":"isOperator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"msgHash","type":"bytes32"}],"name":"l1ToL2MessageCancellations","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1ToL2MessageNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"msgHash","type":"bytes32"}],"name":"l1ToL2Messages","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"msgHash","type":"bytes32"}],"name":"l2ToL1Messages","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"messageCancellationDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"programHash","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator","type":"address"}],"name":"registerOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"toAddress","type":"uint256"},{"internalType":"uint256","name":"selector","type":"uint256"},{"internalType":"uint256[]","name":"payload","type":"uint256[]"}],"name":"sendMessageToL2","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newConfigHash","type":"uint256"}],"name":"setConfigHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"delayInSeconds","type":"uint256"}],"name":"setMessageCancellationDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newProgramHash","type":"uint256"}],"name":"setProgramHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"starknetAcceptGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"starknetCancelNomination","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"testGovernor","type":"address"}],"name":"starknetIsGovernor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newGovernor","type":"address"}],"name":"starknetNominateNewGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"governorForRemoval","type":"address"}],"name":"starknetRemoveGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"toAddress","type":"uint256"},{"internalType":"uint256","name":"selector","type":"uint256"},{"internalType":"uint256[]","name":"payload","type":"uint256[]"},{"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"startL1ToL2MessageCancellation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stateBlockNumber","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stateRoot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"removedOperator","type":"address"}],"name":"unregisterOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"programOutput","type":"uint256[]"},{"internalType":"uint256","name":"onchainDataHash","type":"uint256"},{"internalType":"uint256","name":"onchainDataSize","type":"uint256"}],"name":"updateState","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

1057:6286:16:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2196:133:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1165:128:17;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;4478:497:18:-;;;;;;:::i;:::-;;:::i;1340:86:15:-;;;:::i;5234:102:16:-;;;:::i;1108:175:13:-;;;;;;:::i;:::-;;:::i;:::-;;2099:125:16;;;;;;:::i;:::-;;:::i;3854:503:18:-;;;;;;:::i;:::-;;:::i;2048:1028:15:-;;;;;;:::i;:::-;;:::i;1218:105:4:-;;;:::i;5519:896:18:-;;;;;;:::i;:::-;;:::i;1487:134:13:-;;;;;;:::i;:::-;;:::i;5678:1663:16:-;;;;;;:::i;:::-;;:::i;1592:122:18:-;;;;;;:::i;:::-;;:::i;4981:532::-;;;;;;:::i;:::-;;:::i;2335:152::-;;;:::i;1422:121:17:-;;;;;;:::i;:::-;;:::i;2477:120:16:-;;;:::i;1006:112:4:-;;;:::i;1299:117:17:-;;;;;;:::i;:::-;;:::i;1549:81::-;;;:::i;5078:95:16:-;;;:::i;1289:192:13:-;;;;;;:::i;:::-;;:::i;2859:146:18:-;;;;;;:::i;:::-;;:::i;1720:122::-;;;;;;:::i;:::-;;:::i;2230:183:16:-;;;;;;:::i;:::-;;:::i;3193:118::-;;;:::i;1636:81:17:-;;;:::i;1964:129:16:-;;;;;;:::i;:::-;;:::i;4901:118::-;;;:::i;:::-;;;;;;;:::i;2196:133:18:-;2247:7;2273:49;2299:22;;;;;;;;;;;;;;;;;2273:25;:49::i;:::-;2266:56;;2196:133;:::o;1165:128:17:-;1238:4;1261:25;1273:12;1261:11;:25::i;:::-;1254:32;1165:128;-1:-1:-1;;1165:128:17:o;4478:497:18:-;4672:75;;4608:7;;;;4672:75;;4689:11;;4710:10;;4723:7;;;;;;4672:75;;;:::i;:::-;;;;;;;;;;;;;4649:108;;;;;;4631:126;;4804:1;4776:16;:14;:16::i;:::-;:25;;;;;;;;;;;;;:29;4768:68;;;;-1:-1:-1;;;4768:68:18;;;;;;;:::i;:::-;;;;;;;;;4884:10;-1:-1:-1;;;;;4851:53:18;4871:11;4851:53;4896:7;;4851:53;;;;;;;:::i;:::-;;;;;;;;4943:1;4914:16;:14;:16::i;:::-;:25;;;;;;;;;;;;:30;;;;;;;;:25;4478:497;-1:-1:-1;;;;4478:497:18:o;1340:86:15:-;1391:4;1340:86;:::o;5234:102:16:-;5285:6;5310:7;:5;:7::i;:::-;:19;;;5303:26;;5234:102;:::o;1108:175:13:-;1031:23:9;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1;;;1023:51:9;;;;;;;:::i;:::-;1228:4:13::1;1198:14;:12;:14::i;:::-;-1:-1:-1::0;;;;;1198:27:13;::::1;;::::0;;;::::1;::::0;;;;;;;;;:34;;-1:-1:-1;;1198:34:13::1;::::0;::::1;;::::0;;;::::1;::::0;;;1247:29;::::1;::::0;::::1;::::0;1198:27;;1247:29:::1;:::i;:::-;;;;;;;;1108:175:::0;:::o;2099:125:16:-;1167:13:4;:11;:13::i;:::-;1166:14;1158:36;;;;-1:-1:-1;;;1158:36:4;;;;;;;:::i;:::-;1031:23:9::1;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1::0;;;1023:51:9::1;;;;;;;:::i;:::-;2192:25:16::2;2203:13;2192:10;:25::i;:::-;2099:125:::0;:::o;3854:503:18:-;4001:7;4020:13;4036:20;:18;:20::i;:::-;4020:36;;4066:60;4092:22;;;;;;;;;;;;;;;;;4116:5;4124:1;4116:9;4066:25;:60::i;:::-;4179:8;4168:9;4156:10;-1:-1:-1;;;;;4141:63:18;;4189:7;;4198:5;4141:63;;;;;;;;:::i;:::-;;;;;;;;4214:15;4232:53;4249:9;4260:8;4270:7;;4279:5;4232:16;:53::i;:::-;4214:71;;4324:1;4295:16;:14;:16::i;:::-;:25;;;;;;;;;;;;:30;;;;;;;4312:7;-1:-1:-1;;3854:503:18;;;;;;:::o;2048:1028:15:-;1648:21:0;1728:11;;;1774:19;;1766:54;;;;-1:-1:-1;;;1766:54:0;;;;;;;:::i;:::-;2048:1028:15;;2126:17:::1;2151:19;:17;:19::i;:::-;2146:2;:24:::0;;::::1;::::0;-1:-1:-1;2207:14:15;::::1;2239:31:::0;;::::1;;2231:63;;;;-1:-1:-1::0;;;2231:63:15::1;;;;;;;:::i;:::-;2304:18;2336:32;2351:16:::0;2341:9;2336:4;;:32:::1;:::i;:::-;2325:55;;;;;;;:::i;:::-;2304:76:::0;-1:-1:-1;2391:35:15::1;;2429:16;2435:9:::0;2391:35;2429:4;;:16:::1;:::i;:::-;2391:54;;;;2456:49;2484:20;;2456:27;:49::i;:::-;2516:23;;2542;:4:::0;2547:16;2542:4;;:23:::1;:::i;:::-;2516:49:::0;;-1:-1:-1;2516:49:15;-1:-1:-1;;;;;;2660:26:15;::::1;::::0;2656:122:::1;;2702:45;2726:10;2738:8;;2702:23;:45::i;:::-;2761:7;;;;;;;;;2656:122;2792:15;:13;:15::i;:::-;2788:282;;;2831:20:::0;;2823:53:::1;;;;-1:-1:-1::0;;;2823:53:15::1;;;;;;;:::i;:::-;2788:282;;;2956:26;2973:8;;2956:16;:26::i;:::-;2996:33;3020:8;;2996:23;:33::i;:::-;3043:16;:14;:16::i;:::-;1840:1:0;;;;;;;;2048:1028:15::0;;:::o;1218:105:4:-;1031:23:9;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1;;;1023:51:9;;;;;;;:::i;:::-;1272:44:4::1;1298:11;;;;;;;;;;;;;;;;;1311:4;1272:25;:44::i;:::-;1218:105::o:0;5519:896:18:-;5742:8;5731:9;5719:10;-1:-1:-1;;;;;5699:68:18;;5752:7;;5761:5;5699:68;;;;;;;;:::i;:::-;;;;;;;;5777:15;5795:53;5812:9;5823:8;5833:7;;5842:5;5795:16;:53::i;:::-;5777:71;;5858:16;5877;:14;:16::i;:::-;:25;;;;;;;;;;;;;;-1:-1:-1;5920:12:18;5912:45;;;;-1:-1:-1;;;5912:45:18;;;;;;;:::i;:::-;5968:19;5990:28;:26;:28::i;:::-;:37;;;;;;;;;;;;;;-1:-1:-1;6045:16:18;6037:63;;;;-1:-1:-1;;;6037:63:18;;;;;;;:::i;:::-;6111:25;6153:26;:24;:26::i;:::-;6139:11;:40;6111:68;;6218:11;6197:17;:32;;6189:73;;;;-1:-1:-1;;;6189:73:18;;;;;;;:::i;:::-;6299:17;6280:15;:36;;6272:85;;;;-1:-1:-1;;;6272:85:18;;;;;;;:::i;:::-;6407:1;6396:8;:12;6368:16;:14;:16::i;:::-;:25;;;;;;;;;;:40;;;;-1:-1:-1;;;;;;;;5519:896:18:o;1487:134:13:-;1561:4;1584:14;:12;:14::i;:::-;-1:-1:-1;;;;;1584:30:13;;;;;;;;;;;;;-1:-1:-1;1584:30:13;;;;;;;1487:134::o;5678:1663:16:-;945:22:10;956:10;945;:22::i;:::-;937:48;;;;-1:-1:-1;;;937:48:10;;;;;;;:::i;:::-;5881:38:16::1;5905:13;;5881:23;:38::i;:::-;6000:13;;1376:1:14;6000:48:16;;;;;;;;;;;;;5984:12;:10;:12::i;:::-;:64;5963:130;;;;-1:-1:-1::0;;;5963:130:16::1;;;;;;;:::i;:::-;6104:27;6134:184;6200:13;;6227:81;;;;;;;;6275:15;6227:81;;;;6292:15;6227:81;;::::0;6134:52:::1;:184::i;:::-;6104:214;;6328:17;6369:13;:11;:13::i;:::-;6384:19;6358:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6348:57;;;;;;6328:77;;6437:10;:8;:10::i;:::-;-1:-1:-1::0;;;;;6423:33:16::1;;6457:9;6423:44;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6415:82;;;;-1:-1:-1::0;;;6415:82:16::1;;;;;;;:::i;:::-;6512:43;6535:19;6512:43;;;;;;:::i;:::-;;;;;;;;1423:1:14;6679:155:16;6748:4;6766:28;:13:::0;1423:1:14;6766:13:16;;:28:::1;:::i;:::-;6808:16;:14;:16::i;:::-;6679:30;:155::i;:::-;6663:171;6899:156;6968:5;6987:28;:13:::0;6663:171;6987:13;;:28:::1;:::i;:::-;7029:16;:14;:16::i;6899:156::-;6883:172;7074:36:::0;;::::1;7066:73;;;;-1:-1:-1::0;;;7066:73:16::1;;;;;;;:::i;:::-;7183:29;7198:13;;7183:7;:5;:7::i;:::-;:14:::0;:29;:14:::1;:29::i;:::-;7222:34;7259:7;:5;:7::i;:::-;7222:44;;7281:53;7296:6;:17;;;7315:6;:18;;;7281:53;;;;;;;:::i;:::-;;;;;;;;995:1:10;;;;5678:1663:16::0;;;;:::o;1592:122:18:-;1656:7;1682:16;:14;:16::i;:::-;:25;;;;;;-1:-1:-1;1682:25:18;;;;;1592:122::o;4981:532::-;5226:8;5215:9;5203:10;-1:-1:-1;;;;;5172:79:18;;5236:7;;5245:5;5172:79;;;;;;;;:::i;:::-;;;;;;;;5261:15;5279:53;5296:9;5307:8;5317:7;;5326:5;5279:16;:53::i;:::-;5261:71;;5342:16;5361;:14;:16::i;:::-;:25;;;;;;;;;;;;;;-1:-1:-1;5404:12:18;5396:45;;;;-1:-1:-1;;;5396:45:18;;;;;;;:::i;:::-;5491:15;5451:28;:26;:28::i;:::-;:37;;;;;;;;;;:55;;;;-1:-1:-1;;;;;;4981:532:18:o;2335:152::-;2392:7;2418:62;2444:35;;;;;;;;;;;;;;;;;2418:25;:62::i;1422:121:17:-;1501:35;1517:18;1501:15;:35::i;2477:120:16:-;2521:7;2547:43;2573:16;;;;;;;;;;;;;;;;;2547:25;:43::i;1006:112:4:-;1050:4;1073:38;1099:11;;;;;;;;;;;;;;;;;1073:25;:38::i;1299:117:17:-;1376:33;1397:11;1376:20;:33::i;1549:81::-;1604:19;:17;:19::i;5078:95:16:-;5122:7;5148;:5;:7::i;:::-;:18;;-1:-1:-1;5078:95:16;:::o;1289:192:13:-;1031:23:9;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1;;;1023:51:9;;;;;;;:::i;:::-;1419:5:13::1;1385:14;:12;:14::i;:::-;-1:-1:-1::0;;;;;1385:31:13;::::1;;::::0;;;::::1;::::0;;;;;;;;;:39;;-1:-1:-1;;1385:39:13::1;::::0;::::1;;::::0;;;::::1;::::0;;;1439:35;::::1;::::0;::::1;::::0;1385:31;;1439:35:::1;:::i;2859:146:18:-:0;2935:7;2961:28;:26;:28::i;1720:122::-;1784:7;1810:16;:14;:16::i;2230:183:16:-;1167:13:4;:11;:13::i;:::-;1166:14;1158:36;;;;-1:-1:-1;;;1158:36:4;;;;;;;:::i;:::-;1031:23:9::1;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1::0;;;1023:51:9::1;;;;;;;:::i;:::-;2366:40:16::2;2391:14;2366:24;:40::i;3193:118::-:0;3236:7;3262:42;3288:15;;;;;;;;;;;;;;;;;3262:25;:42::i;1636:81:17:-;1691:19;:17;:19::i;1964:129:16:-;1167:13:4;:11;:13::i;:::-;1166:14;1158:36;;;;-1:-1:-1;;;1158:36:4;;;;;;;:::i;:::-;1031:23:9::1;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1::0;;;1023:51:9::1;;;;;;;:::i;:::-;2059:27:16::2;2071:14;2059:11;:27::i;4901:118::-:0;4978:34;;;;;;;;;;;;;;;;;4901:118;:::o;1760:209:11:-;1825:14;1851:12;1893:4;1876:22;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1876:22:11;;;;;;;;;1866:33;;1876:22;1866:33;;;;1942:11;;1918:45;-1:-1:-1;;;1918:45:11:o;2423:205:3:-;2498:4;2514:32;2549:19;:17;:19::i;:::-;-1:-1:-1;;;;;2585:36:3;;;;:22;:36;;;;;;;;-1:-1:-1;;2585:36:3;;;;;;;2423:205::o;2022:168:18:-;2071:35;2125:58;2162:20;;;;;;;;;;;;;;;;;2125:36;:58::i;3500:232:16:-;3540:39;3591:16;3637;;;;;;;;;;;;;;;;;3620:34;;;;;;;;:::i;:::-;;;;-1:-1:-1;;3620:34:16;;;;;;;;;3610:45;;3620:34;3610:45;;;;;3674:52;-1:-1:-1;;3674:52:16:o;855:170:19:-;911:32;962:56;996:21;;;;;;;;;;;;;;;;;962:33;:56::i;3020:110:16:-;3074:49;3100:15;;;;;;;;;;;;;;;;;3117:5;1975:192:11;2051:12;2093:4;2076:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;2066:33;;;;;;2051:48;;2145:5;2139:4;2132:19;2118:43;;;:::o;3316:476:18:-;3543:228;;3478:7;;3543:228;;3589:10;;3622:9;;3653:5;;3680:8;;3710:7;;;;;;3543:228;;;:::i;:::-;;;;;;;;;;;;;3516:269;;;;;;3497:288;;3316:476;;;;;;;:::o;1848:168::-;1897:35;1951:58;1988:20;;;;;;;;;;;;;;;;;1951:36;:58::i;3082:540:15:-;3210:36;:23;-1:-1:-1;;;;;3210:34:15;;:36::i;:::-;3202:67;;;;-1:-1:-1;;;3202:67:15;;;;;;;:::i;:::-;3350:12;3364:23;3391;-1:-1:-1;;;;;3391:36:15;3464:24;;;3490:7;;3441:57;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;3441:57:15;;;;;;;;;;;;;;-1:-1:-1;;;;;3441:57:15;-1:-1:-1;;;;;;3441:57:15;;;;;;;;;;3391:117;;;;3441:57;3391:117;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3349:159;;;;3526:7;3542:10;3518:36;;;;;-1:-1:-1;;;3518:36:15;;;;;;;;:::i;:::-;-1:-1:-1;3572:17:15;;:10;;:22;3564:51;;;;-1:-1:-1;;;3564:51:15;;;;;;;;:::i;:::-;;3082:540;;;;;:::o;3738:105:16:-;3795:4;3818:13;:11;:13::i;:::-;:18;;;-1:-1:-1;3738:105:16;:::o;3950:266::-;4053:6;4038:21;;4030:56;;;;-1:-1:-1;;;4030:56:16;;;;;;;:::i;:::-;4096:20;4130:9;4136:2;4096:20;4130:4;;:9;:::i;:::-;4119:32;;;;;;;:::i;:::-;4096:55;-1:-1:-1;4169:17:16;4161:48;;;;-1:-1:-1;;;4161:48:16;;;;;;;:::i;:::-;3950:266;;;:::o;4322:505::-;4418:20;4452:17;4483:19;4516:39;;:::i;:::-;4568:66;;;;4579:4;4568:66;:::i;:::-;4404:230;;;;;;;;4645:25;4657:12;4645:11;:25::i;:::-;4680:29;4699:9;4680:18;:29::i;:::-;4719:26;4732:12;4719:7;:5;:7::i;:::-;:12;;:26::i;:::-;4755:23;4766:11;4755:10;:23::i;:::-;4788:32;4813:6;4788:24;:32::i;2112:305:3:-;2157:32;2192:19;:17;:19::i;:::-;2230:15;;;;;;-1:-1:-1;;;;2230:15:3;;;;2229:16;2221:48;;;;-1:-1:-1;;;2221:48:3;;;;;;;:::i;:::-;2297:4;2279:15;;:22;;-1:-1:-1;;;;2279:22:3;-1:-1:-1;;;2279:22:3;;;2387:23;2399:10;2387:11;:23::i;3011:221:18:-;3096:35;3154:71;3191:33;;;;;;;;;;;;;;;;;3154:36;:71::i;2508:151:14:-;1423:1;2590:32;;2582:70;;;;-1:-1:-1;;;2582:70:14;;;;;;;:::i;1205:1452:12:-;2151:31;;1357:7;;2081:13;;1357:7;;2151:31;;2081:13;;;;2151:31;;;:::i;:::-;;;;;;;;;;;;;2141:42;;;;;;2111:72;;2247:18;2325:19;2362:18;2398:8;:24;;;2461:8;:24;;;2440:18;:45;2291:208;;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;2291:208:12;;;;;;2268:241;;2291:208;2268:241;;;;2648:1;2626:23;;1205:1452;-1:-1:-1;;;;;;;1205:1452:12:o;2830:126:16:-;2873:7;2899:50;2928:20;;;;;;;;;;;;;;;;;2899:28;:50::i;3291:2904:14:-;3464:7;3483:26;3512:18;;3531:1;3512:21;;;;;;;;;;;;;3483:50;;3572:5;3551:18;:26;3543:67;;;;-1:-1:-1;;;3543:67:14;;;;;;;:::i;:::-;3638:1;3677:27;;;3621:14;3757:8;:80;;1942:1;3757:80;;;1602:1;3757:80;3715:132;;3857:2230;3873:17;3864:6;:26;3857:2230;;;3936:26;;;3984:47;;;3976:77;;;;-1:-1:-1;;;3976:77:14;;;;;;;:::i;:::-;4068:21;4092:18;;4111:19;4092:39;;;;;;;;;;;;;4068:63;;4169:5;4153:13;:21;4145:56;;;;-1:-1:-1;;;4145:56:14;;;;;;;:::i;:::-;4236:39;;;4258:1;4236:39;4297:38;;;;4289:76;;;;-1:-1:-1;;;4289:76:14;;;;;;;:::i;:::-;4384:8;4380:1664;;;4412:19;4482:36;4508:9;4501:6;4482:18;;:36;:::i;:::-;4465:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4434:103;;;;;;4412:125;;4745:18;;1542:1;4764:6;:40;4745:60;;;;;;;;;;;;;-1:-1:-1;;;;;4561:394:14;4626:18;;1484:1;4645:6;:42;4626:62;;;;;;;;;;;;;4561:394;4872:18;;1654:1;4891:6;:34;4872:64;4926:9;4872:64;;;;;;;:::i;:::-;4561:394;;;;;;;:::i;:::-;;;;;;;;4973:21;;;;;;;;;;;:26;;4998:1;4973:26;;;4380:1664;;;5060:19;5134:36;5160:9;5153:6;5134:18;;:36;:::i;:::-;5117:54;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;5117:54:14;;;;;;;;;5082:111;;5117:54;5082:111;;;;5248:1;5224:21;;;;;;;;;;5082:111;;-1:-1:-1;5216:64:14;;;;-1:-1:-1;;;5216:64:14;;;;;;;:::i;:::-;5302:21;;;;;;;;;;;:26;;-1:-1:-1;;5302:26:14;;;5381:18;;1826:1;5400:35;;5381:55;;;;;;;;;;;;;5365:71;;5764:18;;1882:1;5783:6;:38;5764:58;;;;;;;;;;;;;5649:18;;1773:1;5668:6;:40;5649:60;;;;;;;;;;;;;5537:18;;1715:1;5556:6;:42;5537:62;;;;;;;;;;;;;-1:-1:-1;;;;;5459:570:14;;5888:18;;1994:1;5907:6;:34;5888:64;5942:9;5888:64;;;;;;;:::i;:::-;6006:5;5459:570;;;;;;;;:::i;:::-;;;;;;;;4380:1664;;6067:9;-1:-1:-1;3857:2230:14;;-1:-1:-1;;3857:2230:14;;6114:17;6104:6;:27;6096:68;;;;-1:-1:-1;;;6096:68:14;;;;;;;:::i;:::-;-1:-1:-1;6182:6:14;;3291:2904;-1:-1:-1;;;;;;;3291:2904:14:o;1118:726:20:-;1328:1;1307:17;;;:22;;;;;;;1390:14;;1322:1:14;1390:50:20;;;;;;;;;;;;;1368:5;:17;;;1360:80;1339:147;;;;-1:-1:-1;;;1339:147:20;;;;;;;:::i;:::-;1497:41;;1541:46;1572:14;;1541:30;:46::i;:::-;1497:90;;;;1638:62;1677:22;;1638:38;:62::i;:::-;1618:16;;:82;1597:150;;;;-1:-1:-1;;;1597:150:20;;;;;;;:::i;:::-;1776:61;1814:22;;1776:37;:61::i;:::-;1757:80;;;-1:-1:-1;;;;1118:726:20:o;4337:402:3:-;1031:23:9;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1;;;1023:51:9;;;;;;;:::i;:::-;4432:10:3::1;-1:-1:-1::0;;;;;4432:32:3;::::1;;;4424:65;;;;-1:-1:-1::0;;;4424:65:3::1;;;;;;;:::i;:::-;4499:32;4534:19;:17;:19::i;:::-;4499:54;;4571:31;4583:18;4571:11;:31::i;:::-;4563:56;;;;-1:-1:-1::0;;;4563:56:3::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;4629:42:3;::::1;4674:5;4629:42:::0;;;::::1;::::0;;;;;;;;:50;;-1:-1:-1;;4629:50:3::1;::::0;;4694:38;::::1;::::0;::::1;::::0;4652:18;;4694:38:::1;:::i;:::-;;;;;;;;1084:1:9;4337:402:3::0;:::o;2917:303::-;1031:23:9;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1;;;1023:51:9;;;;;;;:::i;:::-;3002:32:3::1;3037:19;:17;:19::i;:::-;3002:54;;3075:24;3087:11;3075;:24::i;:::-;3074:25;3066:54;;;;-1:-1:-1::0;;;3066:54:3::1;;;;;;;:::i;:::-;3130:21;::::0;::::1;:35:::0;;-1:-1:-1;;;;;;3130:35:3::1;-1:-1:-1::0;;;;;3130:35:3;::::1;;::::0;;3180:33:::1;::::0;::::1;::::0;::::1;::::0;3130:35;;3180:33:::1;:::i;3782:498::-:0;3911:32;3946:19;:17;:19::i;:::-;3997:21;;;;;;-1:-1:-1;;;;;;3997:21:3;3983:10;:35;3975:71;;;;-1:-1:-1;;;3975:71:3;;;;;;;:::i;:::-;4094:21;;;;4082:34;;-1:-1:-1;;;;;4094:21:3;4082:11;:34::i;:::-;4126:21;;;:36;;-1:-1:-1;;;;;;4126:36:3;;;4239:34;;;;;;4262:10;;4239:34;:::i;2493:162:18:-;2570:78;2596:35;;;;;;;;;;;;;;;;;2633:14;2570:25;:78::i;2702:209:3:-;1031:23:9;1043:10;1031:11;:23::i;:::-;1023:51;;;;-1:-1:-1;;;1023:51:9;;;;;;;:::i;:::-;2765:32:3::1;2800:19;:17;:19::i;:::-;2829:21;::::0;::::1;:36:::0;;-1:-1:-1;;;;;;2829:36:3::1;::::0;;2880:24:::1;::::0;2765:54;;-1:-1:-1;2880:24:3::1;::::0;2861:3:::1;::::0;2880:24:::1;1084:1:9;2702:209:3:o:0;2662:112:16:-;2717:50;2743:16;;;;;;;;;;;;;;;;;2761:5;2717:25;:50::i;909:250:17:-;970:32;1014:16;1060:28;;;;;;;;;;;;;;;;;1043:46;;;;;;;;:::i;854:298:11:-;954:50;1020:16;1066:4;1049:22;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1049:22:11;;;;;;;;;1039:33;;1049:22;1039:33;;;;;1091:55;-1:-1:-1;;;1091:55:11:o;757:190:1:-;886:20;932:8;;;757:190::o;3317:130:16:-;3379:61;3412:20;;;;;;;;;;;;;;;;;3434:5;3379:32;:61::i;794:175:20:-;891:20;;872:39;;941:21;;;921:17;;;;:41;794:175::o;3539:237:3:-;3608:24;3620:11;3608;:24::i;:::-;3607:25;3599:54;;;;-1:-1:-1;;;3599:54:3;;;;;;;:::i;:::-;3663:32;3698:19;:17;:19::i;:::-;-1:-1:-1;;;;;3727:35:3;;;:22;:35;;;;;;;;-1:-1:-1;3727:35:3;;;:42;;-1:-1:-1;;3727:42:3;3765:4;3727:42;;;3539:237::o;2768:210:14:-;2872:18;;2913:58;2969:1;2872:18;2913:11;;:58;:::i;:::-;2906:65;;;;2768:210;;;;;;:::o;767:177::-;880:7;910:24;;935:1;910:27;;;;;;;;;;;;;903:34;;767:177;;;;:::o;1009:176::-;1121:7;1151:24;;1176:1;1151:27;;;;;;2767:189:11;2891:3;2858:21;2874:4;2858:15;:21::i;:::-;-1:-1:-1;;;;;2858:37:11;;2850:61;;;;-1:-1:-1;;;2850:61:11;;;;;;;:::i;:::-;2921:28;2937:4;2943:5;2921:15;:28::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o;313:352::-;;;443:3;436:4;428:6;424:17;420:27;410:2;;-1:-1;;451:12;410:2;-1:-1;481:20;;521:18;510:30;;507:2;;;-1:-1;;543:12;507:2;587:4;579:6;575:17;563:29;;638:3;587:4;;622:6;618:17;579:6;604:32;;601:41;598:2;;;655:1;;645:12;2092:241;;2196:2;2184:9;2175:7;2171:23;2167:32;2164:2;;;-1:-1;;2202:12;2164:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2254:63;2158:175;-1:-1;;;2158:175::o;2604:647::-;;;;;2777:2;2765:9;2756:7;2752:23;2748:32;2745:2;;;-1:-1;;2783:12;2745:2;2841:17;2828:31;2879:18;2871:6;2868:30;2865:2;;;-1:-1;;2901:12;2865:2;2939:80;3011:7;3002:6;2991:9;2987:22;2939:80;:::i;:::-;2921:98;;;;-1:-1;3056:2;3095:22;;2022:20;;3164:2;3203:22;2022:20;;-1:-1;2739:512;-1:-1;;;;2739:512::o;3258:257::-;;3370:2;3358:9;3349:7;3345:23;3341:32;3338:2;;;-1:-1;;3376:12;3338:2;754:6;748:13;44897:5;43085:13;43078:21;44875:5;44872:32;44862:2;;-1:-1;;44908:12;3522:241;;3626:2;3614:9;3605:7;3601:23;3597:32;3594:2;;;-1:-1;;3632:12;3594:2;-1:-1;875:20;;3588:175;-1:-1;3588:175::o;3770:365::-;;;3893:2;3881:9;3872:7;3868:23;3864:32;3861:2;;;-1:-1;;3899:12;3861:2;3957:17;3944:31;3995:18;;3987:6;3984:30;3981:2;;;-1:-1;;4017:12;3981:2;4102:6;4091:9;4087:22;;;1073:3;1066:4;1058:6;1054:17;1050:27;1040:2;;-1:-1;;1081:12;1040:2;1124:6;1111:20;3995:18;1143:6;1140:30;1137:2;;;-1:-1;;1173:12;1137:2;1268:3;3893:2;1248:17;1209:6;1234:32;;1231:41;1228:2;;;-1:-1;;1275:12;1228:2;3893;1205:17;;;;;4037:82;;-1:-1;3855:280;;-1:-1;;;;3855:280::o;4390:679::-;;;;;4564:9;4555:7;4551:23;4576:3;4551:23;4547:33;4544:2;;;-1:-1;;4583:12;4544:2;2035:6;2022:20;4635:63;;4735:2;4786:9;4782:22;217:20;242:41;277:5;242:41;:::i;:::-;4743:71;-1:-1;4851:2;4890:22;;;2022:20;;-1:-1;;;1562:19;;1558:30;1555:2;;;-1:-1;;1591:12;1555:2;;4851;40678:9;4851:2;40714:6;40710:17;40821:6;40809:10;40806:22;40785:18;40773:10;40770:34;40767:62;40764:2;;;-1:-1;;40832:12;40764:2;4851;40851:22;4959:2;5021:22;;2022:20;1702:75;;1898:22;;;;1369:20;4735:2;1860:16;;1853:74;-1:-1;4538:531;;;;-1:-1;4538:531;;1709:16;4538:531::o;5076:522::-;;;;5232:2;5220:9;5211:7;5207:23;5203:32;5200:2;;;-1:-1;;5238:12;5200:2;2035:6;2022:20;5290:63;;5418:2;5407:9;5403:18;5390:32;5442:18;5434:6;5431:30;5428:2;;;-1:-1;;5464:12;5428:2;5502:80;5574:7;5565:6;5554:9;5550:22;5502:80;:::i;:::-;5194:404;;5484:98;;-1:-1;5484:98;;-1:-1;;;;5194:404::o;5605:647::-;;;;;5778:2;5766:9;5757:7;5753:23;5749:32;5746:2;;;-1:-1;;5784:12;5746:2;2035:6;2022:20;5836:63;;5936:2;5979:9;5975:22;2022:20;5944:63;;6072:2;6061:9;6057:18;6044:32;6096:18;6088:6;6085:30;6082:2;;;-1:-1;;6118:12;6082:2;6156:80;6228:7;6219:6;6208:9;6204:22;6156:80;:::i;:::-;5740:512;;;;-1:-1;6138:98;-1:-1;;;;5740:512::o;6259:773::-;;;;;;6449:3;6437:9;6428:7;6424:23;6420:33;6417:2;;;-1:-1;;6456:12;6417:2;2035:6;2022:20;6508:63;;6608:2;6651:9;6647:22;2022:20;6616:63;;6744:2;6733:9;6729:18;6716:32;6768:18;6760:6;6757:30;6754:2;;;-1:-1;;6790:12;6754:2;6828:80;6900:7;6891:6;6880:9;6876:22;6828:80;:::i;:::-;6411:621;;;;-1:-1;6810:98;6945:2;6984:22;2022:20;;6411:621;-1:-1;;;;6411:621::o;7339:467::-;41261:19;;;7339:467;-1:-1;;;;;7587:78;;7584:2;;;-1:-1;;7668:12;7584:2;41310:4;7703:6;7699:17;43936:6;43931:3;41310:4;41305:3;41301:14;43913:30;43974:16;;;;41310:4;43974:16;43967:27;;;-1:-1;43974:16;;7471:335;-1:-1;7471:335::o;7845:503::-;;-1:-1;;;;;8129:78;;8126:2;;;-1:-1;;8210:12;8126:2;8253:4;8245:6;8241:17;43936:6;43931:3;43926;43913:30;43974:16;;;;43967:27;;;-1:-1;43974:16;;7995:353;-1:-1;7995:353::o;20524:355::-;;20719:135;20850:3;20841:6;20833;20719:135;:::i;:::-;20864:10;20700:179;-1:-1;;;;20700:179::o;21254:670::-;8538:37;;;21563:2;21554:12;;8538:37;;;;21665:12;;;8538:37;21776:12;;;8538:37;21887:12;;;21454:470::o;21931:271::-;;9234:5;40972:12;9345:52;9390:6;9385:3;9378:4;9371:5;9367:16;9345:52;:::i;:::-;9409:16;;;;;22065:137;-1:-1;;22065:137::o;22491:772::-;;8568:5;8545:3;8538:37;8568:5;22860:2;22855:3;22851:12;8538:37;8568:5;22962:12;22855:3;22962:12;8538:37;23103:135;23073:12;22855:3;23073:12;23225:6;23217;23103:135;:::i;:::-;23248:10;22751:512;-1:-1;;;;;;;22751:512::o;23270:1050::-;;8568:5;8545:3;8538:37;8568:5;23695:2;23690:3;23686:12;8538:37;8568:5;23797:12;23690:3;23797:12;8538:37;8568:5;23908:12;23690:3;23908:12;8538:37;8568:5;24019:12;23690:3;24019:12;8538:37;24160:135;24130:12;23690:3;24130:12;24282:6;24274;24160:135;:::i;:::-;24305:10;23586:734;-1:-1;;;;;;;;;23586:734::o;24327:222::-;-1:-1;;;;;43330:54;;;;7259:37;;24454:2;24439:18;;24425:124::o;24801:390::-;;24988:2;25009:17;25002:47;25063:118;24988:2;24977:9;24973:18;25167:6;25159;25063:118;:::i;25198:501::-;;25413:2;25434:17;25427:47;25488:118;25413:2;25402:9;25398:18;25592:6;25584;25488:118;:::i;:::-;25480:126;;8568:5;25685:2;25674:9;25670:18;8538:37;25384:315;;;;;;:::o;25706:210::-;43085:13;;43078:21;8421:34;;25827:2;25812:18;;25798:118::o;25923:222::-;8538:37;;;26050:2;26035:18;;26021:124::o;26152:326::-;;26307:2;26328:17;26321:47;41273:6;26307:2;26296:9;26292:18;41261:19;43936:6;43931:3;41301:14;26296:9;41301:14;43913:30;43974:16;;;41301:14;43974:16;;;43967:27;;;;44531:7;44515:14;;;-1:-1;;44511:28;9021:39;;;26278:200;-1:-1;26278:200::o;26710:310::-;;26857:2;26878:17;26871:47;9699:5;40972:12;41273:6;26857:2;26846:9;26842:18;41261:19;9793:52;9838:6;41301:14;26846:9;41301:14;26857:2;9819:5;9815:16;9793:52;:::i;:::-;44531:7;44515:14;-1:-1;;44511:28;9857:39;;;;41301:14;9857:39;;26828:192;-1:-1;;26828:192::o;27027:416::-;27227:2;27241:47;;;10500:2;27212:18;;;41261:19;-1:-1;;;41301:14;;;10516:41;10576:12;;;27198:245::o;27450:416::-;27650:2;27664:47;;;10827:2;27635:18;;;41261:19;-1:-1;;;41301:14;;;10843:40;10902:12;;;27621:245::o;27873:416::-;28073:2;28087:47;;;11153:2;28058:18;;;41261:19;-1:-1;;;41301:14;;;11169:45;11233:12;;;28044:245::o;28296:416::-;28496:2;28510:47;;;11484:2;28481:18;;;41261:19;-1:-1;;;41301:14;;;11500:39;11558:12;;;28467:245::o;28719:416::-;28919:2;28933:47;;;11809:2;28904:18;;;41261:19;-1:-1;;;41301:14;;;11825:44;11888:12;;;28890:245::o;29142:416::-;29342:2;29356:47;;;12139:2;29327:18;;;41261:19;-1:-1;;;41301:14;;;12155:42;12216:12;;;29313:245::o;29565:416::-;29765:2;29779:47;;;12467:2;29750:18;;;41261:19;-1:-1;;;41301:14;;;12483:42;12544:12;;;29736:245::o;29988:416::-;30188:2;30202:47;;;12795:2;30173:18;;;41261:19;12831:30;41301:14;;;12811:51;12881:12;;;30159:245::o;30411:416::-;30611:2;30625:47;;;13132:2;30596:18;;;41261:19;13168:34;41301:14;;;13148:55;-1:-1;;;13223:12;;;13216:28;13263:12;;;30582:245::o;30834:416::-;31034:2;31048:47;;;13514:2;31019:18;;;41261:19;-1:-1;;;41301:14;;;13530:34;13583:12;;;31005:245::o;31257:416::-;31457:2;31471:47;;;13834:2;31442:18;;;41261:19;-1:-1;;;41301:14;;;13850:43;13912:12;;;31428:245::o;31680:416::-;31880:2;31894:47;;;14163:2;31865:18;;;41261:19;-1:-1;;;41301:14;;;14179:45;14243:12;;;31851:245::o;32103:416::-;32303:2;32317:47;;;14494:2;32288:18;;;41261:19;-1:-1;;;41301:14;;;14510:45;14574:12;;;32274:245::o;32526:416::-;32726:2;32740:47;;;14825:2;32711:18;;;41261:19;14861:25;41301:14;;;14841:46;14906:12;;;32697:245::o;32949:416::-;33149:2;33163:47;;;15157:2;33134:18;;;41261:19;-1:-1;;;41301:14;;;15173:41;15233:12;;;33120:245::o;33372:416::-;33572:2;33586:47;;;15484:2;33557:18;;;41261:19;15520:30;41301:14;;;15500:51;15570:12;;;33543:245::o;33795:416::-;33995:2;34009:47;;;15821:2;33980:18;;;41261:19;15857:26;41301:14;;;15837:47;15903:12;;;33966:245::o;34218:416::-;34418:2;34432:47;;;16154:2;34403:18;;;41261:19;-1:-1;;;41301:14;;;16170:43;16232:12;;;34389:245::o;34641:416::-;34841:2;34855:47;;;16483:2;34826:18;;;41261:19;16519:27;41301:14;;;16499:48;16566:12;;;34812:245::o;35064:416::-;35264:2;35278:47;;;16817:2;35249:18;;;41261:19;16853:27;41301:14;;;16833:48;16900:12;;;35235:245::o;35487:416::-;35687:2;35701:47;;;17151:1;35672:18;;;41261:19;-1:-1;;;41301:14;;;17166:32;17217:12;;;35658:245::o;35910:416::-;36110:2;36124:47;;;17468:2;36095:18;;;41261:19;-1:-1;;;41301:14;;;17484:38;17541:12;;;36081:245::o;36333:416::-;36533:2;36547:47;;;17792:2;36518:18;;;41261:19;17828:27;41301:14;;;17808:48;17875:12;;;36504:245::o;36756:416::-;36956:2;36970:47;;;18126:2;36941:18;;;41261:19;-1:-1;;;41301:14;;;18142:42;18203:12;;;36927:245::o;37179:416::-;37379:2;37393:47;;;18454:2;37364:18;;;41261:19;18490:28;41301:14;;;18470:49;18538:12;;;37350:245::o;37602:416::-;37802:2;37816:47;;;18789:2;37787:18;;;41261:19;-1:-1;;;41301:14;;;18805:36;18860:12;;;37773:245::o;38025:416::-;38225:2;38239:47;;;19111:2;38210:18;;;41261:19;-1:-1;;;41301:14;;;19127:43;19189:12;;;38196:245::o;38448:416::-;38648:2;38662:47;;;19440:2;38633:18;;;41261:19;-1:-1;;;41301:14;;;19456:43;19518:12;;;38619:245::o;38871:416::-;39071:2;39085:47;;;19769:2;39056:18;;;41261:19;-1:-1;;;41301:14;;;19785:35;19839:12;;;39042:245::o;39294:416::-;39494:2;39508:47;;;20090:2;39479:18;;;41261:19;20126:34;41301:14;;;20106:55;-1:-1;;;20181:12;;;20174:26;20219:12;;;39465:245::o;39946:333::-;8538:37;;;40265:2;40250:18;;8538:37;40101:2;40086:18;;40072:207::o;42148:335::-;;;42314:8;42302:10;42299:24;42296:2;;;-1:-1;;42326:12;42296:2;42361:6;42351:8;42348:20;42345:2;;;-1:-1;;42371:12;42345:2;-1:-1;;42431:2;42415:19;;42403:32;;42453:25;;;;;-1:-1;42290:193::o;42490:318::-;;;42640:8;42628:10;42625:24;42622:2;;;-1:-1;;42652:12;42622:2;42687:6;42677:8;42674:20;42671:2;;;-1:-1;;42697:12;42671:2;-1:-1;;42729:31;;;42778:25;;;;;-1:-1;42616:192::o;44009:268::-;44074:1;44081:101;44095:6;44092:1;44089:13;44081:101;;;44162:11;;;44156:18;44143:11;;;44136:39;44117:2;44110:10;44081:101;;;44197:6;44194:1;44191:13;44188:2;;;44074:1;44253:6;44248:3;44244:16;44237:27;44188:2;;44058:219;;;:::o;44552:117::-;-1:-1;;;;;43330:54;;44611:35;;44601:2;;44660:1;;44650:12

ipfs://3637fdb95e44658db016c22a90a345012942099e4683371c464a194daadb85fc