Token

Alta Finance (ALTA)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Finance

Overview

Max Total Supply

10,000,000,000 ALTA

Holders

60 (0.00%)

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xe0cca86b254005889ac3a81e737f56a14f4a38f5

Filtered by Token Holder

0x9a071b58b0f9741996640f8E583F5c7C6DbA77E3

fonz.eth

Balance

100 ALTA

Value

$0.00

0x9a071b58b0f9741996640f8E583F5c7C6DbA77E3

OVERVIEW

Alta's mission is to bring real-world assets into the crypto ecosystem, powered by the Alta Finance (ALTA) Token.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

AltaFinance

Compiler Version

v0.8.9+commit.e5eed63a

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-03-15
*/

// File: @openzeppelin/contracts/utils/math/SafeCast.sol


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol)

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// File: @openzeppelin/contracts/governance/utils/IVotes.sol


// OpenZeppelin Contracts (last updated v4.5.0) (governance/utils/IVotes.sol)
pragma solidity ^0.8.0;

/**
 * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.
 *
 * _Available since v4.5._
 */
interface IVotes {
    /**
     * @dev Emitted when an account changes their delegate.
     */
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /**
     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of votes.
     */
    event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);

    /**
     * @dev Returns the current amount of votes that `account` has.
     */
    function getVotes(address account) external view returns (uint256);

    /**
     * @dev Returns the amount of votes that `account` had at the end of a past block (`blockNumber`).
     */
    function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);

    /**
     * @dev Returns the total supply of votes available at the end of a past block (`blockNumber`).
     *
     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.
     * Votes that have not been delegated are still part of total supply, even though they would not participate in a
     * vote.
     */
    function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);

    /**
     * @dev Returns the delegate that `account` has chosen.
     */
    function delegates(address account) external view returns (address);

    /**
     * @dev Delegates votes from the sender to `delegatee`.
     */
    function delegate(address delegatee) external;

    /**
     * @dev Delegates votes from signer to `delegatee`.
     */
    function delegateBySig(
        address delegatee,
        uint256 nonce,
        uint256 expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/draft-EIP712.sol


// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;


/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, _allowances[owner][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = _allowances[owner][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Spend `amount` form the allowance of `owner` toward `spender`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;






/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Votes.sol)

pragma solidity ^0.8.0;






/**
 * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,
 * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1.
 *
 * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module.
 *
 * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either
 * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting
 * power can be queried through the public accessors {getVotes} and {getPastVotes}.
 *
 * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it
 * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.
 *
 * _Available since v4.2._
 */
abstract contract ERC20Votes is IVotes, ERC20Permit {
    struct Checkpoint {
        uint32 fromBlock;
        uint224 votes;
    }

    bytes32 private constant _DELEGATION_TYPEHASH =
        keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    mapping(address => address) private _delegates;
    mapping(address => Checkpoint[]) private _checkpoints;
    Checkpoint[] private _totalSupplyCheckpoints;

    /**
     * @dev Get the `pos`-th checkpoint for `account`.
     */
    function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {
        return _checkpoints[account][pos];
    }

    /**
     * @dev Get number of checkpoints for `account`.
     */
    function numCheckpoints(address account) public view virtual returns (uint32) {
        return SafeCast.toUint32(_checkpoints[account].length);
    }

    /**
     * @dev Get the address `account` is currently delegating to.
     */
    function delegates(address account) public view virtual override returns (address) {
        return _delegates[account];
    }

    /**
     * @dev Gets the current votes balance for `account`
     */
    function getVotes(address account) public view virtual override returns (uint256) {
        uint256 pos = _checkpoints[account].length;
        return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
    }

    /**
     * @dev Retrieve the number of votes for `account` at the end of `blockNumber`.
     *
     * Requirements:
     *
     * - `blockNumber` must have been already mined
     */
    function getPastVotes(address account, uint256 blockNumber) public view virtual override returns (uint256) {
        require(blockNumber < block.number, "ERC20Votes: block not yet mined");
        return _checkpointsLookup(_checkpoints[account], blockNumber);
    }

    /**
     * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances.
     * It is but NOT the sum of all the delegated votes!
     *
     * Requirements:
     *
     * - `blockNumber` must have been already mined
     */
    function getPastTotalSupply(uint256 blockNumber) public view virtual override returns (uint256) {
        require(blockNumber < block.number, "ERC20Votes: block not yet mined");
        return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);
    }

    /**
     * @dev Lookup a value in a list of (sorted) checkpoints.
     */
    function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) {
        // We run a binary search to look for the earliest checkpoint taken after `blockNumber`.
        //
        // During the loop, the index of the wanted checkpoint remains in the range [low-1, high).
        // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant.
        // - If the middle checkpoint is after `blockNumber`, we look in [low, mid)
        // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)
        // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not
        // out of bounds (in which case we're looking too far in the past and the result is 0).
        // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is
        // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out
        // the same.
        uint256 high = ckpts.length;
        uint256 low = 0;
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (ckpts[mid].fromBlock > blockNumber) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        return high == 0 ? 0 : ckpts[high - 1].votes;
    }

    /**
     * @dev Delegate votes from the sender to `delegatee`.
     */
    function delegate(address delegatee) public virtual override {
        _delegate(_msgSender(), delegatee);
    }

    /**
     * @dev Delegates votes from signer to `delegatee`
     */
    function delegateBySig(
        address delegatee,
        uint256 nonce,
        uint256 expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= expiry, "ERC20Votes: signature expired");
        address signer = ECDSA.recover(
            _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),
            v,
            r,
            s
        );
        require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce");
        _delegate(signer, delegatee);
    }

    /**
     * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1).
     */
    function _maxSupply() internal view virtual returns (uint224) {
        return type(uint224).max;
    }

    /**
     * @dev Snapshots the totalSupply after it has been increased.
     */
    function _mint(address account, uint256 amount) internal virtual override {
        super._mint(account, amount);
        require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes");

        _writeCheckpoint(_totalSupplyCheckpoints, _add, amount);
    }

    /**
     * @dev Snapshots the totalSupply after it has been decreased.
     */
    function _burn(address account, uint256 amount) internal virtual override {
        super._burn(account, amount);

        _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);
    }

    /**
     * @dev Move voting power when tokens are transferred.
     *
     * Emits a {DelegateVotesChanged} event.
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._afterTokenTransfer(from, to, amount);

        _moveVotingPower(delegates(from), delegates(to), amount);
    }

    /**
     * @dev Change delegation for `delegator` to `delegatee`.
     *
     * Emits events {DelegateChanged} and {DelegateVotesChanged}.
     */
    function _delegate(address delegator, address delegatee) internal virtual {
        address currentDelegate = delegates(delegator);
        uint256 delegatorBalance = balanceOf(delegator);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveVotingPower(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveVotingPower(
        address src,
        address dst,
        uint256 amount
    ) private {
        if (src != dst && amount > 0) {
            if (src != address(0)) {
                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);
                emit DelegateVotesChanged(src, oldWeight, newWeight);
            }

            if (dst != address(0)) {
                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);
                emit DelegateVotesChanged(dst, oldWeight, newWeight);
            }
        }
    }

    function _writeCheckpoint(
        Checkpoint[] storage ckpts,
        function(uint256, uint256) view returns (uint256) op,
        uint256 delta
    ) private returns (uint256 oldWeight, uint256 newWeight) {
        uint256 pos = ckpts.length;
        oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes;
        newWeight = op(oldWeight, delta);

        if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) {
            ckpts[pos - 1].votes = SafeCast.toUint224(newWeight);
        } else {
            ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)}));
        }
    }

    function _add(uint256 a, uint256 b) private pure returns (uint256) {
        return a + b;
    }

    function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
        return a - b;
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20VotesComp.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20VotesComp.sol)

pragma solidity ^0.8.0;


/**
 * @dev Extension of ERC20 to support Compound's voting and delegation. This version exactly matches Compound's
 * interface, with the drawback of only supporting supply up to (2^96^ - 1).
 *
 * NOTE: You should use this contract if you need exact compatibility with COMP (for example in order to use your token
 * with Governor Alpha or Bravo) and if you are sure the supply cap of 2^96^ is enough for you. Otherwise, use the
 * {ERC20Votes} variant of this module.
 *
 * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either
 * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting
 * power can be queried through the public accessors {getCurrentVotes} and {getPriorVotes}.
 *
 * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it
 * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.
 *
 * _Available since v4.2._
 */
abstract contract ERC20VotesComp is ERC20Votes {
    /**
     * @dev Comp version of the {getVotes} accessor, with `uint96` return type.
     */
    function getCurrentVotes(address account) external view virtual returns (uint96) {
        return SafeCast.toUint96(getVotes(account));
    }

    /**
     * @dev Comp version of the {getPastVotes} accessor, with `uint96` return type.
     */
    function getPriorVotes(address account, uint256 blockNumber) external view virtual returns (uint96) {
        return SafeCast.toUint96(getPastVotes(account, blockNumber));
    }

    /**
     * @dev Maximum token supply. Reduced to `type(uint96).max` (2^96^ - 1) to fit COMP interface.
     */
    function _maxSupply() internal view virtual override returns (uint224) {
        return type(uint96).max;
    }
}

// File: contracts/AltaFinance.sol


pragma solidity ^0.8.9;




/// @custom:security-contact [email protected]
contract AltaFinance is ERC20, ERC20Permit, ERC20VotesComp {
    address altaTreasury = address(0x087183a411770a645A96cf2e31fA69Ab89e22F5E);

    constructor() ERC20("Alta Finance", "ALTA") ERC20Permit("Alta Finance") {
        _mint(altaTreasury, 10000000000 * 10**decimals());
    }

    // The following functions are overrides required by Solidity.

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override(ERC20, ERC20Votes) {
        super._afterTokenTransfer(from, to, amount);
    }

    function _mint(address to, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._mint(to, amount);
    }

    function _burn(address account, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._burn(account, amount);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

63611:890:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38319:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40670:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39439:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41451:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39281:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51546:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42155:240;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54748:268;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54122:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57221:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53878:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39610:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63066:179;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51288:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55305:259;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38538:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54334:212;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42898:438;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39943:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62812:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57417:591;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50577:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40199:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53648:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38319:100;38373:13;38406:5;38399:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38319:100;:::o;40670:201::-;40753:4;40770:13;40786:12;:10;:12::i;:::-;40770:28;;40809:32;40818:5;40825:7;40834:6;40809:8;:32::i;:::-;40859:4;40852:11;;;40670:201;;;;:::o;39439:108::-;39500:7;39527:12;;39520:19;;39439:108;:::o;41451:295::-;41582:4;41599:15;41617:12;:10;:12::i;:::-;41599:30;;41640:38;41656:4;41662:7;41671:6;41640:15;:38::i;:::-;41689:27;41699:4;41705:2;41709:6;41689:9;:27::i;:::-;41734:4;41727:11;;;41451:295;;;;;:::o;39281:93::-;39339:5;39364:2;39357:9;;39281:93;:::o;51546:115::-;51606:7;51633:20;:18;:20::i;:::-;51626:27;;51546:115;:::o;42155:240::-;42243:4;42260:13;42276:12;:10;:12::i;:::-;42260:28;;42299:66;42308:5;42315:7;42354:10;42324:11;:18;42336:5;42324:18;;;;;;;;;;;;;;;:27;42343:7;42324:27;;;;;;;;;;;;;;;;:40;;;;:::i;:::-;42299:8;:66::i;:::-;42383:4;42376:11;;;42155:240;;;;:::o;54748:268::-;54846:7;54888:12;54874:11;:26;54866:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;54954:54;54973:12;:21;54986:7;54973:21;;;;;;;;;;;;;;;54996:11;54954:18;:54::i;:::-;54947:61;;54748:268;;;;:::o;54122:128::-;54196:7;54223:10;:19;54234:7;54223:19;;;;;;;;;;;;;;;;;;;;;;;;;54216:26;;54122:128;;;:::o;57221:114::-;57293:34;57303:12;:10;:12::i;:::-;57317:9;57293;:34::i;:::-;57221:114;:::o;53878:151::-;53948:6;53974:47;53992:12;:21;54005:7;53992:21;;;;;;;;;;;;;;;:28;;;;53974:17;:47::i;:::-;53967:54;;53878:151;;;:::o;39610:127::-;39684:7;39711:9;:18;39721:7;39711:18;;;;;;;;;;;;;;;;39704:25;;39610:127;;;:::o;63066:179::-;63158:6;63184:53;63202:34;63215:7;63224:11;63202:12;:34::i;:::-;63184:17;:53::i;:::-;63177:60;;63066:179;;;;:::o;51288:128::-;51357:7;51384:24;:7;:14;51392:5;51384:14;;;;;;;;;;;;;;;:22;:24::i;:::-;51377:31;;51288:128;;;:::o;55305:259::-;55392:7;55434:12;55420:11;:26;55412:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;55500:56;55519:23;55544:11;55500:18;:56::i;:::-;55493:63;;55305:259;;;:::o;38538:104::-;38594:13;38627:7;38620:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38538:104;:::o;54334:212::-;54407:7;54427:11;54441:12;:21;54454:7;54441:21;;;;;;;;;;;;;;;:28;;;;54427:42;;54494:1;54487:3;:8;:51;;54502:12;:21;54515:7;54502:21;;;;;;;;;;;;;;;54530:1;54524:3;:7;;;;:::i;:::-;54502:30;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;;;;;;;;;54487:51;;;54498:1;54487:51;54480:58;;;;;54334:212;;;:::o;42898:438::-;42991:4;43008:13;43024:12;:10;:12::i;:::-;43008:28;;43047:24;43074:11;:18;43086:5;43074:18;;;;;;;;;;;;;;;:27;43093:7;43074:27;;;;;;;;;;;;;;;;43047:54;;43140:15;43120:16;:35;;43112:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;43233:60;43242:5;43249:7;43277:15;43258:16;:34;43233:8;:60::i;:::-;43324:4;43317:11;;;;42898:438;;;;:::o;39943:193::-;40022:4;40039:13;40055:12;:10;:12::i;:::-;40039:28;;40078;40088:5;40095:2;40099:6;40078:9;:28::i;:::-;40124:4;40117:11;;;39943:193;;;;:::o;62812:143::-;62885:6;62911:36;62929:17;62938:7;62929:8;:17::i;:::-;62911;:36::i;:::-;62904:43;;62812:143;;;:::o;57417:591::-;57644:6;57625:15;:25;;57617:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;57695:14;57712:174;57740:87;53328:71;57800:9;57811:5;57818:6;57767:58;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57757:69;;;;;;57740:16;:87::i;:::-;57842:1;57858;57874;57712:13;:174::i;:::-;57695:191;;57914:17;57924:6;57914:9;:17::i;:::-;57905:5;:26;57897:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;57972:28;57982:6;57990:9;57972;:28::i;:::-;57606:402;57417:591;;;;;;:::o;50577:645::-;50821:8;50802:15;:27;;50794:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;50876:18;50918:16;50936:5;50943:7;50952:5;50959:16;50969:5;50959:9;:16::i;:::-;50977:8;50907:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;50897:90;;;;;;50876:111;;51000:12;51015:28;51032:10;51015:16;:28::i;:::-;51000:43;;51056:14;51073:28;51087:4;51093:1;51096;51099;51073:13;:28::i;:::-;51056:45;;51130:5;51120:15;;:6;:15;;;51112:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51183:31;51192:5;51199:7;51208:5;51183:8;:31::i;:::-;50783:439;;;50577:645;;;;;;;:::o;40199:151::-;40288:7;40315:11;:18;40327:5;40315:18;;;;;;;;;;;;;;;:27;40334:7;40315:27;;;;;;;;;;;;;;;;40308:34;;40199:151;;;;:::o;53648:150::-;53727:17;;:::i;:::-;53764:12;:21;53777:7;53764:21;;;;;;;;;;;;;;;53786:3;53764:26;;;;;;;;;;:::i;:::-;;;;;;;;;53757:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53648:150;;;;:::o;58314:290::-;58399:28;58411:7;58420:6;58399:11;:28::i;:::-;58463:12;:10;:12::i;:::-;58446:29;;:13;:11;:13::i;:::-;:29;;58438:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;58541:55;58558:23;58583:4;58589:6;58541:16;:55::i;:::-;;;58314:290;;:::o;44773:399::-;44876:1;44857:21;;:7;:21;;;;44849:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;44927:49;44956:1;44960:7;44969:6;44927:20;:49::i;:::-;45005:6;44989:12;;:22;;;;;;;:::i;:::-;;;;;;;;45044:6;45022:9;:18;45032:7;45022:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;45087:7;45066:37;;45083:1;45066:37;;;45096:6;45066:37;;;;;;:::i;:::-;;;;;;;;45116:48;45144:1;45148:7;45157:6;45116:19;:48::i;:::-;44773:399;;:::o;61158:98::-;61216:7;61247:1;61243;:5;;;;:::i;:::-;61236:12;;61158:98;;;;:::o;1195:195::-;1252:7;1289:17;1280:26;;:5;:26;;1272:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;1376:5;1361:21;;1195:195;;;:::o;3165:190::-;3221:6;3257:16;3248:25;;:5;:25;;3240:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;3341:5;3327:20;;3165:190;;;:::o;59032:262::-;59174:43;59200:4;59206:2;59210:6;59174:25;:43::i;:::-;59230:56;59247:15;59257:4;59247:9;:15::i;:::-;59264:13;59274:2;59264:9;:13::i;:::-;59279:6;59230:16;:56::i;:::-;59032:262;;;:::o;48983:124::-;;;;:::o;61264:103::-;61327:7;61358:1;61354;:5;;;;:::i;:::-;61347:12;;61264:103;;;;:::o;32345:98::-;32398:7;32425:10;32418:17;;32345:98;:::o;46534:380::-;46687:1;46670:19;;:5;:19;;;;46662:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;46768:1;46749:21;;:7;:21;;;;46741:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;46852:6;46822:11;:18;46834:5;46822:18;;;;;;;;;;;;;;;:27;46841:7;46822:27;;;;;;;;;;;;;;;:36;;;;46890:7;46874:32;;46883:5;46874:32;;;46899:6;46874:32;;;;;;:::i;:::-;;;;;;;;46534:380;;;:::o;47201:453::-;47336:24;47363:25;47373:5;47380:7;47363:9;:25::i;:::-;47336:52;;47423:17;47403:16;:37;47399:248;;47485:6;47465:16;:26;;47457:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;47569:51;47578:5;47585:7;47613:6;47594:16;:25;47569:8;:51::i;:::-;47399:248;47325:329;47201:453;;;:::o;43815:671::-;43962:1;43946:18;;:4;:18;;;;43938:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;44039:1;44025:16;;:2;:16;;;;44017:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;44094:38;44115:4;44121:2;44125:6;44094:20;:38::i;:::-;44145:19;44167:9;:15;44177:4;44167:15;;;;;;;;;;;;;;;;44145:37;;44216:6;44201:11;:21;;44193:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;44333:6;44319:11;:20;44301:9;:15;44311:4;44301:15;;;;;;;;;;;;;;;:38;;;;44378:6;44361:9;:13;44371:2;44361:13;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;44417:2;44402:26;;44411:4;44402:26;;;44421:6;44402:26;;;;;;:::i;:::-;;;;;;;;44441:37;44461:4;44467:2;44471:6;44441:19;:37::i;:::-;43927:559;43815:671;;;:::o;27900:314::-;27953:7;27994:12;27977:29;;27985:4;27977:29;;;:66;;;;;28027:16;28010:13;:33;27977:66;27973:234;;;28067:24;28060:31;;;;27973:234;28131:64;28153:10;28165:12;28179:15;28131:21;:64::i;:::-;28124:71;;27900:314;;:::o;55653:1482::-;55752:7;56771:12;56786:5;:12;;;;56771:27;;56809:11;56835:236;56848:4;56842:3;:10;56835:236;;;56869:11;56883:23;56896:3;56901:4;56883:12;:23::i;:::-;56869:37;;56948:11;56925:5;56931:3;56925:10;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;:34;;;56921:139;;;56987:3;56980:10;;56921:139;;;57043:1;57037:3;:7;;;;:::i;:::-;57031:13;;56921:139;56854:217;56835:236;;;57098:1;57090:4;:9;:37;;57106:5;57119:1;57112:4;:8;;;;:::i;:::-;57106:15;;;;;;;;:::i;:::-;;;;;;;;;:21;;;;;;;;;;;;57090:37;;;57102:1;57090:37;57083:44;;;;;;55653:1482;;;;:::o;59458:388::-;59543:23;59569:20;59579:9;59569;:20::i;:::-;59543:46;;59600:24;59627:20;59637:9;59627;:20::i;:::-;59600:47;;59682:9;59658:10;:21;59669:9;59658:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;59753:9;59709:54;;59736:15;59709:54;;59725:9;59709:54;;;;;;;;;;;;59776:62;59793:15;59810:9;59821:16;59776;:62::i;:::-;59532:314;;59458:388;;:::o;2187:190::-;2243:6;2279:16;2270:25;;:5;:25;;2262:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;2363:5;2349:20;;2187:190;;;:::o;12419:114::-;12484:7;12511;:14;;;12504:21;;12419:114;;;:::o;29127:167::-;29204:7;29231:55;29253:20;:18;:20::i;:::-;29275:10;29231:21;:55::i;:::-;29224:62;;29127:167;;;:::o;22776:279::-;22904:7;22925:17;22944:18;22966:25;22977:4;22983:1;22986;22989;22966:10;:25::i;:::-;22924:67;;;;23002:18;23014:5;23002:11;:18::i;:::-;23038:9;23031:16;;;;22776:279;;;;;;:::o;51799:207::-;51859:15;51887:30;51920:7;:14;51928:5;51920:14;;;;;;;;;;;;;;;51887:47;;51955:15;:5;:13;:15::i;:::-;51945:25;;51981:17;:5;:15;:17::i;:::-;51876:130;51799:207;;;:::o;63371:113::-;63433:7;63460:16;63453:23;;;;63371:113;:::o;60505:645::-;60679:17;60698;60728:11;60742:5;:12;;;;60728:26;;60784:1;60777:3;:8;:35;;60792:5;60804:1;60798:3;:7;;;;:::i;:::-;60792:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;;;;;;;;;;60777:35;;;60788:1;60777:35;60765:47;;;;60835:20;60838:9;60849:5;60835:2;:20;;:::i;:::-;60823:32;;60878:1;60872:3;:7;:51;;;;;60911:12;60883:5;60895:1;60889:3;:7;;;;:::i;:::-;60883:14;;;;;;;;:::i;:::-;;;;;;;;;:24;;;;;;;;;;;;:40;;;60872:51;60868:275;;;60963:29;60982:9;60963:18;:29::i;:::-;60940:5;60952:1;60946:3;:7;;;;:::i;:::-;60940:14;;;;;;;;:::i;:::-;;;;;;;;;:20;;;:52;;;;;;;;;;;;;;;;;;60868:275;;;61025:5;61036:94;;;;;;;;61059:31;61077:12;61059:17;:31::i;:::-;61036:94;;;;;;61099:29;61118:9;61099:18;:29::i;:::-;61036:94;;;;;61025:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60868:275;60717:433;60505:645;;;;;;:::o;48254:125::-;;;;:::o;63978:204::-;64131:43;64157:4;64163:2;64167:6;64131:25;:43::i;:::-;63978:204;;;:::o;59854:643::-;59986:3;59979:10;;:3;:10;;;;:24;;;;;60002:1;59993:6;:10;59979:24;59975:515;;;60039:1;60024:17;;:3;:17;;;60020:224;;60063:17;60082;60103:54;60120:12;:17;60133:3;60120:17;;;;;;;;;;;;;;;60139:9;60150:6;60103:16;:54::i;:::-;60062:95;;;;60202:3;60181:47;;;60207:9;60218;60181:47;;;;;;;:::i;:::-;;;;;;;;60043:201;;60020:224;60279:1;60264:17;;:3;:17;;;60260:219;;60303:17;60322;60343:49;60360:12;:17;60373:3;60360:17;;;;;;;;;;;;;;;60379:4;60385:6;60343:16;:49::i;:::-;60302:90;;;;60437:3;60416:47;;;60442:9;60453;60416:47;;;;;;;:::i;:::-;;;;;;;;60283:196;;60260:219;59975:515;59854:643;;;:::o;28222:263::-;28366:7;28414:8;28424;28434:11;28447:13;28470:4;28403:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;28393:84;;;;;;28386:91;;28222:263;;;;;:::o;10980:156::-;11042:7;11127:1;11122;11118;:5;11117:11;;;;:::i;:::-;11112:1;11108;:5;11107:21;;;;:::i;:::-;11100:28;;10980:156;;;;:::o;24467:196::-;24560:7;24626:15;24643:10;24597:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;24587:68;;;;;;24580:75;;24467:196;;;;:::o;21005:1632::-;21136:7;21145:12;22070:66;22065:1;22057:10;;:79;22053:163;;;22169:1;22173:30;22153:51;;;;;;22053:163;22235:2;22230:1;:7;;;;:18;;;;;22246:2;22241:1;:7;;;;22230:18;22226:102;;;22281:1;22285:30;22265:51;;;;;;22226:102;22425:14;22442:24;22452:4;22458:1;22461;22464;22442:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22425:41;;22499:1;22481:20;;:6;:20;;;22477:103;;;22534:1;22538:29;22518:50;;;;;;;22477:103;22600:6;22608:20;22592:37;;;;;21005:1632;;;;;;;;:::o;15714:643::-;15792:20;15783:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;15779:571;;;15829:7;;15779:571;15890:29;15881:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;15877:473;;;15936:34;;;;;;;;;;:::i;:::-;;;;;;;;15877:473;16001:35;15992:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;15988:362;;;16053:41;;;;;;;;;;:::i;:::-;;;;;;;;15988:362;16125:30;16116:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;16112:238;;;16172:44;;;;;;;;;;:::i;:::-;;;;;;;;16112:238;16247:30;16238:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;16234:116;;;16294:44;;;;;;;;;;:::i;:::-;;;;;;;;16234:116;15714:643;;:::o;12541:127::-;12648:1;12630:7;:14;;;:19;;;;;;;;;;;12541:127;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:307::-;355:1;365:113;379:6;376:1;373:13;365:113;;;464:1;459:3;455:11;449:18;445:1;440:3;436:11;429:39;401:2;398:1;394:10;389:15;;365:113;;;496:6;493:1;490:13;487:101;;;576:1;567:6;562:3;558:16;551:27;487:101;336:258;287:307;;;:::o;600:102::-;641:6;692:2;688:7;683:2;676:5;672:14;668:28;658:38;;600:102;;;:::o;708:364::-;796:3;824:39;857:5;824:39;:::i;:::-;879:71;943:6;938:3;879:71;:::i;:::-;872:78;;959:52;1004:6;999:3;992:4;985:5;981:16;959:52;:::i;:::-;1036:29;1058:6;1036:29;:::i;:::-;1031:3;1027:39;1020:46;;800:272;708:364;;;;:::o;1078:313::-;1191:4;1229:2;1218:9;1214:18;1206:26;;1278:9;1272:4;1268:20;1264:1;1253:9;1249:17;1242:47;1306:78;1379:4;1370:6;1306:78;:::i;:::-;1298:86;;1078:313;;;;:::o;1478:117::-;1587:1;1584;1577:12;1724:126;1761:7;1801:42;1794:5;1790:54;1779:65;;1724:126;;;:::o;1856:96::-;1893:7;1922:24;1940:5;1922:24;:::i;:::-;1911:35;;1856:96;;;:::o;1958:122::-;2031:24;2049:5;2031:24;:::i;:::-;2024:5;2021:35;2011:63;;2070:1;2067;2060:12;2011:63;1958:122;:::o;2086:139::-;2132:5;2170:6;2157:20;2148:29;;2186:33;2213:5;2186:33;:::i;:::-;2086:139;;;;:::o;2231:77::-;2268:7;2297:5;2286:16;;2231:77;;;:::o;2314:122::-;2387:24;2405:5;2387:24;:::i;:::-;2380:5;2377:35;2367:63;;2426:1;2423;2416:12;2367:63;2314:122;:::o;2442:139::-;2488:5;2526:6;2513:20;2504:29;;2542:33;2569:5;2542:33;:::i;:::-;2442:139;;;;:::o;2587:474::-;2655:6;2663;2712:2;2700:9;2691:7;2687:23;2683:32;2680:119;;;2718:79;;:::i;:::-;2680:119;2838:1;2863:53;2908:7;2899:6;2888:9;2884:22;2863:53;:::i;:::-;2853:63;;2809:117;2965:2;2991:53;3036:7;3027:6;3016:9;3012:22;2991:53;:::i;:::-;2981:63;;2936:118;2587:474;;;;;:::o;3067:90::-;3101:7;3144:5;3137:13;3130:21;3119:32;;3067:90;;;:::o;3163:109::-;3244:21;3259:5;3244:21;:::i;:::-;3239:3;3232:34;3163:109;;:::o;3278:210::-;3365:4;3403:2;3392:9;3388:18;3380:26;;3416:65;3478:1;3467:9;3463:17;3454:6;3416:65;:::i;:::-;3278:210;;;;:::o;3494:118::-;3581:24;3599:5;3581:24;:::i;:::-;3576:3;3569:37;3494:118;;:::o;3618:222::-;3711:4;3749:2;3738:9;3734:18;3726:26;;3762:71;3830:1;3819:9;3815:17;3806:6;3762:71;:::i;:::-;3618:222;;;;:::o;3846:619::-;3923:6;3931;3939;3988:2;3976:9;3967:7;3963:23;3959:32;3956:119;;;3994:79;;:::i;:::-;3956:119;4114:1;4139:53;4184:7;4175:6;4164:9;4160:22;4139:53;:::i;:::-;4129:63;;4085:117;4241:2;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4212:118;4369:2;4395:53;4440:7;4431:6;4420:9;4416:22;4395:53;:::i;:::-;4385:63;;4340:118;3846:619;;;;;:::o;4471:86::-;4506:7;4546:4;4539:5;4535:16;4524:27;;4471:86;;;:::o;4563:112::-;4646:22;4662:5;4646:22;:::i;:::-;4641:3;4634:35;4563:112;;:::o;4681:214::-;4770:4;4808:2;4797:9;4793:18;4785:26;;4821:67;4885:1;4874:9;4870:17;4861:6;4821:67;:::i;:::-;4681:214;;;;:::o;4901:77::-;4938:7;4967:5;4956:16;;4901:77;;;:::o;4984:118::-;5071:24;5089:5;5071:24;:::i;:::-;5066:3;5059:37;4984:118;;:::o;5108:222::-;5201:4;5239:2;5228:9;5224:18;5216:26;;5252:71;5320:1;5309:9;5305:17;5296:6;5252:71;:::i;:::-;5108:222;;;;:::o;5336:329::-;5395:6;5444:2;5432:9;5423:7;5419:23;5415:32;5412:119;;;5450:79;;:::i;:::-;5412:119;5570:1;5595:53;5640:7;5631:6;5620:9;5616:22;5595:53;:::i;:::-;5585:63;;5541:117;5336:329;;;;:::o;5671:118::-;5758:24;5776:5;5758:24;:::i;:::-;5753:3;5746:37;5671:118;;:::o;5795:222::-;5888:4;5926:2;5915:9;5911:18;5903:26;;5939:71;6007:1;5996:9;5992:17;5983:6;5939:71;:::i;:::-;5795:222;;;;:::o;6023:93::-;6059:7;6099:10;6092:5;6088:22;6077:33;;6023:93;;;:::o;6122:115::-;6207:23;6224:5;6207:23;:::i;:::-;6202:3;6195:36;6122:115;;:::o;6243:218::-;6334:4;6372:2;6361:9;6357:18;6349:26;;6385:69;6451:1;6440:9;6436:17;6427:6;6385:69;:::i;:::-;6243:218;;;;:::o;6467:109::-;6503:7;6543:26;6536:5;6532:38;6521:49;;6467:109;;;:::o;6582:115::-;6667:23;6684:5;6667:23;:::i;:::-;6662:3;6655:36;6582:115;;:::o;6703:218::-;6794:4;6832:2;6821:9;6817:18;6809:26;;6845:69;6911:1;6900:9;6896:17;6887:6;6845:69;:::i;:::-;6703:218;;;;:::o;6927:329::-;6986:6;7035:2;7023:9;7014:7;7010:23;7006:32;7003:119;;;7041:79;;:::i;:::-;7003:119;7161:1;7186:53;7231:7;7222:6;7211:9;7207:22;7186:53;:::i;:::-;7176:63;;7132:117;6927:329;;;;:::o;7262:118::-;7333:22;7349:5;7333:22;:::i;:::-;7326:5;7323:33;7313:61;;7370:1;7367;7360:12;7313:61;7262:118;:::o;7386:135::-;7430:5;7468:6;7455:20;7446:29;;7484:31;7509:5;7484:31;:::i;:::-;7386:135;;;;:::o;7527:122::-;7600:24;7618:5;7600:24;:::i;:::-;7593:5;7590:35;7580:63;;7639:1;7636;7629:12;7580:63;7527:122;:::o;7655:139::-;7701:5;7739:6;7726:20;7717:29;;7755:33;7782:5;7755:33;:::i;:::-;7655:139;;;;:::o;7800:1053::-;7902:6;7910;7918;7926;7934;7942;7991:3;7979:9;7970:7;7966:23;7962:33;7959:120;;;7998:79;;:::i;:::-;7959:120;8118:1;8143:53;8188:7;8179:6;8168:9;8164:22;8143:53;:::i;:::-;8133:63;;8089:117;8245:2;8271:53;8316:7;8307:6;8296:9;8292:22;8271:53;:::i;:::-;8261:63;;8216:118;8373:2;8399:53;8444:7;8435:6;8424:9;8420:22;8399:53;:::i;:::-;8389:63;;8344:118;8501:2;8527:51;8570:7;8561:6;8550:9;8546:22;8527:51;:::i;:::-;8517:61;;8472:116;8627:3;8654:53;8699:7;8690:6;8679:9;8675:22;8654:53;:::i;:::-;8644:63;;8598:119;8756:3;8783:53;8828:7;8819:6;8808:9;8804:22;8783:53;:::i;:::-;8773:63;;8727:119;7800:1053;;;;;;;;:::o;8859:1199::-;8970:6;8978;8986;8994;9002;9010;9018;9067:3;9055:9;9046:7;9042:23;9038:33;9035:120;;;9074:79;;:::i;:::-;9035:120;9194:1;9219:53;9264:7;9255:6;9244:9;9240:22;9219:53;:::i;:::-;9209:63;;9165:117;9321:2;9347:53;9392:7;9383:6;9372:9;9368:22;9347:53;:::i;:::-;9337:63;;9292:118;9449:2;9475:53;9520:7;9511:6;9500:9;9496:22;9475:53;:::i;:::-;9465:63;;9420:118;9577:2;9603:53;9648:7;9639:6;9628:9;9624:22;9603:53;:::i;:::-;9593:63;;9548:118;9705:3;9732:51;9775:7;9766:6;9755:9;9751:22;9732:51;:::i;:::-;9722:61;;9676:117;9832:3;9859:53;9904:7;9895:6;9884:9;9880:22;9859:53;:::i;:::-;9849:63;;9803:119;9961:3;9988:53;10033:7;10024:6;10013:9;10009:22;9988:53;:::i;:::-;9978:63;;9932:119;8859:1199;;;;;;;;;;:::o;10064:474::-;10132:6;10140;10189:2;10177:9;10168:7;10164:23;10160:32;10157:119;;;10195:79;;:::i;:::-;10157:119;10315:1;10340:53;10385:7;10376:6;10365:9;10361:22;10340:53;:::i;:::-;10330:63;;10286:117;10442:2;10468:53;10513:7;10504:6;10493:9;10489:22;10468:53;:::i;:::-;10458:63;;10413:118;10064:474;;;;;:::o;10544:120::-;10616:23;10633:5;10616:23;:::i;:::-;10609:5;10606:34;10596:62;;10654:1;10651;10644:12;10596:62;10544:120;:::o;10670:137::-;10715:5;10753:6;10740:20;10731:29;;10769:32;10795:5;10769:32;:::i;:::-;10670:137;;;;:::o;10813:472::-;10880:6;10888;10937:2;10925:9;10916:7;10912:23;10908:32;10905:119;;;10943:79;;:::i;:::-;10905:119;11063:1;11088:53;11133:7;11124:6;11113:9;11109:22;11088:53;:::i;:::-;11078:63;;11034:117;11190:2;11216:52;11260:7;11251:6;11240:9;11236:22;11216:52;:::i;:::-;11206:62;;11161:117;10813:472;;;;;:::o;11291:105::-;11366:23;11383:5;11366:23;:::i;:::-;11361:3;11354:36;11291:105;;:::o;11402:142::-;11439:7;11479:58;11472:5;11468:70;11457:81;;11402:142;;;:::o;11550:108::-;11627:24;11645:5;11627:24;:::i;:::-;11622:3;11615:37;11550:108;;:::o;11732:517::-;11885:4;11880:3;11876:14;11977:4;11970:5;11966:16;11960:23;11996:61;12051:4;12046:3;12042:14;12028:12;11996:61;:::i;:::-;11900:167;12150:4;12143:5;12139:16;12133:23;12169:63;12226:4;12221:3;12217:14;12203:12;12169:63;:::i;:::-;12077:165;11854:395;11732:517;;:::o;12255:334::-;12404:4;12442:2;12431:9;12427:18;12419:26;;12455:127;12579:1;12568:9;12564:17;12555:6;12455:127;:::i;:::-;12255:334;;;;:::o;12595:180::-;12643:77;12640:1;12633:88;12740:4;12737:1;12730:15;12764:4;12761:1;12754:15;12781:320;12825:6;12862:1;12856:4;12852:12;12842:22;;12909:1;12903:4;12899:12;12930:18;12920:81;;12986:4;12978:6;12974:17;12964:27;;12920:81;13048:2;13040:6;13037:14;13017:18;13014:38;13011:84;;;13067:18;;:::i;:::-;13011:84;12832:269;12781:320;;;:::o;13107:180::-;13155:77;13152:1;13145:88;13252:4;13249:1;13242:15;13276:4;13273:1;13266:15;13293:305;13333:3;13352:20;13370:1;13352:20;:::i;:::-;13347:25;;13386:20;13404:1;13386:20;:::i;:::-;13381:25;;13540:1;13472:66;13468:74;13465:1;13462:81;13459:107;;;13546:18;;:::i;:::-;13459:107;13590:1;13587;13583:9;13576:16;;13293:305;;;;:::o;13604:181::-;13744:33;13740:1;13732:6;13728:14;13721:57;13604:181;:::o;13791:366::-;13933:3;13954:67;14018:2;14013:3;13954:67;:::i;:::-;13947:74;;14030:93;14119:3;14030:93;:::i;:::-;14148:2;14143:3;14139:12;14132:19;;13791:366;;;:::o;14163:419::-;14329:4;14367:2;14356:9;14352:18;14344:26;;14416:9;14410:4;14406:20;14402:1;14391:9;14387:17;14380:47;14444:131;14570:4;14444:131;:::i;:::-;14436:139;;14163:419;;;:::o;14588:191::-;14628:4;14648:20;14666:1;14648:20;:::i;:::-;14643:25;;14682:20;14700:1;14682:20;:::i;:::-;14677:25;;14721:1;14718;14715:8;14712:34;;;14726:18;;:::i;:::-;14712:34;14771:1;14768;14764:9;14756:17;;14588:191;;;;:::o;14785:180::-;14833:77;14830:1;14823:88;14930:4;14927:1;14920:15;14954:4;14951:1;14944:15;14971:224;15111:34;15107:1;15099:6;15095:14;15088:58;15180:7;15175:2;15167:6;15163:15;15156:32;14971:224;:::o;15201:366::-;15343:3;15364:67;15428:2;15423:3;15364:67;:::i;:::-;15357:74;;15440:93;15529:3;15440:93;:::i;:::-;15558:2;15553:3;15549:12;15542:19;;15201:366;;;:::o;15573:419::-;15739:4;15777:2;15766:9;15762:18;15754:26;;15826:9;15820:4;15816:20;15812:1;15801:9;15797:17;15790:47;15854:131;15980:4;15854:131;:::i;:::-;15846:139;;15573:419;;;:::o;15998:179::-;16138:31;16134:1;16126:6;16122:14;16115:55;15998:179;:::o;16183:366::-;16325:3;16346:67;16410:2;16405:3;16346:67;:::i;:::-;16339:74;;16422:93;16511:3;16422:93;:::i;:::-;16540:2;16535:3;16531:12;16524:19;;16183:366;;;:::o;16555:419::-;16721:4;16759:2;16748:9;16744:18;16736:26;;16808:9;16802:4;16798:20;16794:1;16783:9;16779:17;16772:47;16836:131;16962:4;16836:131;:::i;:::-;16828:139;;16555:419;;;:::o;16980:553::-;17157:4;17195:3;17184:9;17180:19;17172:27;;17209:71;17277:1;17266:9;17262:17;17253:6;17209:71;:::i;:::-;17290:72;17358:2;17347:9;17343:18;17334:6;17290:72;:::i;:::-;17372;17440:2;17429:9;17425:18;17416:6;17372:72;:::i;:::-;17454;17522:2;17511:9;17507:18;17498:6;17454:72;:::i;:::-;16980:553;;;;;;;:::o;17539:175::-;17679:27;17675:1;17667:6;17663:14;17656:51;17539:175;:::o;17720:366::-;17862:3;17883:67;17947:2;17942:3;17883:67;:::i;:::-;17876:74;;17959:93;18048:3;17959:93;:::i;:::-;18077:2;18072:3;18068:12;18061:19;;17720:366;;;:::o;18092:419::-;18258:4;18296:2;18285:9;18281:18;18273:26;;18345:9;18339:4;18335:20;18331:1;18320:9;18316:17;18309:47;18373:131;18499:4;18373:131;:::i;:::-;18365:139;;18092:419;;;:::o;18517:179::-;18657:31;18653:1;18645:6;18641:14;18634:55;18517:179;:::o;18702:366::-;18844:3;18865:67;18929:2;18924:3;18865:67;:::i;:::-;18858:74;;18941:93;19030:3;18941:93;:::i;:::-;19059:2;19054:3;19050:12;19043:19;;18702:366;;;:::o;19074:419::-;19240:4;19278:2;19267:9;19263:18;19255:26;;19327:9;19321:4;19317:20;19313:1;19302:9;19298:17;19291:47;19355:131;19481:4;19355:131;:::i;:::-;19347:139;;19074:419;;;:::o;19499:775::-;19732:4;19770:3;19759:9;19755:19;19747:27;;19784:71;19852:1;19841:9;19837:17;19828:6;19784:71;:::i;:::-;19865:72;19933:2;19922:9;19918:18;19909:6;19865:72;:::i;:::-;19947;20015:2;20004:9;20000:18;19991:6;19947:72;:::i;:::-;20029;20097:2;20086:9;20082:18;20073:6;20029:72;:::i;:::-;20111:73;20179:3;20168:9;20164:19;20155:6;20111:73;:::i;:::-;20194;20262:3;20251:9;20247:19;20238:6;20194:73;:::i;:::-;19499:775;;;;;;;;;:::o;20280:180::-;20420:32;20416:1;20408:6;20404:14;20397:56;20280:180;:::o;20466:366::-;20608:3;20629:67;20693:2;20688:3;20629:67;:::i;:::-;20622:74;;20705:93;20794:3;20705:93;:::i;:::-;20823:2;20818:3;20814:12;20807:19;;20466:366;;;:::o;20838:419::-;21004:4;21042:2;21031:9;21027:18;21019:26;;21091:9;21085:4;21081:20;21077:1;21066:9;21062:17;21055:47;21119:131;21245:4;21119:131;:::i;:::-;21111:139;;20838:419;;;:::o;21263:235::-;21403:34;21399:1;21391:6;21387:14;21380:58;21472:18;21467:2;21459:6;21455:15;21448:43;21263:235;:::o;21504:366::-;21646:3;21667:67;21731:2;21726:3;21667:67;:::i;:::-;21660:74;;21743:93;21832:3;21743:93;:::i;:::-;21861:2;21856:3;21852:12;21845:19;;21504:366;;;:::o;21876:419::-;22042:4;22080:2;22069:9;22065:18;22057:26;;22129:9;22123:4;22119:20;22115:1;22104:9;22100:17;22093:47;22157:131;22283:4;22157:131;:::i;:::-;22149:139;;21876:419;;;:::o;22301:181::-;22441:33;22437:1;22429:6;22425:14;22418:57;22301:181;:::o;22488:366::-;22630:3;22651:67;22715:2;22710:3;22651:67;:::i;:::-;22644:74;;22727:93;22816:3;22727:93;:::i;:::-;22845:2;22840:3;22836:12;22829:19;;22488:366;;;:::o;22860:419::-;23026:4;23064:2;23053:9;23049:18;23041:26;;23113:9;23107:4;23103:20;23099:1;23088:9;23084:17;23077:47;23141:131;23267:4;23141:131;:::i;:::-;23133:139;;22860:419;;;:::o;23285:226::-;23425:34;23421:1;23413:6;23409:14;23402:58;23494:9;23489:2;23481:6;23477:15;23470:34;23285:226;:::o;23517:366::-;23659:3;23680:67;23744:2;23739:3;23680:67;:::i;:::-;23673:74;;23756:93;23845:3;23756:93;:::i;:::-;23874:2;23869:3;23865:12;23858:19;;23517:366;;;:::o;23889:419::-;24055:4;24093:2;24082:9;24078:18;24070:26;;24142:9;24136:4;24132:20;24128:1;24117:9;24113:17;24106:47;24170:131;24296:4;24170:131;:::i;:::-;24162:139;;23889:419;;;:::o;24314:225::-;24454:34;24450:1;24442:6;24438:14;24431:58;24523:8;24518:2;24510:6;24506:15;24499:33;24314:225;:::o;24545:366::-;24687:3;24708:67;24772:2;24767:3;24708:67;:::i;:::-;24701:74;;24784:93;24873:3;24784:93;:::i;:::-;24902:2;24897:3;24893:12;24886:19;;24545:366;;;:::o;24917:419::-;25083:4;25121:2;25110:9;25106:18;25098:26;;25170:9;25164:4;25160:20;25156:1;25145:9;25141:17;25134:47;25198:131;25324:4;25198:131;:::i;:::-;25190:139;;24917:419;;;:::o;25342:223::-;25482:34;25478:1;25470:6;25466:14;25459:58;25551:6;25546:2;25538:6;25534:15;25527:31;25342:223;:::o;25571:366::-;25713:3;25734:67;25798:2;25793:3;25734:67;:::i;:::-;25727:74;;25810:93;25899:3;25810:93;:::i;:::-;25928:2;25923:3;25919:12;25912:19;;25571:366;;;:::o;25943:419::-;26109:4;26147:2;26136:9;26132:18;26124:26;;26196:9;26190:4;26186:20;26182:1;26171:9;26167:17;26160:47;26224:131;26350:4;26224:131;:::i;:::-;26216:139;;25943:419;;;:::o;26368:221::-;26508:34;26504:1;26496:6;26492:14;26485:58;26577:4;26572:2;26564:6;26560:15;26553:29;26368:221;:::o;26595:366::-;26737:3;26758:67;26822:2;26817:3;26758:67;:::i;:::-;26751:74;;26834:93;26923:3;26834:93;:::i;:::-;26952:2;26947:3;26943:12;26936:19;;26595:366;;;:::o;26967:419::-;27133:4;27171:2;27160:9;27156:18;27148:26;;27220:9;27214:4;27210:20;27206:1;27195:9;27191:17;27184:47;27248:131;27374:4;27248:131;:::i;:::-;27240:139;;26967:419;;;:::o;27392:179::-;27532:31;27528:1;27520:6;27516:14;27509:55;27392:179;:::o;27577:366::-;27719:3;27740:67;27804:2;27799:3;27740:67;:::i;:::-;27733:74;;27816:93;27905:3;27816:93;:::i;:::-;27934:2;27929:3;27925:12;27918:19;;27577:366;;;:::o;27949:419::-;28115:4;28153:2;28142:9;28138:18;28130:26;;28202:9;28196:4;28192:20;28188:1;28177:9;28173:17;28166:47;28230:131;28356:4;28230:131;:::i;:::-;28222:139;;27949:419;;;:::o;28374:224::-;28514:34;28510:1;28502:6;28498:14;28491:58;28583:7;28578:2;28570:6;28566:15;28559:32;28374:224;:::o;28604:366::-;28746:3;28767:67;28831:2;28826:3;28767:67;:::i;:::-;28760:74;;28843:93;28932:3;28843:93;:::i;:::-;28961:2;28956:3;28952:12;28945:19;;28604:366;;;:::o;28976:419::-;29142:4;29180:2;29169:9;29165:18;29157:26;;29229:9;29223:4;29219:20;29215:1;29204:9;29200:17;29193:47;29257:131;29383:4;29257:131;:::i;:::-;29249:139;;28976:419;;;:::o;29401:222::-;29541:34;29537:1;29529:6;29525:14;29518:58;29610:5;29605:2;29597:6;29593:15;29586:30;29401:222;:::o;29629:366::-;29771:3;29792:67;29856:2;29851:3;29792:67;:::i;:::-;29785:74;;29868:93;29957:3;29868:93;:::i;:::-;29986:2;29981:3;29977:12;29970:19;;29629:366;;;:::o;30001:419::-;30167:4;30205:2;30194:9;30190:18;30182:26;;30254:9;30248:4;30244:20;30240:1;30229:9;30225:17;30218:47;30282:131;30408:4;30282:131;:::i;:::-;30274:139;;30001:419;;;:::o;30426:225::-;30566:34;30562:1;30554:6;30550:14;30543:58;30635:8;30630:2;30622:6;30618:15;30611:33;30426:225;:::o;30657:366::-;30799:3;30820:67;30884:2;30879:3;30820:67;:::i;:::-;30813:74;;30896:93;30985:3;30896:93;:::i;:::-;31014:2;31009:3;31005:12;30998:19;;30657:366;;;:::o;31029:419::-;31195:4;31233:2;31222:9;31218:18;31210:26;;31282:9;31276:4;31272:20;31268:1;31257:9;31253:17;31246:47;31310:131;31436:4;31310:131;:::i;:::-;31302:139;;31029:419;;;:::o;31454:225::-;31594:34;31590:1;31582:6;31578:14;31571:58;31663:8;31658:2;31650:6;31646:15;31639:33;31454:225;:::o;31685:366::-;31827:3;31848:67;31912:2;31907:3;31848:67;:::i;:::-;31841:74;;31924:93;32013:3;31924:93;:::i;:::-;32042:2;32037:3;32033:12;32026:19;;31685:366;;;:::o;32057:419::-;32223:4;32261:2;32250:9;32246:18;32238:26;;32310:9;32304:4;32300:20;32296:1;32285:9;32281:17;32274:47;32338:131;32464:4;32338:131;:::i;:::-;32330:139;;32057:419;;;:::o;32482:332::-;32603:4;32641:2;32630:9;32626:18;32618:26;;32654:71;32722:1;32711:9;32707:17;32698:6;32654:71;:::i;:::-;32735:72;32803:2;32792:9;32788:18;32779:6;32735:72;:::i;:::-;32482:332;;;;;:::o;32820:664::-;33025:4;33063:3;33052:9;33048:19;33040:27;;33077:71;33145:1;33134:9;33130:17;33121:6;33077:71;:::i;:::-;33158:72;33226:2;33215:9;33211:18;33202:6;33158:72;:::i;:::-;33240;33308:2;33297:9;33293:18;33284:6;33240:72;:::i;:::-;33322;33390:2;33379:9;33375:18;33366:6;33322:72;:::i;:::-;33404:73;33472:3;33461:9;33457:19;33448:6;33404:73;:::i;:::-;32820:664;;;;;;;;:::o;33490:180::-;33538:77;33535:1;33528:88;33635:4;33632:1;33625:15;33659:4;33656:1;33649:15;33676:185;33716:1;33733:20;33751:1;33733:20;:::i;:::-;33728:25;;33767:20;33785:1;33767:20;:::i;:::-;33762:25;;33806:1;33796:35;;33811:18;;:::i;:::-;33796:35;33853:1;33850;33846:9;33841:14;;33676:185;;;;:::o;33867:148::-;33969:11;34006:3;33991:18;;33867:148;;;;:::o;34021:214::-;34161:66;34157:1;34149:6;34145:14;34138:90;34021:214;:::o;34241:400::-;34401:3;34422:84;34504:1;34499:3;34422:84;:::i;:::-;34415:91;;34515:93;34604:3;34515:93;:::i;:::-;34633:1;34628:3;34624:11;34617:18;;34241:400;;;:::o;34647:79::-;34686:7;34715:5;34704:16;;34647:79;;;:::o;34732:157::-;34837:45;34857:24;34875:5;34857:24;:::i;:::-;34837:45;:::i;:::-;34832:3;34825:58;34732:157;;:::o;34895:663::-;35136:3;35158:148;35302:3;35158:148;:::i;:::-;35151:155;;35316:75;35387:3;35378:6;35316:75;:::i;:::-;35416:2;35411:3;35407:12;35400:19;;35429:75;35500:3;35491:6;35429:75;:::i;:::-;35529:2;35524:3;35520:12;35513:19;;35549:3;35542:10;;34895:663;;;;;:::o;35564:545::-;35737:4;35775:3;35764:9;35760:19;35752:27;;35789:71;35857:1;35846:9;35842:17;35833:6;35789:71;:::i;:::-;35870:68;35934:2;35923:9;35919:18;35910:6;35870:68;:::i;:::-;35948:72;36016:2;36005:9;36001:18;35992:6;35948:72;:::i;:::-;36030;36098:2;36087:9;36083:18;36074:6;36030:72;:::i;:::-;35564:545;;;;;;;:::o;36115:180::-;36163:77;36160:1;36153:88;36260:4;36257:1;36250:15;36284:4;36281:1;36274:15;36301:174;36441:26;36437:1;36429:6;36425:14;36418:50;36301:174;:::o;36481:366::-;36623:3;36644:67;36708:2;36703:3;36644:67;:::i;:::-;36637:74;;36720:93;36809:3;36720:93;:::i;:::-;36838:2;36833:3;36829:12;36822:19;;36481:366;;;:::o;36853:419::-;37019:4;37057:2;37046:9;37042:18;37034:26;;37106:9;37100:4;37096:20;37092:1;37081:9;37077:17;37070:47;37134:131;37260:4;37134:131;:::i;:::-;37126:139;;36853:419;;;:::o;37278:181::-;37418:33;37414:1;37406:6;37402:14;37395:57;37278:181;:::o;37465:366::-;37607:3;37628:67;37692:2;37687:3;37628:67;:::i;:::-;37621:74;;37704:93;37793:3;37704:93;:::i;:::-;37822:2;37817:3;37813:12;37806:19;;37465:366;;;:::o;37837:419::-;38003:4;38041:2;38030:9;38026:18;38018:26;;38090:9;38084:4;38080:20;38076:1;38065:9;38061:17;38054:47;38118:131;38244:4;38118:131;:::i;:::-;38110:139;;37837:419;;;:::o;38262:221::-;38402:34;38398:1;38390:6;38386:14;38379:58;38471:4;38466:2;38458:6;38454:15;38447:29;38262:221;:::o;38489:366::-;38631:3;38652:67;38716:2;38711:3;38652:67;:::i;:::-;38645:74;;38728:93;38817:3;38728:93;:::i;:::-;38846:2;38841:3;38837:12;38830:19;;38489:366;;;:::o;38861:419::-;39027:4;39065:2;39054:9;39050:18;39042:26;;39114:9;39108:4;39104:20;39100:1;39089:9;39085:17;39078:47;39142:131;39268:4;39142:131;:::i;:::-;39134:139;;38861:419;;;:::o;39286:221::-;39426:34;39422:1;39414:6;39410:14;39403:58;39495:4;39490:2;39482:6;39478:15;39471:29;39286:221;:::o;39513:366::-;39655:3;39676:67;39740:2;39735:3;39676:67;:::i;:::-;39669:74;;39752:93;39841:3;39752:93;:::i;:::-;39870:2;39865:3;39861:12;39854:19;;39513:366;;;:::o;39885:419::-;40051:4;40089:2;40078:9;40074:18;40066:26;;40138:9;40132:4;40128:20;40124:1;40113:9;40109:17;40102:47;40166:131;40292:4;40166:131;:::i;:::-;40158:139;;39885:419;;;:::o

Swarm Source

ipfs://29a28a5cf538903ad749e2977617a624008ca99a023597e1001de0e45adb401c

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services