Contract Source Code (Solidity)

IDE

• Blockscan IDE

Outline

• interface Structs
• library BytesLib
•    - function concat(
•    - function concatStorage(bytes storage ...
•    - function slice(
•    - function toAddress(bytes memory _byte ...
•    - function toUint8(bytes memory _bytes, ...
•    - function toUint16(bytes memory _bytes ...
•    - function toUint32(bytes memory _bytes ...
•    - function toUint64(bytes memory _bytes ...
•    - function toUint96(bytes memory _bytes ...
•    - function toUint128(bytes memory _byte ...
•    - function toUint256(bytes memory _byte ...
•    - function toBytes32(bytes memory _byte ...
•    - function equal(bytes memory _preBytes ...
•    - function equalStorage(
•  contract GovernanceStructs
•    - function parseContractUpgrade(bytes m ...
•    - function parseGuardianSetUpgrade(byte ...
•    - function parseSetMessageFee(bytes mem ...
•    - function parseTransferFees(bytes memo ...
•    - function parseRecoverChainId(bytes me ...
•  contract Events
•  contract Storage
•  contract State
•  contract Getters is State
•    - function getGuardianSet(uint32 index)
•    - function getCurrentGuardianSetIndex()
•    - function getGuardianSetExpiry()
•    - function governanceActionIsConsumed(b ...
•    - function isInitialized(address impl)
•    - function chainId()
•    - function evmChainId()
•    - function isFork()
•    - function governanceChainId()
•    - function governanceContract()
•    - function messageFee()
•    - function nextSequence(address emitter ...
•  contract Messages is Getters
•    - function parseAndVerifyVM(bytes calld ...
•    - function verifyVM(Structs.VM memory v ...
•    - function verifyVMInternal(Structs.VM ...
•    - function verifySignatures(bytes32 has ...
•    - function parseVM(bytes memory encoded ...
•    - function quorum(uint numGuardians)
•  contract Setters is State
•    - function updateGuardianSetIndex(uint3 ...
•    - function expireGuardianSet(uint32 ind ...
•    - function storeGuardianSet(Structs.Gua ...
•    - function setInitialized(address imple ...
•    - function setGovernanceActionConsumed( ...
•    - function setChainId(uint16 chainId)
•    - function setGovernanceChainId(uint16 ...
•    - function setGovernanceContract(bytes3 ...
•    - function setMessageFee(uint256 newFee ...
•    - function setNextSequence(address emit ...
•    - function setEvmChainId(uint256 evmCha ...
• interface IBeacon
•    - function implementation()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library StorageSlot
•    - function getAddressSlot(bytes32 slot)
•    - function getBooleanSlot(bytes32 slot)
•    - function getBytes32Slot(bytes32 slot)
•    - function getUint256Slot(bytes32 slot)
•    - function _getImplementation()
•    - function _setImplementation(address n ...
•    - function _upgradeTo(address newImplem ...
•    - function _upgradeToAndCall(
•    - function _upgradeToAndCallSecure(
•    - function _getAdmin()
•    - function _setAdmin(address newAdmin)
•    - function _changeAdmin(address newAdmi ...
•    - function _getBeacon()
•    - function _setBeacon(address newBeacon ...
•    - function _upgradeBeaconToAndCall(
•    - function submitContractUpgrade(bytes ...
•    - function submitSetMessageFee(bytes me ...
•    - function submitNewGuardianSet(bytes m ...
•    - function submitTransferFees(bytes mem ...
•    - function submitRecoverChainId(bytes m ...
•    - function upgradeImplementation(addres ...
•    - function verifyGovernanceVM(Structs.V ...
•  contract Implementation is Governa ... *
•    - function publishMessage(
•    - function useSequence(address emitter)
•    - function initialize()

More Options

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

/**
 *Submitted for verification at moonbase.moonscan.io on 2023-03-15
*/

// SPDX-License-Identifier: Apache 2
// File: contracts/Structs.sol

// contracts/Structs.sol

pragma solidity ^0.8.0;

interface Structs {
	struct Provider {
		uint16 chainId;
		uint16 governanceChainId;
		bytes32 governanceContract;
	}

	struct GuardianSet {
		address[] keys;
		uint32 expirationTime;
	}

	struct Signature {
		bytes32 r;
		bytes32 s;
		uint8 v;
		uint8 guardianIndex;
	}

	struct VM {
		uint8 version;
		uint32 timestamp;
		uint32 nonce;
		uint16 emitterChainId;
		bytes32 emitterAddress;
		uint64 sequence;
		uint8 consistencyLevel;
		bytes payload;

		uint32 guardianSetIndex;
		Signature[] signatures;

		bytes32 hash;
	}
}

// File: contracts/libraries/external/BytesLib.sol

/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity >=0.8.0 <0.9.0;


library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

// File: contracts/GovernanceStructs.sol

// contracts/GovernanceStructs.sol

pragma solidity ^0.8.0;


/**
 * @dev `GovernanceStructs` defines a set of structs and parsing functions
 * for minimal struct validation
 */
contract GovernanceStructs {
    using BytesLib for bytes;

    enum GovernanceAction {
        UpgradeContract,
        UpgradeGuardianset
    }

    struct ContractUpgrade {
        bytes32 module;
        uint8 action;
        uint16 chain;

        address newContract;
    }

    struct GuardianSetUpgrade {
        bytes32 module;
        uint8 action;
        uint16 chain;

        Structs.GuardianSet newGuardianSet;
        uint32 newGuardianSetIndex;
    }

    struct SetMessageFee {
        bytes32 module;
        uint8 action;
        uint16 chain;

        uint256 messageFee;
    }

    struct TransferFees {
        bytes32 module;
        uint8 action;
        uint16 chain;

        uint256 amount;
        bytes32 recipient;
    }

    struct RecoverChainId {
        bytes32 module;
        uint8 action;

        uint256 evmChainId;
        uint16 newChainId;
    }

    /// @dev Parse a contract upgrade (action 1) with minimal validation
    function parseContractUpgrade(bytes memory encodedUpgrade) public pure returns (ContractUpgrade memory cu) {
        uint index = 0;

        cu.module = encodedUpgrade.toBytes32(index);
        index += 32;

        cu.action = encodedUpgrade.toUint8(index);
        index += 1;

        require(cu.action == 1, "invalid ContractUpgrade");

        cu.chain = encodedUpgrade.toUint16(index);
        index += 2;

        cu.newContract = address(uint160(uint256(encodedUpgrade.toBytes32(index))));
        index += 32;

        require(encodedUpgrade.length == index, "invalid ContractUpgrade");
    }

    /// @dev Parse a guardianSet upgrade (action 2) with minimal validation
    function parseGuardianSetUpgrade(bytes memory encodedUpgrade) public pure returns (GuardianSetUpgrade memory gsu) {
        uint index = 0;

        gsu.module = encodedUpgrade.toBytes32(index);
        index += 32;

        gsu.action = encodedUpgrade.toUint8(index);
        index += 1;

        require(gsu.action == 2, "invalid GuardianSetUpgrade");

        gsu.chain = encodedUpgrade.toUint16(index);
        index += 2;

        gsu.newGuardianSetIndex = encodedUpgrade.toUint32(index);
        index += 4;

        uint8 guardianLength = encodedUpgrade.toUint8(index);
        index += 1;

        gsu.newGuardianSet = Structs.GuardianSet({
            keys : new address[](guardianLength),
            expirationTime : 0
        });

        for(uint i = 0; i < guardianLength; i++) {
            gsu.newGuardianSet.keys[i] = encodedUpgrade.toAddress(index);
            index += 20;
        }

        require(encodedUpgrade.length == index, "invalid GuardianSetUpgrade");
    }

    /// @dev Parse a setMessageFee (action 3) with minimal validation
    function parseSetMessageFee(bytes memory encodedSetMessageFee) public pure returns (SetMessageFee memory smf) {
        uint index = 0;

        smf.module = encodedSetMessageFee.toBytes32(index);
        index += 32;

        smf.action = encodedSetMessageFee.toUint8(index);
        index += 1;

        require(smf.action == 3, "invalid SetMessageFee");

        smf.chain = encodedSetMessageFee.toUint16(index);
        index += 2;

        smf.messageFee = encodedSetMessageFee.toUint256(index);
        index += 32;

        require(encodedSetMessageFee.length == index, "invalid SetMessageFee");
    }

    /// @dev Parse a transferFees (action 4) with minimal validation
    function parseTransferFees(bytes memory encodedTransferFees) public pure returns (TransferFees memory tf) {
        uint index = 0;

        tf.module = encodedTransferFees.toBytes32(index);
        index += 32;

        tf.action = encodedTransferFees.toUint8(index);
        index += 1;

        require(tf.action == 4, "invalid TransferFees");

        tf.chain = encodedTransferFees.toUint16(index);
        index += 2;

        tf.amount = encodedTransferFees.toUint256(index);
        index += 32;

        tf.recipient = encodedTransferFees.toBytes32(index);
        index += 32;

        require(encodedTransferFees.length == index, "invalid TransferFees");
    }

    /// @dev Parse a recoverChainId (action 5) with minimal validation
    function parseRecoverChainId(bytes memory encodedRecoverChainId) public pure returns (RecoverChainId memory rci) {
        uint index = 0;

        rci.module = encodedRecoverChainId.toBytes32(index);
        index += 32;

        rci.action = encodedRecoverChainId.toUint8(index);
        index += 1;

        require(rci.action == 5, "invalid RecoverChainId");

        rci.evmChainId = encodedRecoverChainId.toUint256(index);
        index += 32;

        rci.newChainId = encodedRecoverChainId.toUint16(index);
        index += 2;

        require(encodedRecoverChainId.length == index, "invalid RecoverChainId");
    }
}

// File: contracts/State.sol

// contracts/State.sol

pragma solidity ^0.8.0;

contract Events {
    event LogGuardianSetChanged(
        uint32 oldGuardianIndex,
        uint32 newGuardianIndex
    );

    event LogMessagePublished(
        address emitter_address,
        uint32 nonce,
        bytes payload
    );
}

contract Storage {
    struct WormholeState {
        Structs.Provider provider;

        // Mapping of guardian_set_index => guardian set
        mapping(uint32 => Structs.GuardianSet) guardianSets;

        // Current active guardian set index
        uint32 guardianSetIndex;

        // Period for which a guardian set stays active after it has been replaced
        uint32 guardianSetExpiry;

        // Sequence numbers per emitter
        mapping(address => uint64) sequences;

        // Mapping of consumed governance actions
        mapping(bytes32 => bool) consumedGovernanceActions;

        // Mapping of initialized implementations
        mapping(address => bool) initializedImplementations;

        uint256 messageFee;

        // EIP-155 Chain ID
        uint256 evmChainId;
    }
}

contract State {
    Storage.WormholeState _state;
}

// File: contracts/Getters.sol

// contracts/Getters.sol

pragma solidity ^0.8.0;

contract Getters is State {
    function getGuardianSet(uint32 index) public view returns (Structs.GuardianSet memory) {
        return _state.guardianSets[index];
    }

    function getCurrentGuardianSetIndex() public view returns (uint32) {
        return _state.guardianSetIndex;
    }

    function getGuardianSetExpiry() public view returns (uint32) {
        return _state.guardianSetExpiry;
    }

    function governanceActionIsConsumed(bytes32 hash) public view returns (bool) {
        return _state.consumedGovernanceActions[hash];
    }

    function isInitialized(address impl) public view returns (bool) {
        return _state.initializedImplementations[impl];
    }

    function chainId() public view returns (uint16) {
        return _state.provider.chainId;
    }

    function evmChainId() public view returns (uint256) {
        return _state.evmChainId;
    }

    function isFork() public view returns (bool) {
        return evmChainId() != block.chainid;
    }

    function governanceChainId() public view returns (uint16){
        return _state.provider.governanceChainId;
    }

    function governanceContract() public view returns (bytes32){
        return _state.provider.governanceContract;
    }

    function messageFee() public view returns (uint256) {
        return _state.messageFee;
    }

    function nextSequence(address emitter) public view returns (uint64) {
        return _state.sequences[emitter];
    }
}

// File: contracts/Messages.sol

// contracts/Messages.sol

pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;



contract Messages is Getters {
    using BytesLib for bytes;

    /// @dev parseAndVerifyVM serves to parse an encodedVM and wholy validate it for consumption
    function parseAndVerifyVM(bytes calldata encodedVM) public view returns (Structs.VM memory vm, bool valid, string memory reason) {
        vm = parseVM(encodedVM);
        /// setting checkHash to false as we can trust the hash field in this case given that parseVM computes and then sets the hash field above
        (valid, reason) = verifyVMInternal(vm, false);
    }

   /**
    * @dev `verifyVM` serves to validate an arbitrary vm against a valid Guardian set
    *  - it aims to make sure the VM is for a known guardianSet
    *  - it aims to ensure the guardianSet is not expired
    *  - it aims to ensure the VM has reached quorum
    *  - it aims to verify the signatures provided against the guardianSet
    *  - it aims to verify the hash field provided against the contents of the vm
    */
    function verifyVM(Structs.VM memory vm) public view returns (bool valid, string memory reason) {
        (valid, reason) = verifyVMInternal(vm, true);    
    }

    /**
    * @dev `verifyVMInternal` serves to validate an arbitrary vm against a valid Guardian set
    * if checkHash is set then the hash field of the vm is verified against the hash of its contents
    * in the case that the vm is securely parsed and the hash field can be trusted, checkHash can be set to false
    * as the check would be redundant
    */
    function verifyVMInternal(Structs.VM memory vm, bool checkHash) internal view returns (bool valid, string memory reason) {
        /// @dev Obtain the current guardianSet for the guardianSetIndex provided
        Structs.GuardianSet memory guardianSet = getGuardianSet(vm.guardianSetIndex);

        /**
         * Verify that the hash field in the vm matches with the hash of the contents of the vm if checkHash is set
         * WARNING: This hash check is critical to ensure that the vm.hash provided matches with the hash of the body.
         * Without this check, it would not be safe to call verifyVM on it's own as vm.hash can be a valid signed hash
         * but the body of the vm could be completely different from what was actually signed by the guardians
         */
        if(checkHash){
            bytes memory body = abi.encodePacked(
                vm.timestamp,
                vm.nonce,
                vm.emitterChainId,
                vm.emitterAddress,
                vm.sequence,
                vm.consistencyLevel,
                vm.payload
            );

            bytes32 vmHash = keccak256(abi.encodePacked(keccak256(body)));

            if(vmHash != vm.hash){
                return (false, "vm.hash doesn't match body");
            }
        }

       /**
        * @dev Checks whether the guardianSet has zero keys
        * WARNING: This keys check is critical to ensure the guardianSet has keys present AND to ensure
        * that guardianSet key size doesn't fall to zero and negatively impact quorum assessment.  If guardianSet
        * key length is 0 and vm.signatures length is 0, this could compromise the integrity of both vm and
        * signature verification.
        */
        if(guardianSet.keys.length == 0){
            return (false, "invalid guardian set");
        }

        /// @dev Checks if VM guardian set index matches the current index (unless the current set is expired).
        if(vm.guardianSetIndex != getCurrentGuardianSetIndex() && guardianSet.expirationTime < block.timestamp){
            return (false, "guardian set has expired");
        }

       /**
        * @dev We're using a fixed point number transformation with 1 decimal to deal with rounding.
        *   WARNING: This quorum check is critical to assessing whether we have enough Guardian signatures to validate a VM
        *   if making any changes to this, obtain additional peer review. If guardianSet key length is 0 and
        *   vm.signatures length is 0, this could compromise the integrity of both vm and signature verification.
        */
        if (vm.signatures.length < quorum(guardianSet.keys.length)){
            return (false, "no quorum");
        }

        /// @dev Verify the proposed vm.signatures against the guardianSet
        (bool signaturesValid, string memory invalidReason) = verifySignatures(vm.hash, vm.signatures, guardianSet);
        if(!signaturesValid){
            return (false, invalidReason);
        }

        /// If we are here, we've validated the VM is a valid multi-sig that matches the guardianSet.
        return (true, "");
    }


    /**
     * @dev verifySignatures serves to validate arbitrary sigatures against an arbitrary guardianSet
     *  - it intentionally does not solve for expectations within guardianSet (you should use verifyVM if you need these protections)
     *  - it intentioanlly does not solve for quorum (you should use verifyVM if you need these protections)
     *  - it intentionally returns true when signatures is an empty set (you should use verifyVM if you need these protections)
     */
    function verifySignatures(bytes32 hash, Structs.Signature[] memory signatures, Structs.GuardianSet memory guardianSet) public pure returns (bool valid, string memory reason) {
        uint8 lastIndex = 0;
        uint256 guardianCount = guardianSet.keys.length;
        for (uint i = 0; i < signatures.length; i++) {
            Structs.Signature memory sig = signatures[i];
            address signatory = ecrecover(hash, sig.v, sig.r, sig.s);
            // ecrecover returns 0 for invalid signatures. We explicitly require valid signatures to avoid unexpected
            // behaviour due to the default storage slot value also being 0.
            require(signatory != address(0), "ecrecover failed with signature");

            /// Ensure that provided signature indices are ascending only
            require(i == 0 || sig.guardianIndex > lastIndex, "signature indices must be ascending");
            lastIndex = sig.guardianIndex;

            /// @dev Ensure that the provided signature index is within the
            /// bounds of the guardianSet. This is implicitly checked by the array
            /// index operation below, so this check is technically redundant.
            /// However, reverting explicitly here ensures that a bug is not
            /// introduced accidentally later due to the nontrivial storage
            /// semantics of solidity.
            require(sig.guardianIndex < guardianCount, "guardian index out of bounds");

            /// Check to see if the signer of the signature does not match a specific Guardian key at the provided index
            if(signatory != guardianSet.keys[sig.guardianIndex]){
                return (false, "VM signature invalid");
            }
        }

        /// If we are here, we've validated that the provided signatures are valid for the provided guardianSet
        return (true, "");
    }

    /**
     * @dev parseVM serves to parse an encodedVM into a vm struct
     *  - it intentionally performs no validation functions, it simply parses raw into a struct
     */
    function parseVM(bytes memory encodedVM) public pure virtual returns (Structs.VM memory vm) {
        uint index = 0;

        vm.version = encodedVM.toUint8(index);
        index += 1;
        // SECURITY: Note that currently the VM.version is not part of the hash 
        // and for reasons described below it cannot be made part of the hash. 
        // This means that this field's integrity is not protected and cannot be trusted. 
        // This is not a problem today since there is only one accepted version, but it 
        // could be a problem if we wanted to allow other versions in the future. 
        require(vm.version == 1, "VM version incompatible"); 

        vm.guardianSetIndex = encodedVM.toUint32(index);
        index += 4;

        // Parse Signatures
        uint256 signersLen = encodedVM.toUint8(index);
        index += 1;
        vm.signatures = new Structs.Signature[](signersLen);
        for (uint i = 0; i < signersLen; i++) {
            vm.signatures[i].guardianIndex = encodedVM.toUint8(index);
            index += 1;

            vm.signatures[i].r = encodedVM.toBytes32(index);
            index += 32;
            vm.signatures[i].s = encodedVM.toBytes32(index);
            index += 32;
            vm.signatures[i].v = encodedVM.toUint8(index) + 27;
            index += 1;
        }

        /*
        Hash the body

        SECURITY: Do not change the way the hash of a VM is computed! 
        Changing it could result into two different hashes for the same observation. 
        But xDapps rely on the hash of an observation for replay protection.
        */
        bytes memory body = encodedVM.slice(index, encodedVM.length - index);
        vm.hash = keccak256(abi.encodePacked(keccak256(body)));

        // Parse the body
        vm.timestamp = encodedVM.toUint32(index);
        index += 4;

        vm.nonce = encodedVM.toUint32(index);
        index += 4;

        vm.emitterChainId = encodedVM.toUint16(index);
        index += 2;

        vm.emitterAddress = encodedVM.toBytes32(index);
        index += 32;

        vm.sequence = encodedVM.toUint64(index);
        index += 8;

        vm.consistencyLevel = encodedVM.toUint8(index);
        index += 1;

        vm.payload = encodedVM.slice(index, encodedVM.length - index);
    }

    /**
     * @dev quorum serves solely to determine the number of signatures required to acheive quorum
     */
    function quorum(uint numGuardians) public pure virtual returns (uint numSignaturesRequiredForQuorum) {
        // The max number of guardians is 255
        require(numGuardians < 256, "too many guardians");
        return ((numGuardians * 2) / 3) + 1;
    }
}

// File: contracts/Setters.sol

// contracts/Setters.sol

pragma solidity ^0.8.0;

contract Setters is State {
    function updateGuardianSetIndex(uint32 newIndex) internal {
        _state.guardianSetIndex = newIndex;
    }

    function expireGuardianSet(uint32 index) internal {
        _state.guardianSets[index].expirationTime = uint32(block.timestamp) + 86400;
    }

    function storeGuardianSet(Structs.GuardianSet memory set, uint32 index) internal {
        uint setLength = set.keys.length;
        for (uint i = 0; i < setLength; i++) {
            require(set.keys[i] != address(0), "Invalid key");
        }
        _state.guardianSets[index] = set;
    }

    function setInitialized(address implementatiom) internal {
        _state.initializedImplementations[implementatiom] = true;
    }

    function setGovernanceActionConsumed(bytes32 hash) internal {
        _state.consumedGovernanceActions[hash] = true;
    }

    function setChainId(uint16 chainId) internal {
        _state.provider.chainId = chainId;
    }

    function setGovernanceChainId(uint16 chainId) internal {
        _state.provider.governanceChainId = chainId;
    }

    function setGovernanceContract(bytes32 governanceContract) internal {
        _state.provider.governanceContract = governanceContract;
    }

    function setMessageFee(uint256 newFee) internal {
        _state.messageFee = newFee;
    }

    function setNextSequence(address emitter, uint64 sequence) internal {
        _state.sequences[emitter] = sequence;
    }

    function setEvmChainId(uint256 evmChainId) internal {
        require(evmChainId == block.chainid, "invalid evmChainId");
        _state.evmChainId = evmChainId;
    }
}

// File: @openzeppelin/contracts/proxy/beacon/IBeacon.sol


pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// File: @openzeppelin/contracts/utils/Address.sol


pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/StorageSlot.sol


pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

// File: @openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol


pragma solidity ^0.8.2;



/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967Upgrade {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallSecure(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        address oldImplementation = _getImplementation();

        // Initial upgrade and setup call
        _setImplementation(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }

        // Perform rollback test if not already in progress
        StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
        if (!rollbackTesting.value) {
            // Trigger rollback using upgradeTo from the new implementation
            rollbackTesting.value = true;
            Address.functionDelegateCall(
                newImplementation,
                abi.encodeWithSignature("upgradeTo(address)", oldImplementation)
            );
            rollbackTesting.value = false;
            // Check rollback was effective
            require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
            // Finally reset to the new implementation and log the upgrade
            _upgradeTo(newImplementation);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// File: contracts/Governance.sol

// contracts/Governance.sol

pragma solidity ^0.8.0;




/**
 * @dev `Governance` defines a means to enacting changes to the core bridge contract,
 * guardianSets, message fees, and transfer fees
 */
abstract contract Governance is GovernanceStructs, Messages, Setters, ERC1967Upgrade {
    event ContractUpgraded(address indexed oldContract, address indexed newContract);
    event GuardianSetAdded(uint32 indexed index);

    // "Core" (left padded)
    bytes32 constant module = 0x00000000000000000000000000000000000000000000000000000000436f7265;

    /**
     * @dev Upgrades a contract via Governance VAA/VM
     */
    function submitContractUpgrade(bytes memory _vm) public {
        require(!isFork(), "invalid fork");

        Structs.VM memory vm = parseVM(_vm);

        // Verify the VAA is valid before processing it
        (bool isValid, string memory reason) = verifyGovernanceVM(vm);
        require(isValid, reason);

        GovernanceStructs.ContractUpgrade memory upgrade = parseContractUpgrade(vm.payload);

        // Verify the VAA is for this module
        require(upgrade.module == module, "Invalid Module");

        // Verify the VAA is for this chain
        require(upgrade.chain == chainId(), "Invalid Chain");

        // Record the governance action as consumed
        setGovernanceActionConsumed(vm.hash);

        // Upgrades the implementation to the new contract
        upgradeImplementation(upgrade.newContract);
    }

    /**
     * @dev Sets a `messageFee` via Governance VAA/VM
     */
    function submitSetMessageFee(bytes memory _vm) public {
        Structs.VM memory vm = parseVM(_vm);

        // Verify the VAA is valid before processing it
        (bool isValid, string memory reason) = verifyGovernanceVM(vm);
        require(isValid, reason);

        GovernanceStructs.SetMessageFee memory upgrade = parseSetMessageFee(vm.payload);

        // Verify the VAA is for this module
        require(upgrade.module == module, "Invalid Module");

        // Verify the VAA is for this chain
        require(upgrade.chain == chainId() && !isFork(), "Invalid Chain");

        // Record the governance action as consumed to prevent reentry
        setGovernanceActionConsumed(vm.hash);

        // Updates the messageFee
        setMessageFee(upgrade.messageFee);
    }

    /**
     * @dev Deploys a new `guardianSet` via Governance VAA/VM
     */
    function submitNewGuardianSet(bytes memory _vm) public {
        Structs.VM memory vm = parseVM(_vm);

        // Verify the VAA is valid before processing it
        (bool isValid, string memory reason) = verifyGovernanceVM(vm);
        require(isValid, reason);

        GovernanceStructs.GuardianSetUpgrade memory upgrade = parseGuardianSetUpgrade(vm.payload);

        // Verify the VAA is for this module
        require(upgrade.module == module, "invalid Module");

        // Verify the VAA is for this chain
        require((upgrade.chain == chainId() && !isFork()) || upgrade.chain == 0, "invalid Chain");

        // Verify the Guardian Set keys are not empty, this guards
        // against the accidential upgrade to an empty GuardianSet
        require(upgrade.newGuardianSet.keys.length > 0, "new guardian set is empty");

        // Verify that the index is incrementing via a predictable +1 pattern
        require(upgrade.newGuardianSetIndex == getCurrentGuardianSetIndex() + 1, "index must increase in steps of 1");

        // Record the governance action as consumed to prevent reentry
        setGovernanceActionConsumed(vm.hash);

        // Trigger a time-based expiry of current guardianSet
        expireGuardianSet(getCurrentGuardianSetIndex());

        // Add the new guardianSet to guardianSets
        storeGuardianSet(upgrade.newGuardianSet, upgrade.newGuardianSetIndex);

        // Makes the new guardianSet effective
        updateGuardianSetIndex(upgrade.newGuardianSetIndex);
    }

    /**
     * @dev Submits transfer fees to the recipient via Governance VAA/VM
     */
    function submitTransferFees(bytes memory _vm) public {
        Structs.VM memory vm = parseVM(_vm);

        // Verify the VAA is valid before processing it
        (bool isValid, string memory reason) = verifyGovernanceVM(vm);
        require(isValid, reason);

        // Obtains the transfer from the VAA payload
        GovernanceStructs.TransferFees memory transfer = parseTransferFees(vm.payload);

        // Verify the VAA is for this module
        require(transfer.module == module, "invalid Module");

        // Verify the VAA is for this chain
        require((transfer.chain == chainId() && !isFork()) || transfer.chain == 0, "invalid Chain");

        // Record the governance action as consumed to prevent reentry
        setGovernanceActionConsumed(vm.hash);

        // Obtains the recipient address to be paid transfer fees
        address payable recipient = payable(address(uint160(uint256(transfer.recipient))));

        // Transfers transfer fees to the recipient
        recipient.transfer(transfer.amount);
    }

    /**
    * @dev Updates the `chainId` and `evmChainId` on a forked chain via Governance VAA/VM
    */
    function submitRecoverChainId(bytes memory _vm) public {
        require(isFork(), "not a fork");

        Structs.VM memory vm = parseVM(_vm);

        // Verify the VAA is valid before processing it
        (bool isValid, string memory reason) = verifyGovernanceVM(vm);
        require(isValid, reason);

        GovernanceStructs.RecoverChainId memory rci = parseRecoverChainId(vm.payload);

        // Verify the VAA is for this module
        require(rci.module == module, "invalid Module");

        // Verify the VAA is for this chain
        require(rci.evmChainId == block.chainid, "invalid EVM Chain");

        // Record the governance action as consumed to prevent reentry
        setGovernanceActionConsumed(vm.hash);

        // Update the chainIds
        setEvmChainId(rci.evmChainId);
        setChainId(rci.newChainId);
    }

    /**
     * @dev Upgrades the `currentImplementation` with a `newImplementation`
     */
    function upgradeImplementation(address newImplementation) internal {
        address currentImplementation = _getImplementation();

        _upgradeTo(newImplementation);

        // Call initialize function of the new implementation
        (bool success, bytes memory reason) = newImplementation.delegatecall(abi.encodeWithSignature("initialize()"));

        require(success, string(reason));

        emit ContractUpgraded(currentImplementation, newImplementation);
    }

    /**
     * @dev Verifies a Governance VAA/VM is valid
     */
    function verifyGovernanceVM(Structs.VM memory vm) internal view returns (bool, string memory){
        // Verify the VAA is valid
        (bool isValid, string memory reason) = verifyVM(vm);
        if (!isValid){
            return (false, reason);
        }

        // only current guardianset can sign governance packets
        if (vm.guardianSetIndex != getCurrentGuardianSetIndex()) {
            return (false, "not signed by current guardian set");
        }

        // Verify the VAA is from the governance chain (Solana)
        if (uint16(vm.emitterChainId) != governanceChainId()) {
            return (false, "wrong governance chain");
        }

        // Verify the emitter contract is the governance contract (0x4 left padded)
        if (vm.emitterAddress != governanceContract()) {
            return (false, "wrong governance contract");
        }

        // Verify this governance action hasn't already been
        // consumed to prevent reentry and replay
        if (governanceActionIsConsumed(vm.hash)){
            return (false, "governance action already consumed");
        }

        // Confirm the governance VAA/VM is valid
        return (true, "");
    }
}

// File: contracts/Implementation.sol

// contracts/Implementation.sol

pragma solidity ^0.8.0;

contract Implementation is Governance {
    event LogMessagePublished(address indexed sender, uint64 sequence, uint32 nonce, bytes payload, uint8 consistencyLevel);

    // Publish a message to be attested by the Wormhole network
    function publishMessage(
        uint32 nonce,
        bytes memory payload,
        uint8 consistencyLevel
    ) public payable returns (uint64 sequence) {
        // check fee
        require(msg.value == messageFee(), "invalid fee");

        sequence = useSequence(msg.sender);
        // emit log
        emit LogMessagePublished(msg.sender, sequence, nonce, payload, consistencyLevel);
    }

    function useSequence(address emitter) internal returns (uint64 sequence) {
        sequence = nextSequence(emitter);
        setNextSequence(emitter, sequence + 1);
    }

    function initialize() initializer public virtual {
        // this function needs to be exposed for an upgrade to pass
        if (evmChainId() == 0) {
            uint256 evmChainId;
            uint16 chain = chainId();

            // Wormhole chain ids explicitly enumerated
            if        (chain == 2)  { evmChainId = 1;          // ethereum
            } else if (chain == 4)  { evmChainId = 56;         // bsc
            } else if (chain == 5)  { evmChainId = 137;        // polygon
            } else if (chain == 6)  { evmChainId = 43114;      // avalanche
            } else if (chain == 7)  { evmChainId = 42262;      // oasis
            } else if (chain == 9)  { evmChainId = 1313161554; // aurora
            } else if (chain == 10) { evmChainId = 250;        // fantom
            } else if (chain == 11) { evmChainId = 686;        // karura
            } else if (chain == 12) { evmChainId = 787;        // acala
            } else if (chain == 13) { evmChainId = 8217;       // klaytn
            } else if (chain == 14) { evmChainId = 42220;      // celo
            } else if (chain == 16) { evmChainId = 1284;       // moonbeam
            } else if (chain == 17) { evmChainId = 245022934;  // neon
            } else if (chain == 23) { evmChainId = 42161;      // arbitrum
            } else if (chain == 24) { evmChainId = 10;         // optimism
            } else if (chain == 25) { evmChainId = 100;        // gnosis
            } else {
                revert("Unknown chain id.");
            }

            setEvmChainId(evmChainId);
        }
    }

    modifier initializer() {
        address implementation = ERC1967Upgrade._getImplementation();

        require(
            !isInitialized(implementation),
            "already initialized"
        );

        setInitialized(implementation);

        _;
    }

    fallback() external payable {revert("unsupported");}

    receive() external payable {revert("the Wormhole contract does not accept assets");}
}

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldContract","type":"address"},{"indexed":true,"internalType":"address","name":"newContract","type":"address"}],"name":"ContractUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint32","name":"index","type":"uint32"}],"name":"GuardianSetAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint64","name":"sequence","type":"uint64"},{"indexed":false,"internalType":"uint32","name":"nonce","type":"uint32"},{"indexed":false,"internalType":"bytes","name":"payload","type":"bytes"},{"indexed":false,"internalType":"uint8","name":"consistencyLevel","type":"uint8"}],"name":"LogMessagePublished","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"chainId","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"evmChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentGuardianSetIndex","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"index","type":"uint32"}],"name":"getGuardianSet","outputs":[{"components":[{"internalType":"address[]","name":"keys","type":"address[]"},{"internalType":"uint32","name":"expirationTime","type":"uint32"}],"internalType":"struct Structs.GuardianSet","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGuardianSetExpiry","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"governanceActionIsConsumed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governanceChainId","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governanceContract","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isFork","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"impl","type":"address"}],"name":"isInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"messageFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"emitter","type":"address"}],"name":"nextSequence","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVM","type":"bytes"}],"name":"parseAndVerifyVM","outputs":[{"components":[{"internalType":"uint8","name":"version","type":"uint8"},{"internalType":"uint32","name":"timestamp","type":"uint32"},{"internalType":"uint32","name":"nonce","type":"uint32"},{"internalType":"uint16","name":"emitterChainId","type":"uint16"},{"internalType":"bytes32","name":"emitterAddress","type":"bytes32"},{"internalType":"uint64","name":"sequence","type":"uint64"},{"internalType":"uint8","name":"consistencyLevel","type":"uint8"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"uint32","name":"guardianSetIndex","type":"uint32"},{"components":[{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"uint8","name":"guardianIndex","type":"uint8"}],"internalType":"struct Structs.Signature[]","name":"signatures","type":"tuple[]"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"internalType":"struct Structs.VM","name":"vm","type":"tuple"},{"internalType":"bool","name":"valid","type":"bool"},{"internalType":"string","name":"reason","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedUpgrade","type":"bytes"}],"name":"parseContractUpgrade","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint16","name":"chain","type":"uint16"},{"internalType":"address","name":"newContract","type":"address"}],"internalType":"struct GovernanceStructs.ContractUpgrade","name":"cu","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedUpgrade","type":"bytes"}],"name":"parseGuardianSetUpgrade","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint16","name":"chain","type":"uint16"},{"components":[{"internalType":"address[]","name":"keys","type":"address[]"},{"internalType":"uint32","name":"expirationTime","type":"uint32"}],"internalType":"struct Structs.GuardianSet","name":"newGuardianSet","type":"tuple"},{"internalType":"uint32","name":"newGuardianSetIndex","type":"uint32"}],"internalType":"struct GovernanceStructs.GuardianSetUpgrade","name":"gsu","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedRecoverChainId","type":"bytes"}],"name":"parseRecoverChainId","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint256","name":"evmChainId","type":"uint256"},{"internalType":"uint16","name":"newChainId","type":"uint16"}],"internalType":"struct GovernanceStructs.RecoverChainId","name":"rci","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedSetMessageFee","type":"bytes"}],"name":"parseSetMessageFee","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint16","name":"chain","type":"uint16"},{"internalType":"uint256","name":"messageFee","type":"uint256"}],"internalType":"struct GovernanceStructs.SetMessageFee","name":"smf","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedTransferFees","type":"bytes"}],"name":"parseTransferFees","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint16","name":"chain","type":"uint16"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"recipient","type":"bytes32"}],"internalType":"struct GovernanceStructs.TransferFees","name":"tf","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVM","type":"bytes"}],"name":"parseVM","outputs":[{"components":[{"internalType":"uint8","name":"version","type":"uint8"},{"internalType":"uint32","name":"timestamp","type":"uint32"},{"internalType":"uint32","name":"nonce","type":"uint32"},{"internalType":"uint16","name":"emitterChainId","type":"uint16"},{"internalType":"bytes32","name":"emitterAddress","type":"bytes32"},{"internalType":"uint64","name":"sequence","type":"uint64"},{"internalType":"uint8","name":"consistencyLevel","type":"uint8"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"uint32","name":"guardianSetIndex","type":"uint32"},{"components":[{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"uint8","name":"guardianIndex","type":"uint8"}],"internalType":"struct Structs.Signature[]","name":"signatures","type":"tuple[]"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"internalType":"struct Structs.VM","name":"vm","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint32","name":"nonce","type":"uint32"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"uint8","name":"consistencyLevel","type":"uint8"}],"name":"publishMessage","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"numGuardians","type":"uint256"}],"name":"quorum","outputs":[{"internalType":"uint256","name":"numSignaturesRequiredForQuorum","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"_vm","type":"bytes"}],"name":"submitContractUpgrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_vm","type":"bytes"}],"name":"submitNewGuardianSet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_vm","type":"bytes"}],"name":"submitRecoverChainId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_vm","type":"bytes"}],"name":"submitSetMessageFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_vm","type":"bytes"}],"name":"submitTransferFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"},{"components":[{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"uint8","name":"guardianIndex","type":"uint8"}],"internalType":"struct Structs.Signature[]","name":"signatures","type":"tuple[]"},{"components":[{"internalType":"address[]","name":"keys","type":"address[]"},{"internalType":"uint32","name":"expirationTime","type":"uint32"}],"internalType":"struct Structs.GuardianSet","name":"guardianSet","type":"tuple"}],"name":"verifySignatures","outputs":[{"internalType":"bool","name":"valid","type":"bool"},{"internalType":"string","name":"reason","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"version","type":"uint8"},{"internalType":"uint32","name":"timestamp","type":"uint32"},{"internalType":"uint32","name":"nonce","type":"uint32"},{"internalType":"uint16","name":"emitterChainId","type":"uint16"},{"internalType":"bytes32","name":"emitterAddress","type":"bytes32"},{"internalType":"uint64","name":"sequence","type":"uint64"},{"internalType":"uint8","name":"consistencyLevel","type":"uint8"},{"internalType":"bytes","name":"payload","type":"bytes"},{"internalType":"uint32","name":"guardianSetIndex","type":"uint32"},{"components":[{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"uint8","name":"guardianIndex","type":"uint8"}],"internalType":"struct Structs.Signature[]","name":"signatures","type":"tuple[]"},{"internalType":"bytes32","name":"hash","type":"bytes32"}],"internalType":"struct Structs.VM","name":"vm","type":"tuple"}],"name":"verifyVM","outputs":[{"internalType":"bool","name":"valid","type":"bool"},{"internalType":"string","name":"reason","type":"string"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

608060405234801561001057600080fd5b506138ba806100206000396000f3fe6080604052600436106101c65760003560e01c806393df337e116100f7578063cb4cfea811610095578063f42bc64111610064578063f42bc64114610712578063f8ce560a14610732578063f951975a14610752578063fbe3c2cd1461077f5761022d565b8063cb4cfea814610647578063d60b347f146106a1578063e039f224146106da578063eb8d3f12146106ef5761022d565b8063a9e11893116100d1578063a9e11893146105c3578063b172b222146105f0578063b19a437e14610605578063c0fd8bde146106185761022d565b806393df337e1461055b5780639a8a05921461057b578063a0cce1b3146105a35761022d565b80634fdc60fa1161016457806364d42b171161013e57806364d42b17146104e35780636606b4e0146104f85780638129fc1c14610518578063875be02a1461052d5761022d565b80634fdc60fa14610406578063515f3247146104695780635cb8cae2146104c35761022d565b80631a90a219116101a05780631a90a219146103245780631cfe7951146103435780632c3c02a41461036f5780634cf842b5146103af5761022d565b80630319e59c1461026357806304ca84cf146102d5578063178149e7146103025761022d565b3661022d5760405162461bcd60e51b815260206004820152602c60248201527f74686520576f726d686f6c6520636f6e747261637420646f6573206e6f74206160448201526b63636570742061737365747360a01b60648201526084015b60405180910390fd5b60405162461bcd60e51b815260206004820152600b60248201526a1d5b9cdd5c1c1bdc9d195960aa1b6044820152606401610224565b34801561026f57600080fd5b5061028361027e36600461308b565b61079e565b6040516102cc9190600060a0820190508251825260ff602084015116602083015261ffff6040840151166040830152606083015160608301526080830151608083015292915050565b60405180910390f35b3480156102e157600080fd5b506102f56102f036600461308b565b6108f4565b6040516102cc9190613530565b34801561030e57600080fd5b5061032261031d36600461308b565b610b27565b005b34801561033057600080fd5b506007545b6040519081526020016102cc565b34801561034f57600080fd5b5060035463ffffffff165b60405163ffffffff90911681526020016102cc565b34801561037b57600080fd5b5061039f61038a366004612f00565b60009081526005602052604090205460ff1690565b60405190151581526020016102cc565b3480156103bb57600080fd5b506103ee6103ca366004612edf565b6001600160a01b03166000908152600460205260409020546001600160401b031690565b6040516001600160401b0390911681526020016102cc565b34801561041257600080fd5b5061042661042136600461308b565b610c60565b6040516102cc91908151815260208083015160ff169082015260408083015161ffff16908201526060918201516001600160a01b03169181019190915260800190565b34801561047557600080fd5b5061048961048436600461308b565b610d9c565b6040516102cc91908151815260208083015160ff169082015260408083015161ffff16908201526060918201519181019190915260800190565b3480156104cf57600080fd5b506103226104de36600461308b565b610ecb565b3480156104ef57600080fd5b50600854610335565b34801561050457600080fd5b5061032261051336600461308b565b611010565b34801561052457600080fd5b50610322611220565b34801561053957600080fd5b5061054d6105483660046130c5565b6114b4565b6040516102cc9291906134da565b34801561056757600080fd5b5061032261057636600461308b565b6114cd565b34801561058757600080fd5b5060005461ffff165b60405161ffff90911681526020016102cc565b3480156105af57600080fd5b5061054d6105be366004612f18565b611609565b3480156105cf57600080fd5b506105e36105de36600461308b565b6118a0565b6040516102cc91906135a0565b3480156105fc57600080fd5b50600154610335565b6103ee6106133660046131fe565b611c7e565b34801561062457600080fd5b5061063861063336600461301f565b611d1e565b6040516102cc939291906135b3565b34801561065357600080fd5b5061066761066236600461308b565b611d82565b6040516102cc91908151815260208083015160ff16908201526040808301519082015260609182015161ffff169181019190915260800190565b3480156106ad57600080fd5b5061039f6106bc366004612edf565b6001600160a01b031660009081526006602052604090205460ff1690565b3480156106e657600080fd5b5061039f611eb3565b3480156106fb57600080fd5b50600354640100000000900463ffffffff1661035a565b34801561071e57600080fd5b5061032261072d36600461308b565b611ec6565b34801561073e57600080fd5b5061033561074d366004612f00565b611fd8565b34801561075e57600080fd5b5061077261076d3660046131e4565b612048565b6040516102cc919061358d565b34801561078b57600080fd5b5060005462010000900461ffff16610590565b6040805160a0810182526000808252602082018190529181018290526060810182905260808101829052906107d383826120e7565b82526107e06020826136ec565b90506107ec8382612145565b60ff1660208301526107ff6001826136ec565b9050816020015160ff1660041461084f5760405162461bcd60e51b8152602060048201526014602482015273696e76616c6964205472616e736665724665657360601b6044820152606401610224565b61085983826121a1565b61ffff16604083015261086d6002826136ec565b905061087983826121fe565b60608301526108896020826136ec565b905061089583826120e7565b60808301526108a56020826136ec565b9050808351146108ee5760405162461bcd60e51b8152602060048201526014602482015273696e76616c6964205472616e736665724665657360601b6044820152606401610224565b50919050565b6108fc612c2d565b600061090883826120e7565b82526109156020826136ec565b90506109218382612145565b60ff1660208301526109346001826136ec565b9050816020015160ff1660021461098d5760405162461bcd60e51b815260206004820152601a60248201527f696e76616c696420477561726469616e536574557067726164650000000000006044820152606401610224565b61099783826121a1565b61ffff1660408301526109ab6002826136ec565b90506109b78382612253565b63ffffffff1660808301526109cd6004826136ec565b905060006109db8483612145565b90506109e86001836136ec565b915060405180604001604052808260ff166001600160401b03811115610a1e57634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610a47578160200160208202803683370190505b5081526000602090910181905260608501919091525b8160ff16811015610acf57610a7285846122b0565b606085015151805183908110610a9857634e487b7160e01b600052603260045260246000fd5b6001600160a01b0390921660209283029190910190910152610abb6014846136ec565b925080610ac7816137f9565b915050610a5d565b5081845114610b205760405162461bcd60e51b815260206004820152601a60248201527f696e76616c696420477561726469616e536574557067726164650000000000006044820152606401610224565b5050919050565b610b2f611eb3565b610b685760405162461bcd60e51b815260206004820152600a6024820152696e6f74206120666f726b60b01b6044820152606401610224565b6000610b73826118a0565b9050600080610b8183612315565b91509150818190610ba55760405162461bcd60e51b815260040161022491906134f5565b506000610bb58460e00151611d82565b805190915063436f726514610bdc5760405162461bcd60e51b815260040161022490613508565b46816040015114610c235760405162461bcd60e51b815260206004820152601160248201527034b73b30b634b21022ab269021b430b4b760791b6044820152606401610224565b610c3184610140015161248b565b610c3e81604001516124a6565b60608101516000805461ffff191661ffff9092169190911790555b5050505050565b604080516080810182526000808252602082018190529181018290526060810182905290610c8e83826120e7565b8252610c9b6020826136ec565b9050610ca78382612145565b60ff166020830152610cba6001826136ec565b9050816020015160ff16600114610d0d5760405162461bcd60e51b8152602060048201526017602482015276696e76616c696420436f6e74726163745570677261646560481b6044820152606401610224565b610d1783826121a1565b61ffff166040830152610d2b6002826136ec565b9050610d3783826120e7565b6001600160a01b03166060830152610d506020826136ec565b9050808351146108ee5760405162461bcd60e51b8152602060048201526017602482015276696e76616c696420436f6e74726163745570677261646560481b6044820152606401610224565b604080516080810182526000808252602082018190529181018290526060810182905290610dca83826120e7565b8252610dd76020826136ec565b9050610de38382612145565b60ff166020830152610df66001826136ec565b9050816020015160ff16600314610e475760405162461bcd60e51b8152602060048201526015602482015274696e76616c6964205365744d65737361676546656560581b6044820152606401610224565b610e5183826121a1565b61ffff166040830152610e656002826136ec565b9050610e7183826121fe565b6060830152610e816020826136ec565b9050808351146108ee5760405162461bcd60e51b8152602060048201526015602482015274696e76616c6964205365744d65737361676546656560581b6044820152606401610224565b610ed3611eb3565b15610f0f5760405162461bcd60e51b815260206004820152600c60248201526b696e76616c696420666f726b60a01b6044820152606401610224565b6000610f1a826118a0565b9050600080610f2883612315565b91509150818190610f4c5760405162461bcd60e51b815260040161022491906134f5565b506000610f5c8460e00151610c60565b805190915063436f726514610fa45760405162461bcd60e51b815260206004820152600e60248201526d496e76616c6964204d6f64756c6560901b6044820152606401610224565b60005461ffff1661ffff16816040015161ffff1614610ff55760405162461bcd60e51b815260206004820152600d60248201526c24b73b30b634b21021b430b4b760991b6044820152606401610224565b61100384610140015161248b565b610c5981606001516124ef565b600061101b826118a0565b905060008061102983612315565b9150915081819061104d5760405162461bcd60e51b815260040161022491906134f5565b50600061105d8460e001516108f4565b805190915063436f7265146110845760405162461bcd60e51b815260040161022490613508565b60005461ffff1661ffff16816040015161ffff161480156110aa57506110a8611eb3565b155b806110bb5750604081015161ffff16155b6110f75760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b21021b430b4b760991b6044820152606401610224565b6060810151515161114a5760405162461bcd60e51b815260206004820152601960248201527f6e657720677561726469616e2073657420697320656d707479000000000000006044820152606401610224565b60035463ffffffff1661115e906001613704565b63ffffffff16816080015163ffffffff16146111c65760405162461bcd60e51b815260206004820152602160248201527f696e646578206d75737420696e63726561736520696e207374657073206f66206044820152603160f81b6064820152608401610224565b6111d484610140015161248b565b6111eb6111e660035463ffffffff1690565b61261c565b6111fd81606001518260800151612654565b60808101516003805463ffffffff191663ffffffff909216919091179055610c59565b60006112537f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b9050611277816001600160a01b031660009081526006602052604090205460ff1690565b156112ba5760405162461bcd60e51b8152602060048201526013602482015272185b1c9958591e481a5b9a5d1a585b1a5e9959606a1b6044820152606401610224565b6112e2816001600160a01b03166000908152600660205260409020805460ff19166001179055565b6008546114b1576000806112f960005461ffff1690565b90508061ffff166002141561131157600191506114a5565b8061ffff166004141561132757603891506114a5565b8061ffff166005141561133d57608991506114a5565b8061ffff16600614156113545761a86a91506114a5565b8061ffff166007141561136b5761a51691506114a5565b8061ffff166009141561138457634e45415291506114a5565b8061ffff16600a141561139a5760fa91506114a5565b8061ffff16600b14156113b1576102ae91506114a5565b8061ffff16600c14156113c85761031391506114a5565b8061ffff16600d14156113df5761201991506114a5565b8061ffff16600e14156113f65761a4ec91506114a5565b8061ffff166010141561140d5761050491506114a5565b8061ffff166011141561142657630e9ac0d691506114a5565b8061ffff166017141561143d5761a4b191506114a5565b8061ffff166018141561145357600a91506114a5565b8061ffff166019141561146957606491506114a5565b60405162461bcd60e51b81526020600482015260116024820152702ab735b737bbb71031b430b4b71034b21760791b6044820152606401610224565b6114ae826124a6565b50505b50565b600060606114c383600161273d565b9094909350915050565b60006114d8826118a0565b90506000806114e683612315565b9150915081819061150a5760405162461bcd60e51b815260040161022491906134f5565b50600061151a8460e0015161079e565b805190915063436f7265146115415760405162461bcd60e51b815260040161022490613508565b60005461ffff1661ffff16816040015161ffff161480156115675750611565611eb3565b155b806115785750604081015161ffff16155b6115b45760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b21021b430b4b760991b6044820152606401610224565b6115c284610140015161248b565b608081015160608201516040516001600160a01b0383169180156108fc02916000818181858888f19350505050158015611600573d6000803e3d6000fd5b50505050505050565b8051516000906060908290815b865181101561187e57600087828151811061164157634e487b7160e01b600052603260045260246000fd5b60200260200101519050600060018a83604001518460000151856020015160405160008152602001604052604051611695949392919093845260ff9290921660208401526040830152606082015260800190565b6020604051602081039080840390855afa1580156116b7573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b03811661171a5760405162461bcd60e51b815260206004820152601f60248201527f65637265636f766572206661696c65642077697468207369676e6174757265006044820152606401610224565b82158061173057508460ff16826060015160ff16115b6117885760405162461bcd60e51b815260206004820152602360248201527f7369676e617475726520696e6469636573206d75737420626520617363656e64604482015262696e6760e81b6064820152608401610224565b6060820151945060ff851684116117e15760405162461bcd60e51b815260206004820152601c60248201527f677561726469616e20696e646578206f7574206f6620626f756e6473000000006044820152606401610224565b8760000151826060015160ff168151811061180c57634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b0316816001600160a01b031614611869576000604051806040016040528060148152602001731593481cda59db985d1d5c99481a5b9d985b1a5960621b815250965096505050505050611898565b50508080611876906137f9565b915050611616565b506001604051806020016040528060008152509350935050505b935093915050565b6118a8612c87565b60006118b48382612145565b60ff1682526118c46001826136ec565b9050816000015160ff1660011461191d5760405162461bcd60e51b815260206004820152601760248201527f564d2076657273696f6e20696e636f6d70617469626c650000000000000000006044820152606401610224565b6119278382612253565b63ffffffff1661010083015261193e6004826136ec565b9050600061194c8483612145565b60ff16905061195c6001836136ec565b9150806001600160401b0381111561198457634e487b7160e01b600052604160045260246000fd5b6040519080825280602002602001820160405280156119d657816020015b6040805160808101825260008082526020808301829052928201819052606082015282526000199092019101816119a25790505b5061012084015260005b81811015611b45576119f28584612145565b8461012001518281518110611a1757634e487b7160e01b600052603260045260246000fd5b602090810291909101015160ff909116606090910152611a386001846136ec565b9250611a4485846120e7565b8461012001518281518110611a6957634e487b7160e01b600052603260045260246000fd5b60200260200101516000018181525050602083611a8691906136ec565b9250611a9285846120e7565b8461012001518281518110611ab757634e487b7160e01b600052603260045260246000fd5b60200260200101516020018181525050602083611ad491906136ec565b9250611ae08584612145565b611aeb90601b61374e565b8461012001518281518110611b1057634e487b7160e01b600052603260045260246000fd5b602090810291909101015160ff909116604090910152611b316001846136ec565b925080611b3d816137f9565b9150506119e0565b506000611b6183848751611b5991906137b2565b87919061296e565b90508080519060200120604051602001611b7d91815260200190565b60408051601f198184030181529190528051602090910120610140850152611ba58584612253565b63ffffffff166020850152611bbb6004846136ec565b9250611bc78584612253565b63ffffffff166040850152611bdd6004846136ec565b9250611be985846121a1565b61ffff166060850152611bfd6002846136ec565b9250611c0985846120e7565b6080850152611c196020846136ec565b9250611c258584612a7b565b6001600160401b031660a0850152611c3e6008846136ec565b9250611c4a8584612145565b60ff1660c0850152611c5d6001846136ec565b9250611c7083848751611b5991906137b2565b60e085015250919392505050565b6000611c8960075490565b3414611cc55760405162461bcd60e51b815260206004820152600b60248201526a696e76616c69642066656560a81b6044820152606401610224565b611cce33612ad8565b9050336001600160a01b03167f6eb224fb001ed210e379b335e35efe88672a8ce935d981a6896b27ffdf52a3b282868686604051611d0f94939291906135ea565b60405180910390a29392505050565b611d26612c87565b60006060611d6985858080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152506118a092505050565b9250611d7683600061273d565b93969095509293505050565b604080516080810182526000808252602082018190529181018290526060810182905290611db083826120e7565b8252611dbd6020826136ec565b9050611dc98382612145565b60ff166020830152611ddc6001826136ec565b9050816020015160ff16600514611e2e5760405162461bcd60e51b81526020600482015260166024820152751a5b9d985b1a5908149958dbdd995c90da185a5b925960521b6044820152606401610224565b611e3883826121fe565b6040830152611e486020826136ec565b9050611e5483826121a1565b61ffff166060830152611e686002826136ec565b9050808351146108ee5760405162461bcd60e51b81526020600482015260166024820152751a5b9d985b1a5908149958dbdd995c90da185a5b925960521b6044820152606401610224565b600046611ebf60085490565b1415905090565b6000611ed1826118a0565b9050600080611edf83612315565b91509150818190611f035760405162461bcd60e51b815260040161022491906134f5565b506000611f138460e00151610d9c565b805190915063436f726514611f5b5760405162461bcd60e51b815260206004820152600e60248201526d496e76616c6964204d6f64756c6560901b6044820152606401610224565b60005461ffff1661ffff16816040015161ffff16148015611f815750611f7f611eb3565b155b611fbd5760405162461bcd60e51b815260206004820152600d60248201526c24b73b30b634b21021b430b4b760991b6044820152606401610224565b611fcb84610140015161248b565b610c598160600151600755565b600061010082106120205760405162461bcd60e51b8152602060048201526012602482015271746f6f206d616e7920677561726469616e7360701b6044820152606401610224565b600361202d836002613793565b6120379190613773565b6120429060016136ec565b92915050565b60408051808201825260608082526000602080840182905263ffffffff861682526002815290849020845181549283028101840186529485018281529394939092849284918401828280156120c657602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116120a8575b50505091835250506001919091015463ffffffff1660209091015292915050565b60006120f48260206136ec565b8351101561213c5760405162461bcd60e51b8152602060048201526015602482015274746f427974657333325f6f75744f66426f756e647360581b6044820152606401610224565b50016020015190565b60006121528260016136ec565b835110156121985760405162461bcd60e51b8152602060048201526013602482015272746f55696e74385f6f75744f66426f756e647360681b6044820152606401610224565b50016001015190565b60006121ae8260026136ec565b835110156121f55760405162461bcd60e51b8152602060048201526014602482015273746f55696e7431365f6f75744f66426f756e647360601b6044820152606401610224565b50016002015190565b600061220b8260206136ec565b8351101561213c5760405162461bcd60e51b8152602060048201526015602482015274746f55696e743235365f6f75744f66426f756e647360581b6044820152606401610224565b60006122608260046136ec565b835110156122a75760405162461bcd60e51b8152602060048201526014602482015273746f55696e7433325f6f75744f66426f756e647360601b6044820152606401610224565b50016004015190565b60006122bd8260146136ec565b835110156123055760405162461bcd60e51b8152602060048201526015602482015274746f416464726573735f6f75744f66426f756e647360581b6044820152606401610224565b500160200151600160601b900490565b60006060600080612325856114b4565b915091508161233a5760009590945092505050565b60035463ffffffff1663ffffffff1685610100015163ffffffff161461238057600060405180606001604052806022815260200161384160229139935093505050915091565b60005462010000900461ffff1661ffff16856060015161ffff16146123db576000604051806040016040528060168152602001753bb937b7339033b7bb32b93730b731b29031b430b4b760511b815250935093505050915091565b60015485608001511461242b5760006040518060400160405280601981526020017f77726f6e6720676f7665726e616e636520636f6e747261637400000000000000815250935093505050915091565b61014085015160009081526005602052604090205460ff161561246e57600060405180606001604052806022815260200161386360229139935093505050915091565b600160405180602001604052806000815250935093505050915091565b6000908152600560205260409020805460ff19166001179055565b4681146124ea5760405162461bcd60e51b81526020600482015260126024820152711a5b9d985b1a5908195d9b50da185a5b925960721b6044820152606401610224565b600855565b60006125227f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b905061252d82612b48565b60408051600481526024810182526020810180516001600160e01b031663204a7f0760e21b179052905160009182916001600160a01b0386169161257091613437565b600060405180830381855af49150503d80600081146125ab576040519150601f19603f3d011682016040523d82523d6000602084013e6125b0565b606091505b50915091508181906125d55760405162461bcd60e51b815260040161022491906134f5565b50836001600160a01b0316836001600160a01b03167f2e4cc16c100f0b55e2df82ab0b1a7e294aa9cbd01b48fbaf622683fbc0507a4960405160405180910390a350505050565b6126294262015180613704565b63ffffffff9182166000908152600260205260409020600101805463ffffffff191691909216179055565b81515160005b818110156126e75783518051600091908390811061268857634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b031614156126d55760405162461bcd60e51b815260206004820152600b60248201526a496e76616c6964206b657960a81b6044820152606401610224565b806126df816137f9565b91505061265a565b5063ffffffff82166000908152600260209081526040909120845180518693612714928492910190612ce2565b50602091909101516001909101805463ffffffff191663ffffffff909216919091179055505050565b600060606000612751856101000151612048565b9050831561282757602080860151604080880151606089015160808a015160a08b015160c08c015160e08d0151955160009861278f98979101613453565b6040516020818303038152906040529050600081805190602001206040516020016127bc91815260200190565b60405160208183030381529060405280519060200120905086610140015181146128245760006040518060400160405280601a81526020017f766d2e6861736820646f65736e2774206d6174636820626f647900000000000081525094509450505050612967565b50505b8051516128645750506040805180820190915260148152731a5b9d985b1a590819dd585c991a585b881cd95d60621b602082015260009150612967565b60035463ffffffff1663ffffffff1685610100015163ffffffff1614158015612896575042816020015163ffffffff16105b156128da57505060408051808201909152601881527f677561726469616e207365742068617320657870697265640000000000000000602082015260009150612967565b8051516128e690611fd8565b85610120015151101561291e5750506040805180820190915260098152686e6f2071756f72756d60b81b602082015260009150612967565b60008061293687610140015188610120015185611609565b915091508161294d57600094509250612967915050565b600160405180602001604052806000815250945094505050505b9250929050565b60608161297c81601f6136ec565b10156129bb5760405162461bcd60e51b815260206004820152600e60248201526d736c6963655f6f766572666c6f7760901b6044820152606401610224565b6129c582846136ec565b84511015612a095760405162461bcd60e51b8152602060048201526011602482015270736c6963655f6f75744f66426f756e647360781b6044820152606401610224565b606082158015612a285760405191506000825260208201604052612a72565b6040519150601f8416801560200281840101858101878315602002848b0101015b81831015612a61578051835260209283019201612a49565b5050858452601f01601f1916604052505b50949350505050565b6000612a888260086136ec565b83511015612acf5760405162461bcd60e51b8152602060048201526014602482015273746f55696e7436345f6f75744f66426f756e647360601b6044820152606401610224565b50016008015190565b6001600160a01b0381166000908152600460205260409020546001600160401b0316612b4382612b0983600161372c565b6001600160a01b03919091166000908152600460205260409020805467ffffffffffffffff19166001600160401b03909216919091179055565b919050565b612b5181612b88565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b803b612bec5760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b6064820152608401610224565b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b0319166001600160a01b0392909216919091179055565b6040518060a0016040528060008019168152602001600060ff168152602001600061ffff168152602001612c7a604051806040016040528060608152602001600063ffffffff1681525090565b8152600060209091015290565b604080516101608101825260008082526020820181905291810182905260608082018390526080820183905260a0820183905260c0820183905260e08201819052610100820183905261012082015261014081019190915290565b828054828255906000526020600020908101928215612d37579160200282015b82811115612d3757825182546001600160a01b0319166001600160a01b03909116178255602090920191600190910190612d02565b50612d43929150612d47565b5090565b5b80821115612d435760008155600101612d48565b80356001600160a01b0381168114612b4357600080fd5b600082601f830112612d83578081fd5b81356020612d98612d93836136c9565b613699565b80838252828201915082860187848660071b8901011115612db7578586fd5b855b85811015612e1a57608080838b031215612dd1578788fd5b612dd961362c565b8335815286840135878201526040612df2818601612ece565b908201526060612e03858201612ece565b908201528552938501939190910190600101612db9565b5090979650505050505050565b600082601f830112612e37578081fd5b81356001600160401b03811115612e5057612e5061382a565b612e63601f8201601f1916602001613699565b818152846020838601011115612e77578283fd5b816020850160208301379081016020019190915292915050565b803561ffff81168114612b4357600080fd5b803563ffffffff81168114612b4357600080fd5b80356001600160401b0381168114612b4357600080fd5b803560ff81168114612b4357600080fd5b600060208284031215612ef0578081fd5b612ef982612d5c565b9392505050565b600060208284031215612f11578081fd5b5035919050565b600080600060608486031215612f2c578182fd5b833592506020808501356001600160401b0380821115612f4a578485fd5b612f5688838901612d73565b94506040870135915080821115612f6b578384fd5b9086019060408289031215612f7e578384fd5b612f86613654565b823582811115612f94578586fd5b83019150601f82018913612fa6578485fd5b8135612fb4612d93826136c9565b8082825286820191508685018c888560051b8801011115612fd3578889fd5b8895505b83861015612ffc57612fe881612d5c565b835260019590950194918701918701612fd7565b5083525061300d9050838501612ea3565b84820152809450505050509250925092565b60008060208385031215613031578182fd5b82356001600160401b0380821115613047578384fd5b818501915085601f83011261305a578384fd5b813581811115613068578485fd5b866020828501011115613079578485fd5b60209290920196919550909350505050565b60006020828403121561309c578081fd5b81356001600160401b038111156130b1578182fd5b6130bd84828501612e27565b949350505050565b6000602082840312156130d6578081fd5b81356001600160401b03808211156130ec578283fd5b908301906101608286031215613100578283fd5b613108613676565b61311183612ece565b815261311f60208401612ea3565b602082015261313060408401612ea3565b604082015261314160608401612e91565b60608201526080830135608082015261315c60a08401612eb7565b60a082015261316d60c08401612ece565b60c082015260e083013582811115613183578485fd5b61318f87828601612e27565b60e0830152506101006131a3818501612ea3565b9082015261012083810135838111156131ba578586fd5b6131c688828701612d73565b91830191909152506101409283013592810192909252509392505050565b6000602082840312156131f5578081fd5b612ef982612ea3565b600080600060608486031215613212578081fd5b61321b84612ea3565b925060208401356001600160401b03811115613235578182fd5b61324186828701612e27565b92505061325060408501612ece565b90509250925092565b6000815180845260208085019450808401835b838110156132b157815180518852838101518489015260408082015160ff908116918a019190915260609182015116908801526080909601959082019060010161326c565b509495945050505050565b600081518084526132d48160208601602086016137c9565b601f01601f19169290920160200192915050565b805160408084528151908401819052600091602091908201906060860190845b8181101561332d5783516001600160a01b031683529284019291840191600101613308565b50509382015163ffffffff16949091019390935250919050565b805160ff1682526000610160602083015161336a602086018263ffffffff169052565b506040830151613382604086018263ffffffff169052565b506060830151613398606086018261ffff169052565b506080830151608085015260a08301516133bd60a08601826001600160401b03169052565b5060c08301516133d260c086018260ff169052565b5060e08301518160e08601526133ea828601826132bc565b915050610100808401516134058287018263ffffffff169052565b5050610120808401518583038287015261341f8382613259565b61014095860151969095019590955250919392505050565b600082516134498184602087016137c9565b9190910192915050565b6001600160e01b031960e089811b8216835288901b1660048201526001600160f01b031960f087901b166008820152600a81018590526001600160c01b031960c085901b16602a8201526001600160f81b031960f884901b16603282015281516000906134c78160338501602087016137c9565b9190910160330198975050505050505050565b82151581526040602082015260006130bd60408301846132bc565b602081526000612ef960208301846132bc565b6020808252600e908201526d696e76616c6964204d6f64756c6560901b604082015260600190565b602081528151602082015260ff602083015116604082015261ffff60408301511660608201526000606083015160a0608084015261357160c08401826132e8565b905063ffffffff60808501511660a08401528091505092915050565b602081526000612ef960208301846132e8565b602081526000612ef96020830184613347565b6060815260006135c66060830186613347565b841515602084015282810360408401526135e081856132bc565b9695505050505050565b6001600160401b038516815263ffffffff8416602082015260806040820152600061361860808301856132bc565b905060ff8316606083015295945050505050565b604051608081016001600160401b038111828210171561364e5761364e61382a565b60405290565b604080519081016001600160401b038111828210171561364e5761364e61382a565b60405161016081016001600160401b038111828210171561364e5761364e61382a565b604051601f8201601f191681016001600160401b03811182821017156136c1576136c161382a565b604052919050565b60006001600160401b038211156136e2576136e261382a565b5060051b60200190565b600082198211156136ff576136ff613814565b500190565b600063ffffffff80831681851680830382111561372357613723613814565b01949350505050565b60006001600160401b0380831681851680830382111561372357613723613814565b600060ff821660ff84168060ff0382111561376b5761376b613814565b019392505050565b60008261378e57634e487b7160e01b81526012600452602481fd5b500490565b60008160001904831182151516156137ad576137ad613814565b500290565b6000828210156137c4576137c4613814565b500390565b60005b838110156137e45781810151838201526020016137cc565b838111156137f3576000848401525b50505050565b600060001982141561380d5761380d613814565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fdfe6e6f74207369676e65642062792063757272656e7420677561726469616e20736574676f7665726e616e636520616374696f6e20616c726561647920636f6e73756d6564a264697066735822122074722d052ee17d08879a2ea3324a9c05f4ac85b401c6013af75e6589e6a9c60f64736f6c63430008040033

0x6080604052600436106101c65760003560e01c806393df337e116100f7578063cb4cfea811610095578063f42bc64111610064578063f42bc64114610712578063f8ce560a14610732578063f951975a14610752578063fbe3c2cd1461077f5761022d565b8063cb4cfea814610647578063d60b347f146106a1578063e039f224146106da578063eb8d3f12146106ef5761022d565b8063a9e11893116100d1578063a9e11893146105c3578063b172b222146105f0578063b19a437e14610605578063c0fd8bde146106185761022d565b806393df337e1461055b5780639a8a05921461057b578063a0cce1b3146105a35761022d565b80634fdc60fa1161016457806364d42b171161013e57806364d42b17146104e35780636606b4e0146104f85780638129fc1c14610518578063875be02a1461052d5761022d565b80634fdc60fa14610406578063515f3247146104695780635cb8cae2146104c35761022d565b80631a90a219116101a05780631a90a219146103245780631cfe7951146103435780632c3c02a41461036f5780634cf842b5146103af5761022d565b80630319e59c1461026357806304ca84cf146102d5578063178149e7146103025761022d565b3661022d5760405162461bcd60e51b815260206004820152602c60248201527f74686520576f726d686f6c6520636f6e747261637420646f6573206e6f74206160448201526b63636570742061737365747360a01b60648201526084015b60405180910390fd5b60405162461bcd60e51b815260206004820152600b60248201526a1d5b9cdd5c1c1bdc9d195960aa1b6044820152606401610224565b34801561026f57600080fd5b5061028361027e36600461308b565b61079e565b6040516102cc9190600060a0820190508251825260ff602084015116602083015261ffff6040840151166040830152606083015160608301526080830151608083015292915050565b60405180910390f35b3480156102e157600080fd5b506102f56102f036600461308b565b6108f4565b6040516102cc9190613530565b34801561030e57600080fd5b5061032261031d36600461308b565b610b27565b005b34801561033057600080fd5b506007545b6040519081526020016102cc565b34801561034f57600080fd5b5060035463ffffffff165b60405163ffffffff90911681526020016102cc565b34801561037b57600080fd5b5061039f61038a366004612f00565b60009081526005602052604090205460ff1690565b60405190151581526020016102cc565b3480156103bb57600080fd5b506103ee6103ca366004612edf565b6001600160a01b03166000908152600460205260409020546001600160401b031690565b6040516001600160401b0390911681526020016102cc565b34801561041257600080fd5b5061042661042136600461308b565b610c60565b6040516102cc91908151815260208083015160ff169082015260408083015161ffff16908201526060918201516001600160a01b03169181019190915260800190565b34801561047557600080fd5b5061048961048436600461308b565b610d9c565b6040516102cc91908151815260208083015160ff169082015260408083015161ffff16908201526060918201519181019190915260800190565b3480156104cf57600080fd5b506103226104de36600461308b565b610ecb565b3480156104ef57600080fd5b50600854610335565b34801561050457600080fd5b5061032261051336600461308b565b611010565b34801561052457600080fd5b50610322611220565b34801561053957600080fd5b5061054d6105483660046130c5565b6114b4565b6040516102cc9291906134da565b34801561056757600080fd5b5061032261057636600461308b565b6114cd565b34801561058757600080fd5b5060005461ffff165b60405161ffff90911681526020016102cc565b3480156105af57600080fd5b5061054d6105be366004612f18565b611609565b3480156105cf57600080fd5b506105e36105de36600461308b565b6118a0565b6040516102cc91906135a0565b3480156105fc57600080fd5b50600154610335565b6103ee6106133660046131fe565b611c7e565b34801561062457600080fd5b5061063861063336600461301f565b611d1e565b6040516102cc939291906135b3565b34801561065357600080fd5b5061066761066236600461308b565b611d82565b6040516102cc91908151815260208083015160ff16908201526040808301519082015260609182015161ffff169181019190915260800190565b3480156106ad57600080fd5b5061039f6106bc366004612edf565b6001600160a01b031660009081526006602052604090205460ff1690565b3480156106e657600080fd5b5061039f611eb3565b3480156106fb57600080fd5b50600354640100000000900463ffffffff1661035a565b34801561071e57600080fd5b5061032261072d36600461308b565b611ec6565b34801561073e57600080fd5b5061033561074d366004612f00565b611fd8565b34801561075e57600080fd5b5061077261076d3660046131e4565b612048565b6040516102cc919061358d565b34801561078b57600080fd5b5060005462010000900461ffff16610590565b6040805160a0810182526000808252602082018190529181018290526060810182905260808101829052906107d383826120e7565b82526107e06020826136ec565b90506107ec8382612145565b60ff1660208301526107ff6001826136ec565b9050816020015160ff1660041461084f5760405162461bcd60e51b8152602060048201526014602482015273696e76616c6964205472616e736665724665657360601b6044820152606401610224565b61085983826121a1565b61ffff16604083015261086d6002826136ec565b905061087983826121fe565b60608301526108896020826136ec565b905061089583826120e7565b60808301526108a56020826136ec565b9050808351146108ee5760405162461bcd60e51b8152602060048201526014602482015273696e76616c6964205472616e736665724665657360601b6044820152606401610224565b50919050565b6108fc612c2d565b600061090883826120e7565b82526109156020826136ec565b90506109218382612145565b60ff1660208301526109346001826136ec565b9050816020015160ff1660021461098d5760405162461bcd60e51b815260206004820152601a60248201527f696e76616c696420477561726469616e536574557067726164650000000000006044820152606401610224565b61099783826121a1565b61ffff1660408301526109ab6002826136ec565b90506109b78382612253565b63ffffffff1660808301526109cd6004826136ec565b905060006109db8483612145565b90506109e86001836136ec565b915060405180604001604052808260ff166001600160401b03811115610a1e57634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015610a47578160200160208202803683370190505b5081526000602090910181905260608501919091525b8160ff16811015610acf57610a7285846122b0565b606085015151805183908110610a9857634e487b7160e01b600052603260045260246000fd5b6001600160a01b0390921660209283029190910190910152610abb6014846136ec565b925080610ac7816137f9565b915050610a5d565b5081845114610b205760405162461bcd60e51b815260206004820152601a60248201527f696e76616c696420477561726469616e536574557067726164650000000000006044820152606401610224565b5050919050565b610b2f611eb3565b610b685760405162461bcd60e51b815260206004820152600a6024820152696e6f74206120666f726b60b01b6044820152606401610224565b6000610b73826118a0565b9050600080610b8183612315565b91509150818190610ba55760405162461bcd60e51b815260040161022491906134f5565b506000610bb58460e00151611d82565b805190915063436f726514610bdc5760405162461bcd60e51b815260040161022490613508565b46816040015114610c235760405162461bcd60e51b815260206004820152601160248201527034b73b30b634b21022ab269021b430b4b760791b6044820152606401610224565b610c3184610140015161248b565b610c3e81604001516124a6565b60608101516000805461ffff191661ffff9092169190911790555b5050505050565b604080516080810182526000808252602082018190529181018290526060810182905290610c8e83826120e7565b8252610c9b6020826136ec565b9050610ca78382612145565b60ff166020830152610cba6001826136ec565b9050816020015160ff16600114610d0d5760405162461bcd60e51b8152602060048201526017602482015276696e76616c696420436f6e74726163745570677261646560481b6044820152606401610224565b610d1783826121a1565b61ffff166040830152610d2b6002826136ec565b9050610d3783826120e7565b6001600160a01b03166060830152610d506020826136ec565b9050808351146108ee5760405162461bcd60e51b8152602060048201526017602482015276696e76616c696420436f6e74726163745570677261646560481b6044820152606401610224565b604080516080810182526000808252602082018190529181018290526060810182905290610dca83826120e7565b8252610dd76020826136ec565b9050610de38382612145565b60ff166020830152610df66001826136ec565b9050816020015160ff16600314610e475760405162461bcd60e51b8152602060048201526015602482015274696e76616c6964205365744d65737361676546656560581b6044820152606401610224565b610e5183826121a1565b61ffff166040830152610e656002826136ec565b9050610e7183826121fe565b6060830152610e816020826136ec565b9050808351146108ee5760405162461bcd60e51b8152602060048201526015602482015274696e76616c6964205365744d65737361676546656560581b6044820152606401610224565b610ed3611eb3565b15610f0f5760405162461bcd60e51b815260206004820152600c60248201526b696e76616c696420666f726b60a01b6044820152606401610224565b6000610f1a826118a0565b9050600080610f2883612315565b91509150818190610f4c5760405162461bcd60e51b815260040161022491906134f5565b506000610f5c8460e00151610c60565b805190915063436f726514610fa45760405162461bcd60e51b815260206004820152600e60248201526d496e76616c6964204d6f64756c6560901b6044820152606401610224565b60005461ffff1661ffff16816040015161ffff1614610ff55760405162461bcd60e51b815260206004820152600d60248201526c24b73b30b634b21021b430b4b760991b6044820152606401610224565b61100384610140015161248b565b610c5981606001516124ef565b600061101b826118a0565b905060008061102983612315565b9150915081819061104d5760405162461bcd60e51b815260040161022491906134f5565b50600061105d8460e001516108f4565b805190915063436f7265146110845760405162461bcd60e51b815260040161022490613508565b60005461ffff1661ffff16816040015161ffff161480156110aa57506110a8611eb3565b155b806110bb5750604081015161ffff16155b6110f75760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b21021b430b4b760991b6044820152606401610224565b6060810151515161114a5760405162461bcd60e51b815260206004820152601960248201527f6e657720677561726469616e2073657420697320656d707479000000000000006044820152606401610224565b60035463ffffffff1661115e906001613704565b63ffffffff16816080015163ffffffff16146111c65760405162461bcd60e51b815260206004820152602160248201527f696e646578206d75737420696e63726561736520696e207374657073206f66206044820152603160f81b6064820152608401610224565b6111d484610140015161248b565b6111eb6111e660035463ffffffff1690565b61261c565b6111fd81606001518260800151612654565b60808101516003805463ffffffff191663ffffffff909216919091179055610c59565b60006112537f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b9050611277816001600160a01b031660009081526006602052604090205460ff1690565b156112ba5760405162461bcd60e51b8152602060048201526013602482015272185b1c9958591e481a5b9a5d1a585b1a5e9959606a1b6044820152606401610224565b6112e2816001600160a01b03166000908152600660205260409020805460ff19166001179055565b6008546114b1576000806112f960005461ffff1690565b90508061ffff166002141561131157600191506114a5565b8061ffff166004141561132757603891506114a5565b8061ffff166005141561133d57608991506114a5565b8061ffff16600614156113545761a86a91506114a5565b8061ffff166007141561136b5761a51691506114a5565b8061ffff166009141561138457634e45415291506114a5565b8061ffff16600a141561139a5760fa91506114a5565b8061ffff16600b14156113b1576102ae91506114a5565b8061ffff16600c14156113c85761031391506114a5565b8061ffff16600d14156113df5761201991506114a5565b8061ffff16600e14156113f65761a4ec91506114a5565b8061ffff166010141561140d5761050491506114a5565b8061ffff166011141561142657630e9ac0d691506114a5565b8061ffff166017141561143d5761a4b191506114a5565b8061ffff166018141561145357600a91506114a5565b8061ffff166019141561146957606491506114a5565b60405162461bcd60e51b81526020600482015260116024820152702ab735b737bbb71031b430b4b71034b21760791b6044820152606401610224565b6114ae826124a6565b50505b50565b600060606114c383600161273d565b9094909350915050565b60006114d8826118a0565b90506000806114e683612315565b9150915081819061150a5760405162461bcd60e51b815260040161022491906134f5565b50600061151a8460e0015161079e565b805190915063436f7265146115415760405162461bcd60e51b815260040161022490613508565b60005461ffff1661ffff16816040015161ffff161480156115675750611565611eb3565b155b806115785750604081015161ffff16155b6115b45760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b21021b430b4b760991b6044820152606401610224565b6115c284610140015161248b565b608081015160608201516040516001600160a01b0383169180156108fc02916000818181858888f19350505050158015611600573d6000803e3d6000fd5b50505050505050565b8051516000906060908290815b865181101561187e57600087828151811061164157634e487b7160e01b600052603260045260246000fd5b60200260200101519050600060018a83604001518460000151856020015160405160008152602001604052604051611695949392919093845260ff9290921660208401526040830152606082015260800190565b6020604051602081039080840390855afa1580156116b7573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b03811661171a5760405162461bcd60e51b815260206004820152601f60248201527f65637265636f766572206661696c65642077697468207369676e6174757265006044820152606401610224565b82158061173057508460ff16826060015160ff16115b6117885760405162461bcd60e51b815260206004820152602360248201527f7369676e617475726520696e6469636573206d75737420626520617363656e64604482015262696e6760e81b6064820152608401610224565b6060820151945060ff851684116117e15760405162461bcd60e51b815260206004820152601c60248201527f677561726469616e20696e646578206f7574206f6620626f756e6473000000006044820152606401610224565b8760000151826060015160ff168151811061180c57634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b0316816001600160a01b031614611869576000604051806040016040528060148152602001731593481cda59db985d1d5c99481a5b9d985b1a5960621b815250965096505050505050611898565b50508080611876906137f9565b915050611616565b506001604051806020016040528060008152509350935050505b935093915050565b6118a8612c87565b60006118b48382612145565b60ff1682526118c46001826136ec565b9050816000015160ff1660011461191d5760405162461bcd60e51b815260206004820152601760248201527f564d2076657273696f6e20696e636f6d70617469626c650000000000000000006044820152606401610224565b6119278382612253565b63ffffffff1661010083015261193e6004826136ec565b9050600061194c8483612145565b60ff16905061195c6001836136ec565b9150806001600160401b0381111561198457634e487b7160e01b600052604160045260246000fd5b6040519080825280602002602001820160405280156119d657816020015b6040805160808101825260008082526020808301829052928201819052606082015282526000199092019101816119a25790505b5061012084015260005b81811015611b45576119f28584612145565b8461012001518281518110611a1757634e487b7160e01b600052603260045260246000fd5b602090810291909101015160ff909116606090910152611a386001846136ec565b9250611a4485846120e7565b8461012001518281518110611a6957634e487b7160e01b600052603260045260246000fd5b60200260200101516000018181525050602083611a8691906136ec565b9250611a9285846120e7565b8461012001518281518110611ab757634e487b7160e01b600052603260045260246000fd5b60200260200101516020018181525050602083611ad491906136ec565b9250611ae08584612145565b611aeb90601b61374e565b8461012001518281518110611b1057634e487b7160e01b600052603260045260246000fd5b602090810291909101015160ff909116604090910152611b316001846136ec565b925080611b3d816137f9565b9150506119e0565b506000611b6183848751611b5991906137b2565b87919061296e565b90508080519060200120604051602001611b7d91815260200190565b60408051601f198184030181529190528051602090910120610140850152611ba58584612253565b63ffffffff166020850152611bbb6004846136ec565b9250611bc78584612253565b63ffffffff166040850152611bdd6004846136ec565b9250611be985846121a1565b61ffff166060850152611bfd6002846136ec565b9250611c0985846120e7565b6080850152611c196020846136ec565b9250611c258584612a7b565b6001600160401b031660a0850152611c3e6008846136ec565b9250611c4a8584612145565b60ff1660c0850152611c5d6001846136ec565b9250611c7083848751611b5991906137b2565b60e085015250919392505050565b6000611c8960075490565b3414611cc55760405162461bcd60e51b815260206004820152600b60248201526a696e76616c69642066656560a81b6044820152606401610224565b611cce33612ad8565b9050336001600160a01b03167f6eb224fb001ed210e379b335e35efe88672a8ce935d981a6896b27ffdf52a3b282868686604051611d0f94939291906135ea565b60405180910390a29392505050565b611d26612c87565b60006060611d6985858080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152506118a092505050565b9250611d7683600061273d565b93969095509293505050565b604080516080810182526000808252602082018190529181018290526060810182905290611db083826120e7565b8252611dbd6020826136ec565b9050611dc98382612145565b60ff166020830152611ddc6001826136ec565b9050816020015160ff16600514611e2e5760405162461bcd60e51b81526020600482015260166024820152751a5b9d985b1a5908149958dbdd995c90da185a5b925960521b6044820152606401610224565b611e3883826121fe565b6040830152611e486020826136ec565b9050611e5483826121a1565b61ffff166060830152611e686002826136ec565b9050808351146108ee5760405162461bcd60e51b81526020600482015260166024820152751a5b9d985b1a5908149958dbdd995c90da185a5b925960521b6044820152606401610224565b600046611ebf60085490565b1415905090565b6000611ed1826118a0565b9050600080611edf83612315565b91509150818190611f035760405162461bcd60e51b815260040161022491906134f5565b506000611f138460e00151610d9c565b805190915063436f726514611f5b5760405162461bcd60e51b815260206004820152600e60248201526d496e76616c6964204d6f64756c6560901b6044820152606401610224565b60005461ffff1661ffff16816040015161ffff16148015611f815750611f7f611eb3565b155b611fbd5760405162461bcd60e51b815260206004820152600d60248201526c24b73b30b634b21021b430b4b760991b6044820152606401610224565b611fcb84610140015161248b565b610c598160600151600755565b600061010082106120205760405162461bcd60e51b8152602060048201526012602482015271746f6f206d616e7920677561726469616e7360701b6044820152606401610224565b600361202d836002613793565b6120379190613773565b6120429060016136ec565b92915050565b60408051808201825260608082526000602080840182905263ffffffff861682526002815290849020845181549283028101840186529485018281529394939092849284918401828280156120c657602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116120a8575b50505091835250506001919091015463ffffffff1660209091015292915050565b60006120f48260206136ec565b8351101561213c5760405162461bcd60e51b8152602060048201526015602482015274746f427974657333325f6f75744f66426f756e647360581b6044820152606401610224565b50016020015190565b60006121528260016136ec565b835110156121985760405162461bcd60e51b8152602060048201526013602482015272746f55696e74385f6f75744f66426f756e647360681b6044820152606401610224565b50016001015190565b60006121ae8260026136ec565b835110156121f55760405162461bcd60e51b8152602060048201526014602482015273746f55696e7431365f6f75744f66426f756e647360601b6044820152606401610224565b50016002015190565b600061220b8260206136ec565b8351101561213c5760405162461bcd60e51b8152602060048201526015602482015274746f55696e743235365f6f75744f66426f756e647360581b6044820152606401610224565b60006122608260046136ec565b835110156122a75760405162461bcd60e51b8152602060048201526014602482015273746f55696e7433325f6f75744f66426f756e647360601b6044820152606401610224565b50016004015190565b60006122bd8260146136ec565b835110156123055760405162461bcd60e51b8152602060048201526015602482015274746f416464726573735f6f75744f66426f756e647360581b6044820152606401610224565b500160200151600160601b900490565b60006060600080612325856114b4565b915091508161233a5760009590945092505050565b60035463ffffffff1663ffffffff1685610100015163ffffffff161461238057600060405180606001604052806022815260200161384160229139935093505050915091565b60005462010000900461ffff1661ffff16856060015161ffff16146123db576000604051806040016040528060168152602001753bb937b7339033b7bb32b93730b731b29031b430b4b760511b815250935093505050915091565b60015485608001511461242b5760006040518060400160405280601981526020017f77726f6e6720676f7665726e616e636520636f6e747261637400000000000000815250935093505050915091565b61014085015160009081526005602052604090205460ff161561246e57600060405180606001604052806022815260200161386360229139935093505050915091565b600160405180602001604052806000815250935093505050915091565b6000908152600560205260409020805460ff19166001179055565b4681146124ea5760405162461bcd60e51b81526020600482015260126024820152711a5b9d985b1a5908195d9b50da185a5b925960721b6044820152606401610224565b600855565b60006125227f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b905061252d82612b48565b60408051600481526024810182526020810180516001600160e01b031663204a7f0760e21b179052905160009182916001600160a01b0386169161257091613437565b600060405180830381855af49150503d80600081146125ab576040519150601f19603f3d011682016040523d82523d6000602084013e6125b0565b606091505b50915091508181906125d55760405162461bcd60e51b815260040161022491906134f5565b50836001600160a01b0316836001600160a01b03167f2e4cc16c100f0b55e2df82ab0b1a7e294aa9cbd01b48fbaf622683fbc0507a4960405160405180910390a350505050565b6126294262015180613704565b63ffffffff9182166000908152600260205260409020600101805463ffffffff191691909216179055565b81515160005b818110156126e75783518051600091908390811061268857634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b031614156126d55760405162461bcd60e51b815260206004820152600b60248201526a496e76616c6964206b657960a81b6044820152606401610224565b806126df816137f9565b91505061265a565b5063ffffffff82166000908152600260209081526040909120845180518693612714928492910190612ce2565b50602091909101516001909101805463ffffffff191663ffffffff909216919091179055505050565b600060606000612751856101000151612048565b9050831561282757602080860151604080880151606089015160808a015160a08b015160c08c015160e08d0151955160009861278f98979101613453565b6040516020818303038152906040529050600081805190602001206040516020016127bc91815260200190565b60405160208183030381529060405280519060200120905086610140015181146128245760006040518060400160405280601a81526020017f766d2e6861736820646f65736e2774206d6174636820626f647900000000000081525094509450505050612967565b50505b8051516128645750506040805180820190915260148152731a5b9d985b1a590819dd585c991a585b881cd95d60621b602082015260009150612967565b60035463ffffffff1663ffffffff1685610100015163ffffffff1614158015612896575042816020015163ffffffff16105b156128da57505060408051808201909152601881527f677561726469616e207365742068617320657870697265640000000000000000602082015260009150612967565b8051516128e690611fd8565b85610120015151101561291e5750506040805180820190915260098152686e6f2071756f72756d60b81b602082015260009150612967565b60008061293687610140015188610120015185611609565b915091508161294d57600094509250612967915050565b600160405180602001604052806000815250945094505050505b9250929050565b60608161297c81601f6136ec565b10156129bb5760405162461bcd60e51b815260206004820152600e60248201526d736c6963655f6f766572666c6f7760901b6044820152606401610224565b6129c582846136ec565b84511015612a095760405162461bcd60e51b8152602060048201526011602482015270736c6963655f6f75744f66426f756e647360781b6044820152606401610224565b606082158015612a285760405191506000825260208201604052612a72565b6040519150601f8416801560200281840101858101878315602002848b0101015b81831015612a61578051835260209283019201612a49565b5050858452601f01601f1916604052505b50949350505050565b6000612a888260086136ec565b83511015612acf5760405162461bcd60e51b8152602060048201526014602482015273746f55696e7436345f6f75744f66426f756e647360601b6044820152606401610224565b50016008015190565b6001600160a01b0381166000908152600460205260409020546001600160401b0316612b4382612b0983600161372c565b6001600160a01b03919091166000908152600460205260409020805467ffffffffffffffff19166001600160401b03909216919091179055565b919050565b612b5181612b88565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b803b612bec5760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b6064820152608401610224565b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b0319166001600160a01b0392909216919091179055565b6040518060a0016040528060008019168152602001600060ff168152602001600061ffff168152602001612c7a604051806040016040528060608152602001600063ffffffff1681525090565b8152600060209091015290565b604080516101608101825260008082526020820181905291810182905260608082018390526080820183905260a0820183905260c0820183905260e08201819052610100820183905261012082015261014081019190915290565b828054828255906000526020600020908101928215612d37579160200282015b82811115612d3757825182546001600160a01b0319166001600160a01b03909116178255602090920191600190910190612d02565b50612d43929150612d47565b5090565b5b80821115612d435760008155600101612d48565b80356001600160a01b0381168114612b4357600080fd5b600082601f830112612d83578081fd5b81356020612d98612d93836136c9565b613699565b80838252828201915082860187848660071b8901011115612db7578586fd5b855b85811015612e1a57608080838b031215612dd1578788fd5b612dd961362c565b8335815286840135878201526040612df2818601612ece565b908201526060612e03858201612ece565b908201528552938501939190910190600101612db9565b5090979650505050505050565b600082601f830112612e37578081fd5b81356001600160401b03811115612e5057612e5061382a565b612e63601f8201601f1916602001613699565b818152846020838601011115612e77578283fd5b816020850160208301379081016020019190915292915050565b803561ffff81168114612b4357600080fd5b803563ffffffff81168114612b4357600080fd5b80356001600160401b0381168114612b4357600080fd5b803560ff81168114612b4357600080fd5b600060208284031215612ef0578081fd5b612ef982612d5c565b9392505050565b600060208284031215612f11578081fd5b5035919050565b600080600060608486031215612f2c578182fd5b833592506020808501356001600160401b0380821115612f4a578485fd5b612f5688838901612d73565b94506040870135915080821115612f6b578384fd5b9086019060408289031215612f7e578384fd5b612f86613654565b823582811115612f94578586fd5b83019150601f82018913612fa6578485fd5b8135612fb4612d93826136c9565b8082825286820191508685018c888560051b8801011115612fd3578889fd5b8895505b83861015612ffc57612fe881612d5c565b835260019590950194918701918701612fd7565b5083525061300d9050838501612ea3565b84820152809450505050509250925092565b60008060208385031215613031578182fd5b82356001600160401b0380821115613047578384fd5b818501915085601f83011261305a578384fd5b813581811115613068578485fd5b866020828501011115613079578485fd5b60209290920196919550909350505050565b60006020828403121561309c578081fd5b81356001600160401b038111156130b1578182fd5b6130bd84828501612e27565b949350505050565b6000602082840312156130d6578081fd5b81356001600160401b03808211156130ec578283fd5b908301906101608286031215613100578283fd5b613108613676565b61311183612ece565b815261311f60208401612ea3565b602082015261313060408401612ea3565b604082015261314160608401612e91565b60608201526080830135608082015261315c60a08401612eb7565b60a082015261316d60c08401612ece565b60c082015260e083013582811115613183578485fd5b61318f87828601612e27565b60e0830152506101006131a3818501612ea3565b9082015261012083810135838111156131ba578586fd5b6131c688828701612d73565b91830191909152506101409283013592810192909252509392505050565b6000602082840312156131f5578081fd5b612ef982612ea3565b600080600060608486031215613212578081fd5b61321b84612ea3565b925060208401356001600160401b03811115613235578182fd5b61324186828701612e27565b92505061325060408501612ece565b90509250925092565b6000815180845260208085019450808401835b838110156132b157815180518852838101518489015260408082015160ff908116918a019190915260609182015116908801526080909601959082019060010161326c565b509495945050505050565b600081518084526132d48160208601602086016137c9565b601f01601f19169290920160200192915050565b805160408084528151908401819052600091602091908201906060860190845b8181101561332d5783516001600160a01b031683529284019291840191600101613308565b50509382015163ffffffff16949091019390935250919050565b805160ff1682526000610160602083015161336a602086018263ffffffff169052565b506040830151613382604086018263ffffffff169052565b506060830151613398606086018261ffff169052565b506080830151608085015260a08301516133bd60a08601826001600160401b03169052565b5060c08301516133d260c086018260ff169052565b5060e08301518160e08601526133ea828601826132bc565b915050610100808401516134058287018263ffffffff169052565b5050610120808401518583038287015261341f8382613259565b61014095860151969095019590955250919392505050565b600082516134498184602087016137c9565b9190910192915050565b6001600160e01b031960e089811b8216835288901b1660048201526001600160f01b031960f087901b166008820152600a81018590526001600160c01b031960c085901b16602a8201526001600160f81b031960f884901b16603282015281516000906134c78160338501602087016137c9565b9190910160330198975050505050505050565b82151581526040602082015260006130bd60408301846132bc565b602081526000612ef960208301846132bc565b6020808252600e908201526d696e76616c6964204d6f64756c6560901b604082015260600190565b602081528151602082015260ff602083015116604082015261ffff60408301511660608201526000606083015160a0608084015261357160c08401826132e8565b905063ffffffff60808501511660a08401528091505092915050565b602081526000612ef960208301846132e8565b602081526000612ef96020830184613347565b6060815260006135c66060830186613347565b841515602084015282810360408401526135e081856132bc565b9695505050505050565b6001600160401b038516815263ffffffff8416602082015260806040820152600061361860808301856132bc565b905060ff8316606083015295945050505050565b604051608081016001600160401b038111828210171561364e5761364e61382a565b60405290565b604080519081016001600160401b038111828210171561364e5761364e61382a565b60405161016081016001600160401b038111828210171561364e5761364e61382a565b604051601f8201601f191681016001600160401b03811182821017156136c1576136c161382a565b604052919050565b60006001600160401b038211156136e2576136e261382a565b5060051b60200190565b600082198211156136ff576136ff613814565b500190565b600063ffffffff80831681851680830382111561372357613723613814565b01949350505050565b60006001600160401b0380831681851680830382111561372357613723613814565b600060ff821660ff84168060ff0382111561376b5761376b613814565b019392505050565b60008261378e57634e487b7160e01b81526012600452602481fd5b500490565b60008160001904831182151516156137ad576137ad613814565b500290565b6000828210156137c4576137c4613814565b500390565b60005b838110156137e45781810151838201526020016137cc565b838111156137f3576000848401525b50505050565b600060001982141561380d5761380d613814565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fdfe6e6f74207369676e65642062792063757272656e7420677561726469616e20736574676f7665726e616e636520616374696f6e20616c726561647920636f6e73756d6564a264697066735822122074722d052ee17d08879a2ea3324a9c05f4ac85b401c6013af75e6589e6a9c60f64736f6c63430008040033

66501:2883:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69325:54;;-1:-1:-1;;;69325:54:0;;15611:2:1;69325:54:0;;;15593:21:1;15650:2;15630:18;;;15623:30;15689:34;15669:18;;;15662:62;-1:-1:-1;;;15740:18:1;;;15733:42;15792:19;;69325:54:0;;;;;;;;66501:2883;69266:21;;-1:-1:-1;;;69266:21:0;;25933:2:1;69266:21:0;;;25915::1;25972:2;25952:18;;;25945:30;-1:-1:-1;;;25991:18:1;;;25984:41;26042:18;;69266:21:0;25905:161:1;24249:692:0;;;;;;;;;;-1:-1:-1;24249:692:0;;;;;:::i;:::-;;:::i;:::-;;;;;;29299:4:1;29341:3;29330:9;29326:19;29318:27;;29378:6;29372:13;29361:9;29354:32;29454:4;29446;29438:6;29434:17;29428:24;29424:35;29417:4;29406:9;29402:20;29395:65;29528:6;29520:4;29512:6;29508:17;29502:24;29498:37;29491:4;29480:9;29476:20;29469:67;29592:4;29584:6;29580:17;29574:24;29567:4;29556:9;29552:20;29545:54;29655:4;29647:6;29643:17;29637:24;29630:4;29619:9;29615:20;29608:54;29308:360;;;;;24249:692:0;;;;;;;;22447:1019;;;;;;;;;;-1:-1:-1;22447:1019:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;63638:866::-;;;;;;;;;;-1:-1:-1;63638:866:0;;;;;:::i;:::-;;:::i;:::-;;28263:95;;;;;;;;;;-1:-1:-1;28333:17:0;;28263:95;;;13356:25:1;;;13344:2;13329:18;28263:95:0;13311:76:1;27167:116:0;;;;;;;;;;-1:-1:-1;27252:23:0;;;;27167:116;;;30953:10:1;30941:23;;;30923:42;;30911:2;30896:18;27167:116:0;30878:93:1;27410:141:0;;;;;;;;;;-1:-1:-1;27410:141:0;;;;;:::i;:::-;27481:4;27505:38;;;:32;:38;;;;;;;;;27410:141;;;;12878:14:1;;12871:22;12853:41;;12841:2;12826:18;27410:141:0;12808:92:1;28366:119:0;;;;;;;;;;-1:-1:-1;28366:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;28452:25:0;28426:6;28452:25;;;:16;:25;;;;;;-1:-1:-1;;;;;28452:25:0;;28366:119;;;;-1:-1:-1;;;;;31138:31:1;;;31120:50;;31108:2;31093:18;28366:119:0;31075:101:1;21742:620:0;;;;;;;;;;-1:-1:-1;21742:620:0;;;;;:::i;:::-;;:::i;:::-;;;;;;26999:13:1;;26981:32;;27073:4;27061:17;;;27055:24;27081:4;27051:35;27029:20;;;27022:65;27147:4;27135:17;;;27129:24;27155:6;27125:37;27103:20;;;27096:67;27223:4;27211:17;;;27205:24;-1:-1:-1;;;;;27201:50:1;27179:20;;;27172:80;;;;26968:3;26953:19;;26935:323;23545:626:0;;;;;;;;;;-1:-1:-1;23545:626:0;;;;;:::i;:::-;;:::i;:::-;;;;;;28911:13:1;;28893:32;;28985:4;28973:17;;;28967:24;28993:4;28963:35;28941:20;;;28934:65;29059:4;29047:17;;;29041:24;29067:6;29037:37;29015:20;;;29008:67;29131:4;29119:17;;;29113:24;29091:20;;;29084:54;;;;28880:3;28865:19;;28847:297;58983:856:0;;;;;;;;;;-1:-1:-1;58983:856:0;;;;;:::i;:::-;;:::i;27801:95::-;;;;;;;;;;-1:-1:-1;27871:17:0;;27801:95;;60810:1550;;;;;;;;;;-1:-1:-1;60810:1550:0;;;;;:::i;:::-;;:::i;67336:1614::-;;;;;;;;;;;;;:::i;29611:162::-;;;;;;;;;;-1:-1:-1;29611:162:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;62460:1062::-;;;;;;;;;;-1:-1:-1;62460:1062:0;;;;;:::i;:::-;;:::i;27696:97::-;;;;;;;;;;-1:-1:-1;27736:6:0;27762:23;;;27696:97;;;30578:6:1;30566:19;;;30548:38;;30536:2;30521:18;27696:97:0;30503:89:1;33842:1902:0;;;;;;;;;;-1:-1:-1;33842:1902:0;;;;;:::i;:::-;;:::i;35934:2354::-;;;;;;;;;;-1:-1:-1;35934:2354:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;28136:119::-;;;;;;;;;;-1:-1:-1;28213:34:0;;28136:119;;66739:408;;;;;;:::i;:::-;;:::i;28789:374::-;;;;;;;;;;-1:-1:-1;28789:374:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;25021:641::-;;;;;;;;;;-1:-1:-1;25021:641:0;;;;;:::i;:::-;;:::i;:::-;;;;;;28448:13:1;;28430:32;;28522:4;28510:17;;;28504:24;28530:4;28500:35;28478:20;;;28471:65;28592:4;28580:17;;;28574:24;28552:20;;;28545:54;28659:4;28647:17;;;28641:24;28667:6;28637:37;28615:20;;;28608:67;;;;28417:3;28402:19;;28384:297;27559:129:0;;;;;;;;;;-1:-1:-1;27559:129:0;;;;;:::i;:::-;-1:-1:-1;;;;;27641:39:0;27617:4;27641:39;;;:33;:39;;;;;;;;;27559:129;27904:100;;;;;;;;;;;;;:::i;27291:111::-;;;;;;;;;;-1:-1:-1;27370:24:0;;;;;;;27291:111;;59920:801;;;;;;;;;;-1:-1:-1;59920:801:0;;;;;:::i;:::-;;:::i;38413:262::-;;;;;;;;;;-1:-1:-1;38413:262:0;;;;;:::i;:::-;;:::i;27020:139::-;;;;;;;;;;-1:-1:-1;27020:139:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;28012:116::-;;;;;;;;;;-1:-1:-1;28062:6:0;28087:33;;;;;;28012:116;;24249:692;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24405:36:0;:19;-1:-1:-1;24405:29:0;:36::i;:::-;24393:48;;24452:11;24461:2;24452:11;;:::i;:::-;;-1:-1:-1;24488:34:0;:19;24452:11;24488:27;:34::i;:::-;24476:46;;:9;;;:46;24533:10;24542:1;24533:10;;:::i;:::-;;;24564:2;:9;;;:14;;24577:1;24564:14;24556:47;;;;-1:-1:-1;;;24556:47:0;;25584:2:1;24556:47:0;;;25566:21:1;25623:2;25603:18;;;25596:30;-1:-1:-1;;;25642:18:1;;;25635:50;25702:18;;24556:47:0;25556:170:1;24556:47:0;24627:35;:19;24656:5;24627:28;:35::i;:::-;24616:46;;:8;;;:46;24673:10;24682:1;24673:10;;:::i;:::-;;-1:-1:-1;24708:36:0;:19;24673:10;24708:29;:36::i;:::-;24696:9;;;:48;24755:11;24764:2;24755:11;;:::i;:::-;;-1:-1:-1;24794:36:0;:19;24755:11;24794:29;:36::i;:::-;24779:12;;;:51;24841:11;24850:2;24841:11;;:::i;:::-;;;24903:5;24873:19;:26;:35;24865:68;;;;-1:-1:-1;;;24865:68:0;;25584:2:1;24865:68:0;;;25566:21:1;25623:2;25603:18;;;25596:30;-1:-1:-1;;;25642:18:1;;;25635:50;25702:18;;24865:68:0;25556:170:1;24865:68:0;24249:692;;;;:::o;22447:1019::-;22530:29;;:::i;:::-;22572:10;22612:31;:14;22572:10;22612:24;:31::i;:::-;22599:44;;22654:11;22663:2;22654:11;;:::i;:::-;;-1:-1:-1;22691:29:0;:14;22654:11;22691:22;:29::i;:::-;22678:42;;:10;;;:42;22731:10;22740:1;22731:10;;:::i;:::-;;;22762:3;:10;;;:15;;22776:1;22762:15;22754:54;;;;-1:-1:-1;;;22754:54:0;;14561:2:1;22754:54:0;;;14543:21:1;14600:2;14580:18;;;14573:30;14639:28;14619:18;;;14612:56;14685:18;;22754:54:0;14533:176:1;22754:54:0;22833:30;:14;22857:5;22833:23;:30::i;:::-;22821:42;;:9;;;:42;22874:10;22883:1;22874:10;;:::i;:::-;;-1:-1:-1;22923:30:0;:14;22874:10;22923:23;:30::i;:::-;22897:56;;:23;;;:56;22964:10;22973:1;22964:10;;:::i;:::-;;-1:-1:-1;22987:20:0;23010:29;:14;22964:10;23010:22;:29::i;:::-;22987:52;-1:-1:-1;23050:10:0;23059:1;23050:10;;:::i;:::-;;;23094:116;;;;;;;;23150:14;23136:29;;-1:-1:-1;;;;;23136:29:0;;;;;-1:-1:-1;;;23136:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23136:29:0;-1:-1:-1;23094:116:0;;23197:1;23094:116;;;;;;;23073:18;;;:137;;;;23223:154;23243:14;23239:18;;:1;:18;23223:154;;;23308:31;:14;23333:5;23308:24;:31::i;:::-;23279:18;;;;:23;:26;;23303:1;;23279:26;;;;-1:-1:-1;;;23279:26:0;;;;;;;;;-1:-1:-1;;;;;23279:60:0;;;:26;;;;;;;;;;;:60;23354:11;23363:2;23354:11;;:::i;:::-;;-1:-1:-1;23259:3:0;;;;:::i;:::-;;;;23223:154;;;;23422:5;23397:14;:21;:30;23389:69;;;;-1:-1:-1;;;23389:69:0;;14561:2:1;23389:69:0;;;14543:21:1;14600:2;14580:18;;;14573:30;14639:28;14619:18;;;14612:56;14685:18;;23389:69:0;14533:176:1;23389:69:0;22447:1019;;;;;:::o;63638:866::-;63712:8;:6;:8::i;:::-;63704:31;;;;-1:-1:-1;;;63704:31:0;;19570:2:1;63704:31:0;;;19552:21:1;19609:2;19589:18;;;19582:30;-1:-1:-1;;;19628:18:1;;;19621:40;19678:18;;63704:31:0;19542:160:1;63704:31:0;63748:20;63771:12;63779:3;63771:7;:12::i;:::-;63748:35;;63854:12;63868:20;63892:22;63911:2;63892:18;:22::i;:::-;63853:61;;;;63933:7;63942:6;63925:24;;;;;-1:-1:-1;;;63925:24:0;;;;;;;;:::i;:::-;;63962:43;64008:31;64028:2;:10;;;64008:19;:31::i;:::-;64106:10;;63962:77;;-1:-1:-1;58835:66:0;64106:20;64098:47;;;;-1:-1:-1;;;64098:47:0;;;;;;;:::i;:::-;64229:13;64211:3;:14;;;:31;64203:61;;;;-1:-1:-1;;;64203:61:0;;21344:2:1;64203:61:0;;;21326:21:1;21383:2;21363:18;;;21356:30;-1:-1:-1;;;21402:18:1;;;21395:47;21459:18;;64203:61:0;21316:167:1;64203:61:0;64349:36;64377:2;:7;;;64349:27;:36::i;:::-;64430:29;64444:3;:14;;;64430:13;:29::i;:::-;64481:14;;;;39709:6;:33;;-1:-1:-1;;39709:33:0;;;;;;;;;;;64470:26;63638:866;;;;;:::o;21742:620::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21899:31:0;:14;-1:-1:-1;21899:24:0;:31::i;:::-;21887:43;;21941:11;21950:2;21941:11;;:::i;:::-;;-1:-1:-1;21977:29:0;:14;21941:11;21977:22;:29::i;:::-;21965:41;;:9;;;:41;22017:10;22026:1;22017:10;;:::i;:::-;;;22048:2;:9;;;:14;;22061:1;22048:14;22040:50;;;;-1:-1:-1;;;22040:50:0;;23425:2:1;22040:50:0;;;23407:21:1;23464:2;23444:18;;;23437:30;-1:-1:-1;;;23483:18:1;;;23476:53;23546:18;;22040:50:0;23397:173:1;22040:50:0;22114:30;:14;22138:5;22114:23;:30::i;:::-;22103:41;;:8;;;:41;22155:10;22164:1;22155:10;;:::i;:::-;;-1:-1:-1;22219:31:0;:14;22155:10;22219:24;:31::i;:::-;-1:-1:-1;;;;;22178:75:0;:14;;;:75;22264:11;22273:2;22264:11;;:::i;:::-;;;22321:5;22296:14;:21;:30;22288:66;;;;-1:-1:-1;;;22288:66:0;;23425:2:1;22288:66:0;;;23407:21:1;23464:2;23444:18;;;23437:30;-1:-1:-1;;;23483:18:1;;;23476:53;23546:18;;22288:66:0;23397:173:1;23545:626:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23706:37:0;:20;-1:-1:-1;23706:30:0;:37::i;:::-;23693:50;;23754:11;23763:2;23754:11;;:::i;:::-;;-1:-1:-1;23791:35:0;:20;23754:11;23791:28;:35::i;:::-;23778:48;;:10;;;:48;23837:10;23846:1;23837:10;;:::i;:::-;;;23868:3;:10;;;:15;;23882:1;23868:15;23860:49;;;;-1:-1:-1;;;23860:49:0;;18456:2:1;23860:49:0;;;18438:21:1;18495:2;18475:18;;;18468:30;-1:-1:-1;;;18514:18:1;;;18507:51;18575:18;;23860:49:0;18428:171:1;23860:49:0;23934:36;:20;23964:5;23934:29;:36::i;:::-;23922:48;;:9;;;:48;23981:10;23990:1;23981:10;;:::i;:::-;;-1:-1:-1;24021:37:0;:20;23981:10;24021:30;:37::i;:::-;24004:14;;;:54;24069:11;24078:2;24069:11;;:::i;:::-;;;24132:5;24101:20;:27;:36;24093:70;;;;-1:-1:-1;;;24093:70:0;;18456:2:1;24093:70:0;;;18438:21:1;18495:2;18475:18;;;18468:30;-1:-1:-1;;;18514:18:1;;;18507:51;18575:18;;24093:70:0;18428:171:1;58983:856:0;59059:8;:6;:8::i;:::-;59058:9;59050:34;;;;-1:-1:-1;;;59050:34:0;;21003:2:1;59050:34:0;;;20985:21:1;21042:2;21022:18;;;21015:30;-1:-1:-1;;;21061:18:1;;;21054:42;21113:18;;59050:34:0;20975:162:1;59050:34:0;59097:20;59120:12;59128:3;59120:7;:12::i;:::-;59097:35;;59203:12;59217:20;59241:22;59260:2;59241:18;:22::i;:::-;59202:61;;;;59282:7;59291:6;59274:24;;;;;-1:-1:-1;;;59274:24:0;;;;;;;;:::i;:::-;;59311:48;59362:32;59383:2;:10;;;59362:20;:32::i;:::-;59461:14;;59311:83;;-1:-1:-1;58835:66:0;59461:24;59453:51;;;;-1:-1:-1;;;59453:51:0;;24134:2:1;59453:51:0;;;24116:21:1;24173:2;24153:18;;;24146:30;-1:-1:-1;;;24192:18:1;;;24185:44;24246:18;;59453:51:0;24106:164:1;59453:51:0;27736:6;27762:23;;;59570:26;;:7;:13;;;:26;;;59562:52;;;;-1:-1:-1;;;59562:52:0;;19909:2:1;59562:52:0;;;19891:21:1;19948:2;19928:18;;;19921:30;-1:-1:-1;;;19967:18:1;;;19960:43;20020:18;;59562:52:0;19881:163:1;59562:52:0;59680:36;59708:2;:7;;;59680:27;:36::i;:::-;59789:42;59811:7;:19;;;59789:21;:42::i;60810:1550::-;60876:20;60899:12;60907:3;60899:7;:12::i;:::-;60876:35;;60982:12;60996:20;61020:22;61039:2;61020:18;:22::i;:::-;60981:61;;;;61061:7;61070:6;61053:24;;;;;-1:-1:-1;;;61053:24:0;;;;;;;;:::i;:::-;;61090:51;61144:35;61168:2;:10;;;61144:23;:35::i;:::-;61246:14;;61090:89;;-1:-1:-1;58835:66:0;61246:24;61238:51;;;;-1:-1:-1;;;61238:51:0;;;;;;;:::i;:::-;27736:6;27762:23;;;61356:26;;:7;:13;;;:26;;;:39;;;;;61387:8;:6;:8::i;:::-;61386:9;61356:39;61355:63;;;-1:-1:-1;61400:13:0;;;;:18;;;61355:63;61347:89;;;;-1:-1:-1;;;61347:89:0;;16384:2:1;61347:89:0;;;16366:21:1;16423:2;16403:18;;;16396:30;-1:-1:-1;;;16442:18:1;;;16435:43;16495:18;;61347:89:0;16356:163:1;61347:89:0;61593:22;;;;:27;:34;61585:76;;;;-1:-1:-1;;;61585:76:0;;25230:2:1;61585:76:0;;;25212:21:1;25269:2;25249:18;;;25242:30;25308:27;25288:18;;;25281:55;25353:18;;61585:76:0;25202:175:1;61585:76:0;27252:23;;;;61792:32;;61823:1;61792:32;:::i;:::-;61761:63;;:7;:27;;;:63;;;61753:109;;;;-1:-1:-1;;;61753:109:0;;20601:2:1;61753:109:0;;;20583:21:1;20640:2;20620:18;;;20613:30;20679:34;20659:18;;;20652:62;-1:-1:-1;;;20730:18:1;;;20723:31;20771:19;;61753:109:0;20573:223:1;61753:109:0;61947:36;61975:2;:7;;;61947:27;:36::i;:::-;62059:47;62077:28;27252:23;;;;;27167:116;62077:28;62059:17;:47::i;:::-;62171:69;62188:7;:22;;;62212:7;:27;;;62171:16;:69::i;:::-;62324:27;;;;38873:23;:34;;-1:-1:-1;;38873:34:0;;;;;;;;;;;62301:51;38804:111;67336:1614;68992:22;69017:35;52366:66;52727:54;-1:-1:-1;;;;;52727:54:0;;52647:142;69017:35;68992:60;;69088:29;69102:14;-1:-1:-1;;;;;27641:39:0;27617:4;27641:39;;;:33;:39;;;;;;;;;27559:129;69088:29;69087:30;69065:99;;;;-1:-1:-1;;;69065:99:0;;17758:2:1;69065:99:0;;;17740:21:1;17797:2;17777:18;;;17770:30;-1:-1:-1;;;17816:18:1;;;17809:49;17875:18;;69065:99:0;17730:169:1;69065:99:0;69177:30;69192:14;-1:-1:-1;;;;;39449:49:0;:6;:49;;;:33;:49;;;;;:56;;-1:-1:-1;;39449:56:0;39501:4;39449:56;;;39381:132;69177:30;27871:17;;67465:1478:::1;;67503:18;67536:12:::0;67551:9:::1;27736:6:::0;27762:23;;;;27696:97;67551:9:::1;67536:24;;67645:5;:10;;67654:1;67645:10;67634:1256;;;67673:1;67660:14;;67634:1256;;;67721:5;:10;;67730:1;67721:10;67717:1173;;;67749:2;67736:15;;67717:1173;;;67792:5;:10;;67801:1;67792:10;67788:1102;;;67820:3;67807:16;;67788:1102;;;67867:5;:10;;67876:1;67867:10;67863:1027;;;67895:5;67882:18;;67863:1027;;;67944:5;:10;;67953:1;67944:10;67940:950;;;67972:5;67959:18;;67940:950;;;68017:5;:10;;68026:1;68017:10;68013:877;;;68045:10;68032:23;;68013:877;;;68091:5;:11;;68100:2;68091:11;68087:803;;;68119:3;68106:16;;68087:803;;;68165:5;:11;;68174:2;68165:11;68161:729;;;68193:3;68180:16;;68161:729;;;68239:5;:11;;68248:2;68239:11;68235:655;;;68267:3;68254:16;;68235:655;;;68312:5;:11;;68321:2;68312:11;68308:582;;;68340:4;68327:17;;68308:582;;;68386:5;:11;;68395:2;68386:11;68382:508;;;68414:5;68401:18;;68382:508;;;68458:5;:11;;68467:2;68458:11;68454:436;;;68486:4;68473:17;;68454:436;;;68534:5;:11;;68543:2;68534:11;68530:360;;;68562:9;68549:22;;68530:360;;;68606:5;:11;;68615:2;68606:11;68602:288;;;68634:5;68621:18;;68602:288;;;68682:5;:11;;68691:2;68682:11;68678:212;;;68710:2;68697:15;;68678:212;;;68758:5;:11;;68767:2;68758:11;68754:136;;;68786:3;68773:16;;68754:136;;;68847:27;::::0;-1:-1:-1;;;68847:27:0;;15265:2:1;68847:27:0::1;::::0;::::1;15247:21:1::0;15304:2;15284:18;;;15277:30;-1:-1:-1;;;15323:18:1;;;15316:47;15380:18;;68847:27:0::1;15237:167:1::0;68754:136:0::1;68906:25;68920:10;68906:13;:25::i;:::-;67465:1478;;;67336:1614:::0;:::o;29611:162::-;29672:10;29684:20;29735:26;29752:2;29756:4;29735:16;:26::i;:::-;29717:44;;;;-1:-1:-1;29611:162:0;-1:-1:-1;;29611:162:0:o;62460:1062::-;62524:20;62547:12;62555:3;62547:7;:12::i;:::-;62524:35;;62630:12;62644:20;62668:22;62687:2;62668:18;:22::i;:::-;62629:61;;;;62709:7;62718:6;62701:24;;;;;-1:-1:-1;;;62701:24:0;;;;;;;;:::i;:::-;;62792:46;62841:29;62859:2;:10;;;62841:17;:29::i;:::-;62937:15;;62792:78;;-1:-1:-1;58835:66:0;62937:25;62929:52;;;;-1:-1:-1;;;62929:52:0;;;;;;;:::i;:::-;27736:6;27762:23;;;63048:27;;:8;:14;;;:27;;;:40;;;;;63080:8;:6;:8::i;:::-;63079:9;63048:40;63047:65;;;-1:-1:-1;63093:14:0;;;;:19;;;63047:65;63039:91;;;;-1:-1:-1;;;63039:91:0;;16384:2:1;63039:91:0;;;16366:21:1;16423:2;16403:18;;;16396:30;-1:-1:-1;;;16442:18:1;;;16435:43;16495:18;;63039:91:0;16356:163:1;63039:91:0;63215:36;63243:2;:7;;;63215:27;:36::i;:::-;63391:18;;;;63498:15;;;;63479:35;;-1:-1:-1;;;;;63479:18:0;;;:35;;;;;63331:25;63479:35;63331:25;63479:35;63498:15;63479:18;:35;;;;;;;;;;;;;;;;;;;;;62460:1062;;;;;;:::o;33842:1902::-;34081:16;;:23;33982:10;;33994:20;;33982:10;;;34115:1479;34136:10;:17;34132:1;:21;34115:1479;;;34175:28;34206:10;34217:1;34206:13;;;;;;-1:-1:-1;;;34206:13:0;;;;;;;;;;;;;;;34175:44;;34234:17;34254:36;34264:4;34270:3;:5;;;34277:3;:5;;;34284:3;:5;;;34254:36;;;;;;;;;;;;;;;;;13619:25:1;;;13692:4;13680:17;;;;13675:2;13660:18;;13653:45;13729:2;13714:18;;13707:34;13772:2;13757:18;;13750:34;13606:3;13591:19;;13573:217;34254:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;34254:36:0;;-1:-1:-1;;34254:36:0;;;-1:-1:-1;;;;;;;34510:23:0;;34502:67;;;;-1:-1:-1;;;34502:67:0;;16024:2:1;34502:67:0;;;16006:21:1;16063:2;16043:18;;;16036:30;16102:33;16082:18;;;16075:61;16153:18;;34502:67:0;15996:181:1;34502:67:0;34669:6;;;:39;;;34699:9;34679:29;;:3;:17;;;:29;;;34669:39;34661:87;;;;-1:-1:-1;;;34661:87:0;;24477:2:1;34661:87:0;;;24459:21:1;24516:2;24496:18;;;24489:30;24555:34;24535:18;;;24528:62;-1:-1:-1;;;24606:18:1;;;24599:33;24649:19;;34661:87:0;24449:225:1;34661:87:0;34775:17;;;;;-1:-1:-1;35253:33:0;;;;-1:-1:-1;35245:74:0;;;;-1:-1:-1;;;35245:74:0;;23777:2:1;35245:74:0;;;23759:21:1;23816:2;23796:18;;;23789:30;23855;23835:18;;;23828:58;23903:18;;35245:74:0;23749:178:1;35245:74:0;35474:11;:16;;;35491:3;:17;;;35474:35;;;;;;;;-1:-1:-1;;;35474:35:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;35461:48:0;:9;-1:-1:-1;;;;;35461:48:0;;35458:125;;35537:5;35529:38;;;;;;;;;;;;;-1:-1:-1;;;35529:38:0;;;;;;;;;;;;;;35458:125;34115:1479;;34155:3;;;;;:::i;:::-;;;;34115:1479;;;;35727:4;35719:17;;;;;;;;;;;;;;;;;;33842:1902;;;;;;;:::o;35934:2354::-;36004:20;;:::i;:::-;36037:10;36077:24;:9;36037:10;36077:17;:24::i;:::-;36064:37;;;;36112:10;36121:1;36112:10;;:::i;:::-;;;36570:2;:10;;;:15;;36584:1;36570:15;36562:51;;;;-1:-1:-1;;;36562:51:0;;26273:2:1;36562:51:0;;;26255:21:1;26312:2;26292:18;;;26285:30;26351:25;26331:18;;;26324:53;26394:18;;36562:51:0;26245:173:1;36562:51:0;36649:25;:9;36668:5;36649:18;:25::i;:::-;36627:47;;:19;;;:47;36685:10;36694:1;36685:10;;:::i;:::-;;-1:-1:-1;36737:18:0;36758:24;:9;36685:10;36758:17;:24::i;:::-;36737:45;;;-1:-1:-1;36793:10:0;36802:1;36793:10;;:::i;:::-;;;36854;-1:-1:-1;;;;;36830:35:0;;;;;-1:-1:-1;;;36830:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36830:35:0;;-1:-1:-1;;36830:35:0;;;;;;;;;;;-1:-1:-1;36814:13:0;;;:51;36881:6;36876:415;36897:10;36893:1;:14;36876:415;;;36962:24;:9;36980:5;36962:17;:24::i;:::-;36929:2;:13;;;36943:1;36929:16;;;;;;-1:-1:-1;;;36929:16:0;;;;;;;;;;;;;;;;;;;:57;;;;:30;;;;:57;37001:10;37010:1;37001:10;;:::i;:::-;;-1:-1:-1;37049:26:0;:9;37001:10;37049:19;:26::i;:::-;37028:2;:13;;;37042:1;37028:16;;;;;;-1:-1:-1;;;37028:16:0;;;;;;;;;;;;;;;:18;;:47;;;;;37099:2;37090:11;;;;;:::i;:::-;;-1:-1:-1;37137:26:0;:9;37090:11;37137:19;:26::i;:::-;37116:2;:13;;;37130:1;37116:16;;;;;;-1:-1:-1;;;37116:16:0;;;;;;;;;;;;;;;:18;;:47;;;;;37187:2;37178:11;;;;;:::i;:::-;;-1:-1:-1;37225:24:0;:9;37178:11;37225:17;:24::i;:::-;:29;;37252:2;37225:29;:::i;:::-;37204:2;:13;;;37218:1;37204:16;;;;;;-1:-1:-1;;;37204:16:0;;;;;;;;;;;;;;;;;;;:50;;;;:18;;;;:50;37269:10;37278:1;37269:10;;:::i;:::-;;-1:-1:-1;36909:3:0;;;;:::i;:::-;;;;36876:415;;;;37589:17;37609:48;37625:5;37651;37632:9;:16;:24;;;;:::i;:::-;37609:9;;:48;:15;:48::i;:::-;37589:68;;37715:4;37705:15;;;;;;37688:33;;;;;;11528:19:1;;11572:2;11563:12;;11518:63;37688:33:0;;;;-1:-1:-1;;37688:33:0;;;;;;;;;37678:44;;37688:33;37678:44;;;;37668:7;;;:54;37777:25;:9;37796:5;37777:18;:25::i;:::-;37762:40;;:12;;;:40;37813:10;37822:1;37813:10;;:::i;:::-;;-1:-1:-1;37847:25:0;:9;37813:10;37847:18;:25::i;:::-;37836:36;;:8;;;:36;37883:10;37892:1;37883:10;;:::i;:::-;;-1:-1:-1;37926:25:0;:9;37883:10;37926:18;:25::i;:::-;37906:45;;:17;;;:45;37962:10;37971:1;37962:10;;:::i;:::-;;-1:-1:-1;38005:26:0;:9;37962:10;38005:19;:26::i;:::-;37985:17;;;:46;38042:11;38051:2;38042:11;;:::i;:::-;;-1:-1:-1;38080:25:0;:9;38042:11;38080:18;:25::i;:::-;-1:-1:-1;;;;;38066:39:0;:11;;;:39;38116:10;38125:1;38116:10;;:::i;:::-;;-1:-1:-1;38161:24:0;:9;38116:10;38161:17;:24::i;:::-;38139:46;;:19;;;:46;38196:10;38205:1;38196:10;;:::i;:::-;;;38232:48;38248:5;38274;38255:9;:16;:24;;;;:::i;38232:48::-;38219:10;;;:61;-1:-1:-1;38219:2:0;;35934:2354;-1:-1:-1;;;35934:2354:0:o;66739:408::-;66881:15;66952:12;28333:17;;;28263:95;66952:12;66939:9;:25;66931:49;;;;-1:-1:-1;;;66931:49:0;;17075:2:1;66931:49:0;;;17057:21:1;17114:2;17094:18;;;17087:30;-1:-1:-1;;;17133:18:1;;;17126:41;17184:18;;66931:49:0;17047:161:1;66931:49:0;67004:23;67016:10;67004:11;:23::i;:::-;66993:34;;67084:10;-1:-1:-1;;;;;67064:75:0;;67096:8;67106:5;67113:7;67122:16;67064:75;;;;;;;;;:::i;:::-;;;;;;;;66739:408;;;;;:::o;28789:374::-;28862:20;;:::i;:::-;28884:10;28896:20;28934:18;28942:9;;28934:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28934:7:0;;-1:-1:-1;;;28934:18:0:i;:::-;28929:23;;29128:27;29145:2;29149:5;29128:16;:27::i;:::-;28789:374;;29110:45;;-1:-1:-1;29110:45:0;;-1:-1:-1;;;28789:374:0:o;25021:641::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25185:38:0;:21;-1:-1:-1;25185:31:0;:38::i;:::-;25172:51;;25234:11;25243:2;25234:11;;:::i;:::-;;-1:-1:-1;25271:36:0;:21;25234:11;25271:29;:36::i;:::-;25258:49;;:10;;;:49;25318:10;25327:1;25318:10;;:::i;:::-;;;25349:3;:10;;;:15;;25363:1;25349:15;25341:50;;;;-1:-1:-1;;;25341:50:0;;22727:2:1;25341:50:0;;;22709:21:1;22766:2;22746:18;;;22739:30;-1:-1:-1;;;22785:18:1;;;22778:52;22847:18;;25341:50:0;22699:172:1;25341:50:0;25421:38;:21;25453:5;25421:31;:38::i;:::-;25404:14;;;:55;25470:11;25479:2;25470:11;;:::i;:::-;;-1:-1:-1;25511:37:0;:21;25470:11;25511:30;:37::i;:::-;25494:54;;:14;;;:54;25559:10;25568:1;25559:10;;:::i;:::-;;;25622:5;25590:21;:28;:37;25582:72;;;;-1:-1:-1;;;25582:72:0;;22727:2:1;25582:72:0;;;22709:21:1;22766:2;22746:18;;;22739:30;-1:-1:-1;;;22785:18:1;;;22778:52;22847:18;;25582:72:0;22699:172:1;27904:100:0;27943:4;27983:13;27967:12;27871:17;;;27801:95;27967:12;:29;;27960:36;;27904:100;:::o;59920:801::-;59985:20;60008:12;60016:3;60008:7;:12::i;:::-;59985:35;;60091:12;60105:20;60129:22;60148:2;60129:18;:22::i;:::-;60090:61;;;;60170:7;60179:6;60162:24;;;;;-1:-1:-1;;;60162:24:0;;;;;;;;:::i;:::-;;60199:46;60248:30;60267:2;:10;;;60248:18;:30::i;:::-;60345:14;;60199:79;;-1:-1:-1;58835:66:0;60345:24;60337:51;;;;-1:-1:-1;;;60337:51:0;;24134:2:1;60337:51:0;;;24116:21:1;24173:2;24153:18;;;24146:30;-1:-1:-1;;;24192:18:1;;;24185:44;24246:18;;60337:51:0;24106:164:1;60337:51:0;27736:6;27762:23;;;60454:26;;:7;:13;;;:26;;;:39;;;;;60485:8;:6;:8::i;:::-;60484:9;60454:39;60446:65;;;;-1:-1:-1;;;60446:65:0;;19909:2:1;60446:65:0;;;19891:21:1;19948:2;19928:18;;;19921:30;-1:-1:-1;;;19967:18:1;;;19960:43;20020:18;;60446:65:0;19881:163:1;60446:65:0;60596:36;60624:2;:7;;;60596:27;:36::i;:::-;60680:33;60694:7;:18;;;40092:17;:26;40033:93;38413:262;38477:35;38595:3;38580:12;:18;38572:49;;;;-1:-1:-1;;;38572:49:0;;26625:2:1;38572:49:0;;;26607:21:1;26664:2;26644:18;;;26637:30;-1:-1:-1;;;26683:18:1;;;26676:48;26741:18;;38572:49:0;26597:168:1;38572:49:0;38661:1;38641:16;:12;38656:1;38641:16;:::i;:::-;38640:22;;;;:::i;:::-;38639:28;;38666:1;38639:28;:::i;:::-;38632:35;38413:262;-1:-1:-1;;38413:262:0:o;27020:139::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;27125:26:0;;;;;:19;:26;;;;;;27118:33;;;;;;;;;;;;;;;;;;;-1:-1:-1;;27118:33:0;27125:26;;27118:33;;27125:26;;27118:33;;27125:26;27118:33;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;27118:33:0;;;;;;;;;;;;;;;;-1:-1:-1;;;27118:33:0;;;-1:-1:-1;;27118:33:0;;;;;;;;;;;;;;27020:139;-1:-1:-1;;27020:139:0:o;15904:329::-;15983:7;16028:11;:6;16037:2;16028:11;:::i;:::-;16011:6;:13;:28;;16003:62;;;;-1:-1:-1;;;16003:62:0;;18806:2:1;16003:62:0;;;18788:21:1;18845:2;18825:18;;;18818:30;-1:-1:-1;;;18864:18:1;;;18857:51;18925:18;;16003:62:0;18778:171:1;16003:62:0;-1:-1:-1;16153:30:0;16169:4;16153:30;16147:37;;15904:329::o;13640:311::-;13717:5;13760:10;:6;13769:1;13760:10;:::i;:::-;13743:6;:13;:27;;13735:60;;;;-1:-1:-1;;;13735:60:0;;22379:2:1;13735:60:0;;;22361:21:1;22418:2;22398:18;;;22391:30;-1:-1:-1;;;22437:18:1;;;22430:49;22496:18;;13735:60:0;22351:169:1;13735:60:0;-1:-1:-1;13875:29:0;13891:3;13875:29;13869:36;;13640:311::o;13959:314::-;14037:6;14081:10;:6;14090:1;14081:10;:::i;:::-;14064:6;:13;:27;;14056:60;;;;-1:-1:-1;;;14056:60:0;;14916:2:1;14056:60:0;;;14898:21:1;14955:2;14935:18;;;14928:30;-1:-1:-1;;;14974:18:1;;;14967:50;15034:18;;14056:60:0;14888:170:1;14056:60:0;-1:-1:-1;14197:29:0;14213:3;14197:29;14191:36;;13959:314::o;15576:320::-;15655:7;15700:11;:6;15709:2;15700:11;:::i;:::-;15683:6;:13;:28;;15675:62;;;;-1:-1:-1;;;15675:62:0;;18106:2:1;15675:62:0;;;18088:21:1;18145:2;18125:18;;;18118:30;-1:-1:-1;;;18164:18:1;;;18157:51;18225:18;;15675:62:0;18078:171:1;14281:314:0;14359:6;14403:10;:6;14412:1;14403:10;:::i;:::-;14386:6;:13;:27;;14378:60;;;;-1:-1:-1;;;14378:60:0;;24881:2:1;14378:60:0;;;24863:21:1;24920:2;24900:18;;;24893:30;-1:-1:-1;;;24939:18:1;;;24932:50;24999:18;;14378:60:0;24853:170:1;14378:60:0;-1:-1:-1;14519:29:0;14535:3;14519:29;14513:36;;14281:314::o;13269:363::-;13348:7;13393:11;:6;13402:2;13393:11;:::i;:::-;13376:6;:13;:28;;13368:62;;;;-1:-1:-1;;;13368:62:0;;20251:2:1;13368:62:0;;;20233:21:1;20290:2;20270:18;;;20263:30;-1:-1:-1;;;20309:18:1;;;20302:51;20370:18;;13368:62:0;20223:171:1;13368:62:0;-1:-1:-1;13522:30:0;13538:4;13522:30;13516:37;-1:-1:-1;;;13512:71:0;;;13269:363::o;65170:1221::-;65243:4;65249:13;65311:12;65325:20;65349:12;65358:2;65349:8;:12::i;:::-;65310:51;;;;65377:7;65372:62;;65408:5;;65415:6;;-1:-1:-1;65170:1221:0;-1:-1:-1;;;65170:1221:0:o;65372:62::-;27252:23;;;;65515:51;;:2;:19;;;:51;;;65511:136;;65591:5;65583:52;;;;;;;;;;;;;;;;;;;;;;;65170:1221;;;:::o;65511:136::-;28062:6;28087:33;;;;;;65728:48;;65735:2;:17;;;65728:48;;;65724:121;;65801:5;65793:40;;;;;;;;;;;;;-1:-1:-1;;;65793:40:0;;;;;;;;;65170:1221;;;:::o;65724:121::-;28213:34;;65946:2;:17;;;:41;65942:117;;66012:5;66004:43;;;;;;;;;;;;;;;;;;;;;;;65170:1221;;;:::o;65942:117::-;66215:7;;;;27481:4;27505:38;;;:32;:38;;;;;;;;66184:119;;;66247:5;66239:52;;;;;;;;;;;;;;;;;;;;;;;65170:1221;;;:::o;66184:119::-;66374:4;66366:17;;;;;;;;;;;;;;;;;;65170:1221;;;:::o;39521:124::-;39592:6;:38;;;:32;:38;;;;;:45;;-1:-1:-1;;39592:45:0;39633:4;39592:45;;;39521:124::o;40265:170::-;40350:13;40336:10;:27;40328:58;;;;-1:-1:-1;;;40328:58:0;;23078:2:1;40328:58:0;;;23060:21:1;23117:2;23097:18;;;23090:30;-1:-1:-1;;;23136:18:1;;;23129:48;23194:18;;40328:58:0;23050:168:1;40328:58:0;40397:17;:30;40265:170::o;64607:486::-;64685:29;64717:20;52366:66;52727:54;-1:-1:-1;;;;;52727:54:0;;52647:142;64717:20;64685:52;;64750:29;64761:17;64750:10;:29::i;:::-;64924:39;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64924:39:0;-1:-1:-1;;;64924:39:0;;;64893:71;;64856:12;;;;-1:-1:-1;;;;;64893:30:0;;;:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64855:109;;;;64985:7;65001:6;64977:32;;;;;-1:-1:-1;;;64977:32:0;;;;;;;;:::i;:::-;;65067:17;-1:-1:-1;;;;;65027:58:0;65044:21;-1:-1:-1;;;;;65027:58:0;;;;;;;;;;;64607:486;;;;:::o;38923:144::-;39028:31;39035:15;39054:5;39028:31;:::i;:::-;38984:26;;;;:6;:26;;;:19;:26;;;;;:41;;:75;;-1:-1:-1;;38984:75:0;;;;;;;;38923:144::o;39075:298::-;39184:8;;:15;39167:14;39210:113;39231:9;39227:1;:13;39210:113;;;39270:8;;:11;;39293:1;;39270:8;39279:1;;39270:11;;;;-1:-1:-1;;;39270:11:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;39270:25:0;;;39262:49;;;;-1:-1:-1;;;39262:49:0;;14221:2:1;39262:49:0;;;14203:21:1;14260:2;14240:18;;;14233:30;-1:-1:-1;;;14279:18:1;;;14272:41;14330:18;;39262:49:0;14193:161:1;39262:49:0;39242:3;;;;:::i;:::-;;;;39210:113;;;-1:-1:-1;39333:26:0;;;:6;:26;;;:19;:26;;;;;;;;:32;;;;39362:3;;39333:32;;:26;;:32;;;;:::i;:::-;-1:-1:-1;39333:32:0;;;;;;;;;;;;-1:-1:-1;;39333:32:0;;;;;;;;;;;-1:-1:-1;;;39075:298:0:o;30149:3189::-;30236:10;30248:20;30364:38;30405:35;30420:2;:19;;;30405:14;:35::i;:::-;30364:76;;30951:9;30948:512;;;31031:12;;;;;31062:8;;;;;31089:17;;;;31125;;;;31161:11;;;;31191:19;;;;31229:10;;;;30996:258;;30976:17;;30996:258;;31031:12;31229:10;30996:258;;:::i;:::-;;;;;;;;;;;;;30976:278;;31271:14;31325:4;31315:15;;;;;;31298:33;;;;;;11528:19:1;;11572:2;11563:12;;11518:63;31298:33:0;;;;;;;;;;;;;31288:44;;;;;;31271:61;;31362:2;:7;;;31352:6;:17;31349:100;;31397:5;31389:44;;;;;;;;;;;;;;;;;;;;;;;;;;31349:100;30948:512;;;31924:16;;:23;31921:97;;-1:-1:-1;;31968:38:0;;;;;;;;;;;;-1:-1:-1;;;31968:38:0;;;;31976:5;;-1:-1:-1;31968:38:0;;31921:97;27252:23;;;;32146:51;;:2;:19;;;:51;;;;:99;;;;;32230:15;32201:11;:26;;;:44;;;32146:99;32143:172;;;-1:-1:-1;;32261:42:0;;;;;;;;;;;;;;;;;32269:5;;-1:-1:-1;32261:42:0;;32143:172;32837:16;;:23;32830:31;;:6;:31::i;:::-;32807:2;:13;;;:20;:54;32803:113;;;-1:-1:-1;;32877:27:0;;;;;;;;;;;;-1:-1:-1;;;32877:27:0;;;;32885:5;;-1:-1:-1;32877:27:0;;32803:113;33005:20;33027:27;33058:53;33075:2;:7;;;33084:2;:13;;;33099:11;33058:16;:53::i;:::-;33004:107;;;;33126:15;33122:76;;33165:5;;-1:-1:-1;33172:13:0;-1:-1:-1;33157:29:0;;-1:-1:-1;;33157:29:0;33122:76;33321:4;33313:17;;;;;;;;;;;;;;;;;;;30149:3189;;;;;;:::o;10390:2871::-;10543:12;10597:7;10581:12;10597:7;10591:2;10581:12;:::i;:::-;:23;;10573:50;;;;-1:-1:-1;;;10573:50:0;;17415:2:1;10573:50:0;;;17397:21:1;17454:2;17434:18;;;17427:30;-1:-1:-1;;;17473:18:1;;;17466:44;17527:18;;10573:50:0;17387:164:1;10573:50:0;10659:16;10668:7;10659:6;:16;:::i;:::-;10642:6;:13;:33;;10634:63;;;;-1:-1:-1;;;10634:63:0;;22033:2:1;10634:63:0;;;22015:21:1;22072:2;22052:18;;;22045:30;-1:-1:-1;;;22091:18:1;;;22084:47;22148:18;;10634:63:0;22005:167:1;10634:63:0;10710:22;10776:15;;10805:2005;;;;12954:4;12948:11;12935:24;;13143:1;13132:9;13125:20;13193:4;13182:9;13178:20;13172:4;13165:34;10769:2445;;10805:2005;10990:4;10984:11;10971:24;;11659:2;11650:7;11646:16;12047:9;12040:17;12034:4;12030:28;12018:9;12007;12003:25;11999:60;12096:7;12092:2;12088:16;12353:6;12339:9;12332:17;12326:4;12322:28;12310:9;12302:6;12298:22;12294:57;12290:70;12124:434;12387:3;12383:2;12380:11;12124:434;;;12529:9;;12518:21;;12429:4;12421:13;;;;12462;12124:434;;;-1:-1:-1;;12578:26:0;;;12790:2;12773:11;-1:-1:-1;;12769:25:0;12763:4;12756:39;-1:-1:-1;10769:2445:0;-1:-1:-1;13244:9:0;10390:2871;-1:-1:-1;;;;10390:2871:0:o;14603:314::-;14681:6;14725:10;:6;14734:1;14725:10;:::i;:::-;14708:6;:13;:27;;14700:60;;;;-1:-1:-1;;;14700:60:0;;16726:2:1;14700:60:0;;;16708:21:1;16765:2;16745:18;;;16738:30;-1:-1:-1;;;16784:18:1;;;16777:50;16844:18;;14700:60:0;16698:170:1;14700:60:0;-1:-1:-1;14841:29:0;14857:3;14841:29;14835:36;;14603:314::o;67155:173::-;-1:-1:-1;;;;;28452:25:0;;67211:15;28452:25;;;:16;:25;;;;;;-1:-1:-1;;;;;28452:25:0;67282:38;28452:25;67307:12;28452:25;67318:1;67307:12;:::i;:::-;-1:-1:-1;;;;;40213:25:0;;;;:6;:25;;;:16;:25;;;;;:36;;-1:-1:-1;;40213:36:0;-1:-1:-1;;;;;40213:36:0;;;;;;;;;40134:123;67282:38;67155:173;;;:::o;53260:155::-;53327:37;53346:17;53327:18;:37::i;:::-;53380:27;;-1:-1:-1;;;;;53380:27:0;;;;;;;;53260:155;:::o;52885:262::-;41964:20;;52959:95;;;;-1:-1:-1;;;52959:95:0;;19156:2:1;52959:95:0;;;19138:21:1;19195:2;19175:18;;;19168:30;19234:34;19214:18;;;19207:62;-1:-1:-1;;;19285:18:1;;;19278:43;19338:19;;52959:95:0;19128:235:1;52959:95:0;52366:66;53065:74;;-1:-1:-1;;;;;;53065:74:0;-1:-1:-1;;;;;53065:74:0;;;;;;;;;;52885:262::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;192:1120;255:5;308:3;301:4;293:6;289:17;285:27;275:2;;330:5;323;316:20;275:2;370:6;357:20;396:4;420:60;436:43;476:2;436:43;:::i;:::-;420:60;:::i;:::-;502:3;526:2;521:3;514:15;554:2;549:3;545:12;538:19;;589:2;581:6;577:15;641:3;636:2;630;627:1;623:10;615:6;611:23;607:32;604:41;601:2;;;662:5;655;648:20;601:2;688:5;702:581;716:2;713:1;710:9;702:581;;;771:4;810:2;804:3;799;795:13;791:22;788:2;;;830:5;823;816:20;788:2;864:22;;:::i;:::-;926:3;913:17;906:5;899:32;989:2;984:3;980:12;967:26;962:2;955:5;951:14;944:50;1017:2;1055:30;1081:2;1076:3;1072:12;1055:30;:::i;:::-;1039:14;;;1032:54;1109:2;1147:30;1164:12;;;1147:30;:::i;:::-;1131:14;;;1124:54;1191:18;;1229:12;;;;1261;;;;;734:1;727:9;702:581;;;-1:-1:-1;1301:5:1;;265:1047;-1:-1:-1;;;;;;;265:1047:1:o;1317:550::-;1359:5;1412:3;1405:4;1397:6;1393:17;1389:27;1379:2;;1434:5;1427;1420:20;1379:2;1474:6;1461:20;-1:-1:-1;;;;;1496:2:1;1493:26;1490:2;;;1522:18;;:::i;:::-;1566:55;1609:2;1590:13;;-1:-1:-1;;1586:27:1;1615:4;1582:38;1566:55;:::i;:::-;1646:2;1637:7;1630:19;1692:3;1685:4;1680:2;1672:6;1668:15;1664:26;1661:35;1658:2;;;1713:5;1706;1699:20;1658:2;1782;1775:4;1767:6;1763:17;1756:4;1747:7;1743:18;1730:55;1805:16;;;1823:4;1801:27;1794:42;;;;1809:7;1369:498;-1:-1:-1;;1369:498:1:o;1872:159::-;1939:20;;1999:6;1988:18;;1978:29;;1968:2;;2021:1;2018;2011:12;2036:163;2103:20;;2163:10;2152:22;;2142:33;;2132:2;;2189:1;2186;2179:12;2204:171;2271:20;;-1:-1:-1;;;;;2320:30:1;;2310:41;;2300:2;;2365:1;2362;2355:12;2380:156;2446:20;;2506:4;2495:16;;2485:27;;2475:2;;2526:1;2523;2516:12;2541:196;2600:6;2653:2;2641:9;2632:7;2628:23;2624:32;2621:2;;;2674:6;2666;2659:22;2621:2;2702:29;2721:9;2702:29;:::i;:::-;2692:39;2611:126;-1:-1:-1;;;2611:126:1:o;2742:190::-;2801:6;2854:2;2842:9;2833:7;2829:23;2825:32;2822:2;;;2875:6;2867;2860:22;2822:2;-1:-1:-1;2903:23:1;;2812:120;-1:-1:-1;2812:120:1:o;2937:1646::-;3091:6;3099;3107;3160:2;3148:9;3139:7;3135:23;3131:32;3128:2;;;3181:6;3173;3166:22;3128:2;3222:9;3209:23;3199:33;;3251:2;3304;3293:9;3289:18;3276:32;-1:-1:-1;;;;;3368:2:1;3360:6;3357:14;3354:2;;;3389:6;3381;3374:22;3354:2;3417:70;3479:7;3470:6;3459:9;3455:22;3417:70;:::i;:::-;3407:80;;3540:2;3529:9;3525:18;3512:32;3496:48;;3569:2;3559:8;3556:16;3553:2;;;3590:6;3582;3575:22;3553:2;3618:24;;;;3676:2;3658:16;;;3654:25;3651:2;;;3697:6;3689;3682:22;3651:2;3728:22;;:::i;:::-;3788:2;3775:16;3816:2;3806:8;3803:16;3800:2;;;3837:6;3829;3822:22;3800:2;3865:17;;;-1:-1:-1;3913:4:1;3905:13;;3901:27;-1:-1:-1;3891:2:1;;3947:6;3939;3932:22;3891:2;3988;3975:16;4011:60;4027:43;4067:2;4027:43;:::i;4011:60::-;4093:3;4117:2;4112:3;4105:15;4145:2;4140:3;4136:12;4129:19;;4176:2;4172;4168:11;4224:7;4219:2;4213;4210:1;4206:10;4202:2;4198:19;4194:28;4191:41;4188:2;;;4250:6;4242;4235:22;4188:2;4277:6;4268:15;;4292:169;4306:2;4303:1;4300:9;4292:169;;;4363:23;4382:3;4363:23;:::i;:::-;4351:36;;4324:1;4317:9;;;;;4407:12;;;;4439;;4292:169;;;-1:-1:-1;4470:20:1;;-1:-1:-1;4522:30:1;;-1:-1:-1;4540:11:1;;;4522:30;:::i;:::-;4517:2;4510:5;4506:14;4499:54;4572:5;4562:15;;;;;;3118:1465;;;;;:::o;4588:641::-;4658:6;4666;4719:2;4707:9;4698:7;4694:23;4690:32;4687:2;;;4740:6;4732;4725:22;4687:2;4785:9;4772:23;-1:-1:-1;;;;;4855:2:1;4847:6;4844:14;4841:2;;;4876:6;4868;4861:22;4841:2;4919:6;4908:9;4904:22;4894:32;;4964:7;4957:4;4953:2;4949:13;4945:27;4935:2;;4991:6;4983;4976:22;4935:2;5036;5023:16;5062:2;5054:6;5051:14;5048:2;;;5083:6;5075;5068:22;5048:2;5133:7;5128:2;5119:6;5115:2;5111:15;5107:24;5104:37;5101:2;;;5159:6;5151;5144:22;5101:2;5195;5187:11;;;;;5217:6;;-1:-1:-1;4677:552:1;;-1:-1:-1;;;;4677:552:1:o;5234:340::-;5302:6;5355:2;5343:9;5334:7;5330:23;5326:32;5323:2;;;5376:6;5368;5361:22;5323:2;5421:9;5408:23;-1:-1:-1;;;;;5446:6:1;5443:30;5440:2;;;5491:6;5483;5476:22;5440:2;5519:49;5560:7;5551:6;5540:9;5536:22;5519:49;:::i;:::-;5509:59;5313:261;-1:-1:-1;;;;5313:261:1:o;5579:1475::-;5656:6;5709:2;5697:9;5688:7;5684:23;5680:32;5677:2;;;5730:6;5722;5715:22;5677:2;5775:9;5762:23;-1:-1:-1;;;;;5845:2:1;5837:6;5834:14;5831:2;;;5866:6;5858;5851:22;5831:2;5894:22;;;;5950:6;5932:16;;;5928:29;5925:2;;;5975:6;5967;5960:22;5925:2;6006:22;;:::i;:::-;6051:20;6068:2;6051:20;:::i;:::-;6044:5;6037:35;6104:30;6130:2;6126;6122:11;6104:30;:::i;:::-;6099:2;6092:5;6088:14;6081:54;6167:30;6193:2;6189;6185:11;6167:30;:::i;:::-;6162:2;6155:5;6151:14;6144:54;6230:30;6256:2;6252;6248:11;6230:30;:::i;:::-;6225:2;6218:5;6214:14;6207:54;6315:3;6311:2;6307:12;6294:26;6288:3;6281:5;6277:15;6270:51;6354:31;6380:3;6376:2;6372:12;6354:31;:::i;:::-;6348:3;6341:5;6337:15;6330:56;6419:30;6444:3;6440:2;6436:12;6419:30;:::i;:::-;6413:3;6406:5;6402:15;6395:55;6496:3;6492:2;6488:12;6475:26;6526:2;6516:8;6513:16;6510:2;;;6547:6;6539;6532:22;6510:2;6589:44;6625:7;6614:8;6610:2;6606:17;6589:44;:::i;:::-;6583:3;6576:5;6572:15;6565:69;;6653:3;6688:30;6714:2;6710;6706:11;6688:30;:::i;:::-;6672:14;;;6665:54;6738:3;6779:11;;;6766:25;6803:16;;;6800:2;;;6837:6;6829;6822:22;6800:2;6878:65;6935:7;6924:8;6920:2;6916:17;6878:65;:::i;:::-;6862:14;;;6855:89;;;;-1:-1:-1;6963:3:1;7011:11;;;6998:25;6982:14;;;6975:49;;;;-1:-1:-1;6866:5:1;5667:1387;-1:-1:-1;;;5667:1387:1:o;7254:194::-;7312:6;7365:2;7353:9;7344:7;7340:23;7336:32;7333:2;;;7386:6;7378;7371:22;7333:2;7414:28;7432:9;7414:28;:::i;7453:482::-;7536:6;7544;7552;7605:2;7593:9;7584:7;7580:23;7576:32;7573:2;;;7626:6;7618;7611:22;7573:2;7654:28;7672:9;7654:28;:::i;:::-;7644:38;;7733:2;7722:9;7718:18;7705:32;-1:-1:-1;;;;;7752:6:1;7749:30;7746:2;;;7797:6;7789;7782:22;7746:2;7825:49;7866:7;7857:6;7846:9;7842:22;7825:49;:::i;:::-;7815:59;;;7893:36;7925:2;7914:9;7910:18;7893:36;:::i;:::-;7883:46;;7563:372;;;;;:::o;7940:783::-;8002:3;8040:5;8034:12;8067:6;8062:3;8055:19;8093:4;8122:2;8117:3;8113:12;8106:19;;8159:2;8152:5;8148:14;8180:3;8192:506;8206:6;8203:1;8200:13;8192:506;;;8265:13;;8303:9;;8291:22;;8353:11;;;8347:18;8333:12;;;8326:40;8389:4;8432:11;;;8426:18;8467:4;8505:21;;;8491:12;;;8484:43;;;;8550:4;8598:11;;;8592:18;8588:27;8574:12;;;8567:49;8645:4;8636:14;;;;8673:15;;;;8228:1;8221:9;8192:506;;;-1:-1:-1;8714:3:1;;8010:713;-1:-1:-1;;;;;8010:713:1:o;8728:257::-;8769:3;8807:5;8801:12;8834:6;8829:3;8822:19;8850:63;8906:6;8899:4;8894:3;8890:14;8883:4;8876:5;8872:16;8850:63;:::i;:::-;8967:2;8946:15;-1:-1:-1;;8942:29:1;8933:39;;;;8974:4;8929:50;;8777:208;-1:-1:-1;;8777:208:1:o;8990:686::-;9117:12;;9083:4;9138:17;;;9204:19;;9074:14;;;9232:20;;;9044:3;;9301:4;;9328:21;;;;9279:2;9270:12;;;9044:3;9379:201;9393:6;9390:1;9387:13;9379:201;;;9460:13;;-1:-1:-1;;;;;9456:39:1;9442:54;;9555:15;;;;9518:14;;;;9492:1;9408:9;9379:201;;;-1:-1:-1;;9620:14:1;;;9614:21;9637:10;9610:38;9596:12;;;;9589:60;;;;-1:-1:-1;9665:5:1;9052:624;-1:-1:-1;9052:624:1:o;9681:1332::-;9786:12;;11386:4;11375:16;11363:29;;9726:3;9754:6;9850:4;9843:5;9839:16;9833:23;9865:47;9906:4;9901:3;9897:14;9883:12;11189:10;11178:22;11166:35;;11156:51;9865:47;;9960:4;9953:5;9949:16;9943:23;9975:49;10018:4;10013:3;10009:14;9993;11189:10;11178:22;11166:35;;11156:51;9975:49;;10072:4;10065:5;10061:16;10055:23;10087:49;10130:4;10125:3;10121:14;10105;11094:6;11083:18;11071:31;;11061:47;10087:49;;10185:4;10178:5;10174:16;10168:23;10161:4;10156:3;10152:14;10145:47;10240:4;10233:5;10229:16;10223:23;10255:49;10298:4;10293:3;10289:14;10273;-1:-1:-1;;;;;11277:30:1;11265:43;;11255:59;10255:49;;10352:4;10345:5;10341:16;10335:23;10367:48;10409:4;10404:3;10400:14;10384;11386:4;11375:16;11363:29;;11361:33;10367:48;;10463:4;10456:5;10452:16;10446:23;10501:2;10494:4;10489:3;10485:14;10478:26;10525:46;10567:2;10562:3;10558:12;10542:14;10525:46;:::i;:::-;10513:58;;;10590:6;10644:2;10637:5;10633:14;10627:21;10657:47;10700:2;10695:3;10691:12;10675:14;11189:10;11178:22;11166:35;;11156:51;10657:47;;;10723:6;10777:2;10770:5;10766:14;10760:21;10821:3;10815:4;10811:14;10806:2;10801:3;10797:12;10790:36;10849:59;10903:4;10887:14;10849:59;:::i;:::-;10927:6;10969:14;;;10963:21;10949:12;;;;10942:43;;;;-1:-1:-1;10835:73:1;;9734:1279;-1:-1:-1;;;9734:1279:1:o;11586:274::-;11715:3;11753:6;11747:13;11769:53;11815:6;11810:3;11803:4;11795:6;11791:17;11769:53;:::i;:::-;11838:16;;;;;11723:137;-1:-1:-1;;11723:137:1:o;11865:843::-;-1:-1:-1;;;;;;12182:3:1;12223:16;;;12219:25;;12207:38;;12278:16;;;12274:25;12270:1;12261:11;;12254:46;-1:-1:-1;;;;;;12355:3:1;12333:16;;;12329:38;12325:1;12316:11;;12309:59;12393:2;12384:12;;12377:28;;;-1:-1:-1;;;;;;12461:3:1;12439:16;;;12435:51;12430:2;12421:12;;12414:73;-1:-1:-1;;;;;;12543:3:1;12521:16;;;12517:36;12512:2;12503:12;;12496:58;12577:13;;-1:-1:-1;;12599:62:1;12577:13;12649:2;12640:12;;12633:4;12621:17;;12599:62;:::i;:::-;12681:16;;;;12699:2;12677:25;;12158:550;-1:-1:-1;;;;;;;;12158:550:1:o;12905:300::-;13090:6;13083:14;13076:22;13065:9;13058:41;13135:2;13130;13119:9;13115:18;13108:30;13039:4;13155:44;13195:2;13184:9;13180:18;13172:6;13155:44;:::i;13795:219::-;13944:2;13933:9;13926:21;13907:4;13964:44;14004:2;13993:9;13989:18;13981:6;13964:44;:::i;21488:338::-;21690:2;21672:21;;;21729:2;21709:18;;;21702:30;-1:-1:-1;;;21763:2:1;21748:18;;21741:44;21817:2;21802:18;;21662:164::o;27263:682::-;27462:2;27451:9;27444:21;27507:6;27501:13;27496:2;27485:9;27481:18;27474:41;27579:4;27573:2;27565:6;27561:15;27555:22;27551:33;27546:2;27535:9;27531:18;27524:61;27649:6;27643:2;27635:6;27631:15;27625:22;27621:35;27616:2;27605:9;27601:18;27594:63;27425:4;27704:2;27696:6;27692:15;27686:22;27745:4;27739:3;27728:9;27724:19;27717:33;27773:64;27832:3;27821:9;27817:19;27803:12;27773:64;:::i;:::-;27759:78;;27904:10;27897:3;27889:6;27885:16;27879:23;27875:40;27868:4;27857:9;27853:20;27846:70;27933:6;27925:14;;;27434:511;;;;:::o;27950:266::-;28133:2;28122:9;28115:21;28096:4;28153:57;28206:2;28195:9;28191:18;28183:6;28153:57;:::i;29673:239::-;29838:2;29827:9;29820:21;29801:4;29858:48;29902:2;29891:9;29887:18;29879:6;29858:48;:::i;29917:482::-;30152:2;30141:9;30134:21;30115:4;30178:48;30222:2;30211:9;30207:18;30199:6;30178:48;:::i;:::-;30276:6;30269:14;30262:22;30257:2;30246:9;30242:18;30235:50;30333:9;30325:6;30321:22;30316:2;30305:9;30301:18;30294:50;30361:32;30386:6;30378;30361:32;:::i;:::-;30353:40;30124:275;-1:-1:-1;;;;;;30124:275:1:o;31181:477::-;-1:-1:-1;;;;;31408:6:1;31404:31;31393:9;31386:50;31484:10;31476:6;31472:23;31467:2;31456:9;31452:18;31445:51;31532:3;31527:2;31516:9;31512:18;31505:31;31367:4;31553:45;31593:3;31582:9;31578:19;31570:6;31553:45;:::i;:::-;31545:53;;31646:4;31638:6;31634:17;31629:2;31618:9;31614:18;31607:45;31376:282;;;;;;;:::o;31663:253::-;31735:2;31729:9;31777:4;31765:17;;-1:-1:-1;;;;;31797:34:1;;31833:22;;;31794:62;31791:2;;;31859:18;;:::i;:::-;31895:2;31888:22;31709:207;:::o;31921:251::-;31993:2;31987:9;;;32023:15;;-1:-1:-1;;;;;32053:34:1;;32089:22;;;32050:62;32047:2;;;32115:18;;:::i;32177:255::-;32249:2;32243:9;32291:6;32279:19;;-1:-1:-1;;;;;32313:34:1;;32349:22;;;32310:62;32307:2;;;32375:18;;:::i;32437:275::-;32508:2;32502:9;32573:2;32554:13;;-1:-1:-1;;32550:27:1;32538:40;;-1:-1:-1;;;;;32593:34:1;;32629:22;;;32590:62;32587:2;;;32655:18;;:::i;:::-;32691:2;32684:22;32482:230;;-1:-1:-1;32482:230:1:o;32717:183::-;32777:4;-1:-1:-1;;;;;32802:6:1;32799:30;32796:2;;;32832:18;;:::i;:::-;-1:-1:-1;32877:1:1;32873:14;32889:4;32869:25;;32786:114::o;32905:128::-;32945:3;32976:1;32972:6;32969:1;32966:13;32963:2;;;32982:18;;:::i;:::-;-1:-1:-1;33018:9:1;;32953:80::o;33038:228::-;33077:3;33105:10;33142:2;33139:1;33135:10;33172:2;33169:1;33165:10;33203:3;33199:2;33195:12;33190:3;33187:21;33184:2;;;33211:18;;:::i;:::-;33247:13;;33085:181;-1:-1:-1;;;;33085:181:1:o;33271:236::-;33310:3;-1:-1:-1;;;;;33383:2:1;33380:1;33376:10;33413:2;33410:1;33406:10;33444:3;33440:2;33436:12;33431:3;33428:21;33425:2;;;33452:18;;:::i;33512:204::-;33550:3;33586:4;33583:1;33579:12;33618:4;33615:1;33611:12;33653:3;33647:4;33643:14;33638:3;33635:23;33632:2;;;33661:18;;:::i;:::-;33697:13;;33558:158;-1:-1:-1;;;33558:158:1:o;33721:217::-;33761:1;33787;33777:2;;-1:-1:-1;;;33812:31:1;;33866:4;33863:1;33856:15;33894:4;33819:1;33884:15;33777:2;-1:-1:-1;33923:9:1;;33767:171::o;33943:168::-;33983:7;34049:1;34045;34041:6;34037:14;34034:1;34031:21;34026:1;34019:9;34012:17;34008:45;34005:2;;;34056:18;;:::i;:::-;-1:-1:-1;34096:9:1;;33995:116::o;34116:125::-;34156:4;34184:1;34181;34178:8;34175:2;;;34189:18;;:::i;:::-;-1:-1:-1;34226:9:1;;34165:76::o;34246:258::-;34318:1;34328:113;34342:6;34339:1;34336:13;34328:113;;;34418:11;;;34412:18;34399:11;;;34392:39;34364:2;34357:10;34328:113;;;34459:6;34456:1;34453:13;34450:2;;;34494:1;34485:6;34480:3;34476:16;34469:27;34450:2;;34299:205;;;:::o;34509:135::-;34548:3;-1:-1:-1;;34569:17:1;;34566:2;;;34589:18;;:::i;:::-;-1:-1:-1;34636:1:1;34625:13;;34556:88::o;34649:127::-;34710:10;34705:3;34701:20;34698:1;34691:31;34741:4;34738:1;34731:15;34765:4;34762:1;34755:15;34781:127;34842:10;34837:3;34833:20;34830:1;34823:31;34873:4;34870:1;34863:15;34897:4;34894:1;34887:15

ipfs://74722d052ee17d08879a2ea3324a9c05f4ac85b401c6013af75e6589e6a9c60f