Token

Swaggy Moose (SWAGGYMO)

ERC-721

Overview

Max Total Supply

54 SWAGGYMO

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x43683f46d2707f3952035ca334c7f234f620a9d2

Filtered by Token Holder

0xf83a76a56123E2c44D41E7b9716C712a8eb34eeB

funkymonks.eth

Balance

2 SWAGGYMO

0xf83a76a56123e2c44d41e7b9716c712a8eb34eeb

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SwaggyMoose

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-09-13
*/

// SPDX-License-Identifier: MIT

// GO TO LINE 1904 TO SEE WHERE THE COW CONTRACT STARTS
 
// File: @openzeppelin/contracts/utils/Context.sol

pragma solidity >=0.6.0 <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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/introspection/IERC165.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol



pragma solidity >=0.6.2 <0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol



pragma solidity >=0.6.2 <0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

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

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol



pragma solidity >=0.6.2 <0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

// File: @openzeppelin/contracts/introspection/ERC165.sol



pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: @openzeppelin/contracts/math/SafeMath.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when 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.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

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



pragma solidity >=0.6.2 <0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

   /**
    * @dev Returns the element stored at position `index` in the set. O(1).
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
 
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

    // Mapping from token ID to approved address
    mapping (uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping (uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId); // internal owner

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
    }

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

// File: @openzeppelin/contracts/access/Ownable.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


// SwaggyMoose created by WoodCollector
// Art by ebbanosen

pragma solidity ^0.7.0;
pragma abicoder v2;

abstract contract SwaggyCows {
  function ownerOf(uint256 tokenId) public virtual view returns (address);
  function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
  function balanceOf(address owner) external virtual view returns (uint256 balance);
}

contract SwaggyMoose is ERC721, Ownable {
    
    using SafeMath for uint256;

    string public MOOSE_PROVENANCE = ""; // IPFS URL WILL BE ADDED WHEN COWS ARE ALL SOLD OUT
    
    string public LICENSE_TEXT = ""; // IT IS WHAT IT SAYS
    
    bool licenseLocked = false; // TEAM CAN'T EDIT THE LICENSE AFTER THIS GETS TRUE

    uint256 public constant MAX_MOOSE = 1000;

    bool public saleIsActive = false;
    
    bool public uriIsFrozen = false;
    
    SwaggyCows private swaggycows;
    
    
    event licenseisLocked(string _licenseText);

    constructor() ERC721("Swaggy Moose", "SWAGGYMO") {
    swaggycows = SwaggyCows(0x398A5b355658Df4a836c9250FCe6F0A0fC0c9EA0);
    }
    
    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    function setProvenanceHash(string memory provenanceHash) public onlyOwner {
        MOOSE_PROVENANCE = provenanceHash;
    }
    
      function isMinted(uint256 tokenId) external view returns (bool) {
    require(tokenId < MAX_MOOSE, "tokenId outside collection bounds");

    return _exists(tokenId);
  }

    function setBaseURI(string memory baseURI) public onlyOwner {
        require(uriIsFrozen == false, "The BaseURI has been frozen and can not be changed.");
        _setBaseURI(baseURI);
    }
    
    function freezeBaseURI() public onlyOwner {
        require(uriIsFrozen == false, "The BaseURI has already been frozen.");
        uriIsFrozen = true;
    }


    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }
    
    
    function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }
    
    // Returns the license for tokens
    function tokenLicense(uint _id) public view returns(string memory) {
        require(_id < totalSupply(), "CHOOSE A MOOSE WITHIN RANGE");
        return LICENSE_TEXT;
    }
    
    // Locks the license to prevent further changes 
    function lockLicense() public onlyOwner {
        licenseLocked =  true;
        emit licenseisLocked(LICENSE_TEXT);
    }
    
    // Change the license
    function changeLicense(string memory _license) public onlyOwner {
        require(licenseLocked == false, "License already locked");
        LICENSE_TEXT = _license;
    }
    
    function adoptMoose(uint256 swaggycowsTokenId) public {
    require(saleIsActive, "Sale must be active to mint a Swaggy Moose");
    require(totalSupply() < MAX_MOOSE, "Minting would exceed max supply of Moose");
    require(swaggycowsTokenId < MAX_MOOSE, "Requested tokenId exceeds upper bound");
    require(swaggycows.ownerOf(swaggycowsTokenId) == msg.sender, "Must own the Swaggy Cow for requested tokenId to mint a Swaggy Moose");
    
    _safeMint(msg.sender, swaggycowsTokenId);
  }
    
     
    
    

    
}

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":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_licenseText","type":"string"}],"name":"licenseisLocked","type":"event"},{"inputs":[],"name":"LICENSE_TEXT","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_MOOSE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MOOSE_PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"swaggycowsTokenId","type":"uint256"}],"name":"adoptMoose","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_license","type":"string"}],"name":"changeLicense","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"freezeBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockLicense","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"provenanceHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"tokenLicense","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uriIsFrozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"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

67259:3380:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10295:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51580:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54366:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53896:404;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68120:126;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53374:211;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55256:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53136:162;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68260:174;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68817:89;;;:::i;:::-;;67981:131;;;:::i;:::-;;67695:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55632:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53662:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68442:194;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51336:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52955:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51053:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66291:148;;;:::i;:::-;;67601:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67347:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68924:540;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65640:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51749:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67448:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54659:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70106:497;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69920:174;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55854:285;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69756:125;;;:::i;:::-;;51924:792;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69515:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68648:159;;;:::i;:::-;;55025:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67650:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66594:244;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10295:150;10380:4;10404:20;:33;10425:11;10404:33;;;;;;;;;;;;;;;;;;;;;;;;;;;10397:40;;10295:150;;;:::o;51580:100::-;51634:13;51667:5;51660:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51580:100;:::o;54366:221::-;54442:7;54470:16;54478:7;54470;:16::i;:::-;54462:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;54555:15;:24;54571:7;54555:24;;;;;;;;;;;;;;;;;;;;;54548:31;;54366:221;;;:::o;53896:404::-;53977:13;53993:23;54008:7;53993:14;:23::i;:::-;53977:39;;54041:5;54035:11;;:2;:11;;;;54027:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;54121:5;54105:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;54130:44;54154:5;54161:12;:10;:12::i;:::-;54130:23;:44::i;:::-;54105:69;54097:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;54271:21;54280:2;54284:7;54271:8;:21::i;:::-;53896:404;;;:::o;68120:126::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68224:14:::1;68205:16;:33;;;;;;;;;;;;:::i;:::-;;68120:126:::0;:::o;53374:211::-;53435:7;53556:21;:12;:19;:21::i;:::-;53549:28;;53374:211;:::o;55256:305::-;55417:41;55436:12;:10;:12::i;:::-;55450:7;55417:18;:41::i;:::-;55409:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;55525:28;55535:4;55541:2;55545:7;55525:9;:28::i;:::-;55256:305;;;:::o;53136:162::-;53233:7;53260:30;53284:5;53260:13;:20;53274:5;53260:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;53253:37;;53136:162;;;;:::o;68260:174::-;68318:4;67637;68339:7;:19;68331:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;68412:16;68420:7;68412;:16::i;:::-;68405:23;;68260:174;;;:::o;68817:89::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68886:12:::1;;;;;;;;;;;68885:13;68870:12;;:28;;;;;;;;;;;;;;;;;;68817:89::o:0;67981:131::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68029:12:::1;68044:21;68029:36;;68076:10;:19;;:28;68096:7;68076:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;65931:1;67981:131::o:0;67695:31::-;;;;;;;;;;;;;:::o;55632:151::-;55736:39;55753:4;55759:2;55763:7;55736:39;;;;;;;;;;;;:16;:39::i;:::-;55632:151;;;:::o;53662:172::-;53737:7;53758:15;53779:22;53795:5;53779:12;:15;;:22;;;;:::i;:::-;53757:44;;;53819:7;53812:14;;;53662:172;;;:::o;68442:194::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68536:5:::1;68521:20;;:11;;;;;;;;;;;:20;;;68513:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;68608:20;68620:7;68608:11;:20::i;:::-;68442:194:::0;:::o;51336:177::-;51408:7;51435:70;51452:7;51435:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;51428:77;;51336:177;;;:::o;52955:97::-;53003:13;53036:8;53029:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52955:97;:::o;51053:221::-;51125:7;51170:1;51153:19;;:5;:19;;;;51145:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;51237:29;:13;:20;51251:5;51237:20;;;;;;;;;;;;;;;:27;:29::i;:::-;51230:36;;51053:221;;;:::o;66291:148::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66398:1:::1;66361:40;;66382:6;;;;;;;;;;;66361:40;;;;;;;;;;;;66429:1;66412:6;;:19;;;;;;;;;;;;;;;;;;66291:148::o:0;67601:40::-;67637:4;67601:40;:::o;67347:35::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68924:540::-;68985:16;69015:18;69036:17;69046:6;69036:9;:17::i;:::-;69015:38;;69082:1;69068:10;:15;69064:393;;;69159:1;69145:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69138:23;;;;;69064:393;69194:23;69234:10;69220:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69194:51;;69260:13;69288:130;69312:10;69304:5;:18;69288:130;;;69368:34;69388:6;69396:5;69368:19;:34::i;:::-;69352:6;69359:5;69352:13;;;;;;;;;;;;;:50;;;;;69324:7;;;;;;;69288:130;;;69439:6;69432:13;;;;;68924:540;;;;:::o;65640:87::-;65686:7;65713:6;;;;;;;;;;;65706:13;;65640:87;:::o;51749:104::-;51805:13;51838:7;51831:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51749:104;:::o;67448:31::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;54659:295::-;54774:12;:10;:12::i;:::-;54762:24;;:8;:24;;;;54754:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;54874:8;54829:18;:32;54848:12;:10;:12::i;:::-;54829:32;;;;;;;;;;;;;;;:42;54862:8;54829:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;54927:8;54898:48;;54913:12;:10;:12::i;:::-;54898:48;;;54937:8;54898:48;;;;;;:::i;:::-;;;;;;;;54659:295;;:::o;70106:497::-;70175:12;;;;;;;;;;;70167:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;67637:4;70249:13;:11;:13::i;:::-;:25;70241:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;67637:4;70334:17;:29;70326:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;70461:10;70420:51;;:10;;;;;;;;;;;:18;;;70439:17;70420:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:51;;;70412:132;;;;;;;;;;;;:::i;:::-;;;;;;;;;70557:40;70567:10;70579:17;70557:9;:40::i;:::-;70106:497;:::o;69920:174::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70020:5:::1;70003:22;;:13;;;;;;;;;;;:22;;;69995:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;70078:8;70063:12;:23;;;;;;;;;;;;:::i;:::-;;69920:174:::0;:::o;55854:285::-;55986:41;56005:12;:10;:12::i;:::-;56019:7;55986:18;:41::i;:::-;55978:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;56092:39;56106:4;56112:2;56116:7;56125:5;56092:13;:39::i;:::-;55854:285;;;;:::o;69756:125::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;69824:4:::1;69807:13;;:21;;;;;;;;;;;;;;;;;;69844:29;69860:12;69844:29;;;;;;:::i;:::-;;;;;;;;69756:125::o:0;51924:792::-;51997:13;52031:16;52039:7;52031;:16::i;:::-;52023:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;52112:23;52138:10;:19;52149:7;52138:19;;;;;;;;;;;52112:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52168:18;52189:9;:7;:9::i;:::-;52168:30;;52296:1;52280:4;52274:18;:23;52270:72;;;52321:9;52314:16;;;;;;52270:72;52472:1;52452:9;52446:23;:27;52442:108;;;52521:4;52527:9;52504:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52490:48;;;;;;52442:108;52682:4;52688:18;:7;:16;:18::i;:::-;52665:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52651:57;;;;51924:792;;;;:::o;69515:175::-;69567:13;69607;:11;:13::i;:::-;69601:3;:19;69593:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;69670:12;69663:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69515:175;;;:::o;68648:159::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68724:5:::1;68709:20;;:11;;;;;;;;;;;:20;;;68701:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;68795:4;68781:11;;:18;;;;;;;;;;;;;;;;;;68648:159::o:0;55025:164::-;55122:4;55146:18;:25;55165:5;55146:25;;;;;;;;;;;;;;;:35;55172:8;55146:35;;;;;;;;;;;;;;;;;;;;;;;;;55139:42;;55025:164;;;;:::o;67650:32::-;;;;;;;;;;;;;:::o;66594:244::-;65871:12;:10;:12::i;:::-;65860:23;;:7;:5;:7::i;:::-;:23;;;65852:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66703:1:::1;66683:22;;:8;:22;;;;66675:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;66793:8;66764:38;;66785:6;;;;;;;;;;;66764:38;;;;;;;;;;;;66822:8;66813:6;;:17;;;;;;;;;;;;;;;;;;66594:244:::0;:::o;57606:127::-;57671:4;57695:30;57717:7;57695:12;:21;;:30;;;;:::i;:::-;57688:37;;57606:127;;;:::o;727:106::-;780:15;815:10;808:17;;727:106;:::o;63624:192::-;63726:2;63699:15;:24;63715:7;63699:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;63782:7;63778:2;63744:46;;63753:23;63768:7;63753:14;:23::i;:::-;63744:46;;;;;;;;;;;;63624:192;;:::o;44338:123::-;44407:7;44434:19;44442:3;:10;;44434:7;:19::i;:::-;44427:26;;44338:123;;;:::o;57900:355::-;57993:4;58018:16;58026:7;58018;:16::i;:::-;58010:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58094:13;58110:23;58125:7;58110:14;:23::i;:::-;58094:39;;58163:5;58152:16;;:7;:16;;;:51;;;;58196:7;58172:31;;:20;58184:7;58172:11;:20::i;:::-;:31;;;58152:51;:94;;;;58207:39;58231:5;58238:7;58207:23;:39::i;:::-;58152:94;58144:103;;;57900:355;;;;:::o;61036:599::-;61161:4;61134:31;;:23;61149:7;61134:14;:23::i;:::-;:31;;;61126:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;61262:1;61248:16;;:2;:16;;;;61240:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;61318:39;61339:4;61345:2;61349:7;61318:20;:39::i;:::-;61422:29;61439:1;61443:7;61422:8;:29::i;:::-;61464:35;61491:7;61464:13;:19;61478:4;61464:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;61510:30;61532:7;61510:13;:17;61524:2;61510:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;61553:29;61570:7;61579:2;61553:12;:16;;:29;;;;;:::i;:::-;;61619:7;61615:2;61600:27;;61609:4;61600:27;;;;;;;;;;;;61036:599;;;:::o;36129:137::-;36200:7;36235:22;36239:3;:10;;36251:5;36235:3;:22::i;:::-;36227:31;;36220:38;;36129:137;;;;:::o;44800:236::-;44880:7;44889;44910:11;44923:13;44940:22;44944:3;:10;;44956:5;44940:3;:22::i;:::-;44909:53;;;;44989:3;44981:12;;45019:5;45011:14;;44973:55;;;;;;44800:236;;;;;:::o;62236:100::-;62320:8;62309;:19;;;;;;;;;;;;:::i;:::-;;62236:100;:::o;46086:213::-;46193:7;46244:44;46249:3;:10;;46269:3;46261:12;;46275;46244:4;:44::i;:::-;46236:53;;46213:78;;46086:213;;;;;:::o;35671:114::-;35731:7;35758:19;35766:3;:10;;35758:7;:19::i;:::-;35751:26;;35671:114;;;:::o;58598:110::-;58674:26;58684:2;58688:7;58674:26;;;;;;;;;;;;:9;:26::i;:::-;58598:110;;:::o;57021:272::-;57135:28;57145:4;57151:2;57155:7;57135:9;:28::i;:::-;57182:48;57205:4;57211:2;57215:7;57224:5;57182:22;:48::i;:::-;57174:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;57021:272;;;;:::o;46550:746::-;46606:13;46836:1;46827:5;:10;46823:53;;;46854:10;;;;;;;;;;;;;;;;;;;;;46823:53;46886:12;46901:5;46886:20;;46917:14;46942:78;46957:1;46949:4;:9;46942:78;;46975:8;;;;;;;47006:2;46998:10;;;;;;;;;46942:78;;;47030:19;47062:6;47052:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47030:39;;47080:13;47105:1;47096:6;:10;47080:26;;47124:5;47117:12;;47140:117;47155:1;47147:4;:9;47140:117;;47216:2;47209:4;:9;;;;;;47204:2;:14;47191:29;;47173:6;47180:7;;;;;;;47173:15;;;;;;;;;;;:47;;;;;;;;;;;47243:2;47235:10;;;;;;;;;47140:117;;;47281:6;47267:21;;;;;;46550:746;;;;:::o;44099:151::-;44183:4;44207:35;44217:3;:10;;44237:3;44229:12;;44207:9;:35::i;:::-;44200:42;;44099:151;;;;:::o;40917:110::-;40973:7;41000:3;:12;;:19;;;;40993:26;;40917:110;;;:::o;64429:93::-;;;;:::o;35216:137::-;35286:4;35310:35;35318:3;:10;;35338:5;35330:14;;35310:7;:35::i;:::-;35303:42;;35216:137;;;;:::o;34909:131::-;34976:4;35000:32;35005:3;:10;;35025:5;35017:14;;35000:4;:32::i;:::-;34993:39;;34909:131;;;;:::o;43522:185::-;43611:4;43635:64;43640:3;:10;;43660:3;43652:12;;43690:5;43674:23;;43666:32;;43635:4;:64::i;:::-;43628:71;;43522:185;;;;;:::o;31167:204::-;31234:7;31283:5;31262:3;:11;;:18;;;;:26;31254:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;31345:3;:11;;31357:5;31345:18;;;;;;;;;;;;;;;;31338:25;;31167:204;;;;:::o;41382:279::-;41449:7;41458;41508:5;41486:3;:12;;:19;;;;:27;41478:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;41565:22;41590:3;:12;;41603:5;41590:19;;;;;;;;;;;;;;;;;;41565:44;;41628:5;:10;;;41640:5;:12;;;41620:33;;;;;41382:279;;;;;:::o;42879:319::-;42973:7;42993:16;43012:3;:12;;:17;43025:3;43012:17;;;;;;;;;;;;42993:36;;43060:1;43048:8;:13;;43063:12;43040:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;43130:3;:12;;43154:1;43143:8;:12;43130:26;;;;;;;;;;;;;;;;;;:33;;;43123:40;;;42879:319;;;;;:::o;30714:109::-;30770:7;30797:3;:11;;:18;;;;30790:25;;30714:109;;;:::o;58935:250::-;59031:18;59037:2;59041:7;59031:5;:18::i;:::-;59068:54;59099:1;59103:2;59107:7;59116:5;59068:22;:54::i;:::-;59060:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;58935:250;;;:::o;62901:604::-;63022:4;63049:15;:2;:13;;;:15::i;:::-;63044:60;;63088:4;63081:11;;;;63044:60;63114:23;63140:252;63193:45;;;63253:12;:10;:12::i;:::-;63280:4;63299:7;63321:5;63156:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63140:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;63114:278;;63403:13;63430:10;63419:32;;;;;;;;;;;;:::i;:::-;63403:48;;48050:10;63480:16;;63470:26;;;:6;:26;;;;63462:35;;;;62901:604;;;;;;;:::o;40697:125::-;40768:4;40813:1;40792:3;:12;;:17;40805:3;40792:17;;;;;;;;;;;;:22;;40785:29;;40697:125;;;;:::o;28869:1544::-;28935:4;29053:18;29074:3;:12;;:19;29087:5;29074:19;;;;;;;;;;;;29053:40;;29124:1;29110:10;:15;29106:1300;;29472:21;29509:1;29496:10;:14;29472:38;;29525:17;29566:1;29545:3;:11;;:18;;;;:22;29525:42;;29812:17;29832:3;:11;;29844:9;29832:22;;;;;;;;;;;;;;;;29812:42;;29978:9;29949:3;:11;;29961:13;29949:26;;;;;;;;;;;;;;;:38;;;;30097:1;30081:13;:17;30055:3;:12;;:23;30068:9;30055:23;;;;;;;;;;;:43;;;;30207:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;30302:3;:12;;:19;30315:5;30302:19;;;;;;;;;;;30295:26;;;30345:4;30338:11;;;;;;;;29106:1300;30389:5;30382:12;;;28869:1544;;;;;:::o;28279:414::-;28342:4;28364:21;28374:3;28379:5;28364:9;:21::i;:::-;28359:327;;28402:3;:11;;28419:5;28402:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28585:3;:11;;:18;;;;28563:3;:12;;:19;28576:5;28563:19;;;;;;;;;;;:40;;;;28625:4;28618:11;;;;28359:327;28669:5;28662:12;;28279:414;;;;;:::o;38197:692::-;38273:4;38389:16;38408:3;:12;;:17;38421:3;38408:17;;;;;;;;;;;;38389:36;;38454:1;38442:8;:13;38438:444;;;38509:3;:12;;38527:38;;;;;;;;38544:3;38527:38;;;;38557:5;38527:38;;;38509:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38724:3;:12;;:19;;;;38704:3;:12;;:17;38717:3;38704:17;;;;;;;;;;;:39;;;;38765:4;38758:11;;;;;38438:444;38838:5;38802:3;:12;;38826:1;38815:8;:12;38802:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;38865:5;38858:12;;;38197:692;;;;;;:::o;59521:404::-;59615:1;59601:16;;:2;:16;;;;59593:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;59674:16;59682:7;59674;:16::i;:::-;59673:17;59665:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;59736:45;59765:1;59769:2;59773:7;59736:20;:45::i;:::-;59794:30;59816:7;59794:13;:17;59808:2;59794:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;59837:29;59854:7;59863:2;59837:12;:16;;:29;;;;;:::i;:::-;;59909:7;59905:2;59884:33;;59901:1;59884:33;;;;;;;;;;;;59521:404;;:::o;19298:422::-;19358:4;19566:12;19677:7;19665:20;19657:28;;19711:1;19704:4;:8;19697:15;;;19298:422;;;:::o;22216:195::-;22319:12;22351:52;22373:6;22381:4;22387:1;22390:12;22351:21;:52::i;:::-;22344:59;;22216:195;;;;;:::o;30499:129::-;30572:4;30619:1;30596:3;:12;;:19;30609:5;30596:19;;;;;;;;;;;;:24;;30589:31;;30499:129;;;;:::o;23268:530::-;23395:12;23453:5;23428:21;:30;;23420:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;23520:18;23531:6;23520:10;:18::i;:::-;23512:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;23646:12;23660:23;23687:6;:11;;23707:5;23715:4;23687:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23645:75;;;;23738:52;23756:7;23765:10;23777:12;23738:17;:52::i;:::-;23731:59;;;;23268:530;;;;;;:::o;25808:742::-;25923:12;25952:7;25948:595;;;25983:10;25976:17;;;;25948:595;26117:1;26097:10;:17;:21;26093:439;;;26360:10;26354:17;26421:15;26408:10;26404:2;26400:19;26393:44;26308:148;26503:12;26496:20;;;;;;;;;;;:::i;:::-;;;;;;;;25808:742;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:342:1:-;;109:64;124:48;165:6;124:48;:::i;:::-;109:64;:::i;:::-;100:73;;196:6;189:5;182:21;234:4;227:5;223:16;272:3;263:6;258:3;254:16;251:25;248:2;;;289:1;286;279:12;248:2;302:41;336:6;331:3;326;302:41;:::i;:::-;90:259;;;;;;:::o;355:344::-;;458:65;473:49;515:6;473:49;:::i;:::-;458:65;:::i;:::-;449:74;;546:6;539:5;532:21;584:4;577:5;573:16;622:3;613:6;608:3;604:16;601:25;598:2;;;639:1;636;629:12;598:2;652:41;686:6;681:3;676;652:41;:::i;:::-;439:260;;;;;;:::o;705:139::-;;789:6;776:20;767:29;;805:33;832:5;805:33;:::i;:::-;757:87;;;;:::o;850:143::-;;938:6;932:13;923:22;;954:33;981:5;954:33;:::i;:::-;913:80;;;;:::o;999:133::-;;1080:6;1067:20;1058:29;;1096:30;1120:5;1096:30;:::i;:::-;1048:84;;;;:::o;1138:137::-;;1221:6;1208:20;1199:29;;1237:32;1263:5;1237:32;:::i;:::-;1189:86;;;;:::o;1281:141::-;;1368:6;1362:13;1353:22;;1384:32;1410:5;1384:32;:::i;:::-;1343:79;;;;:::o;1441:271::-;;1545:3;1538:4;1530:6;1526:17;1522:27;1512:2;;1563:1;1560;1553:12;1512:2;1603:6;1590:20;1628:78;1702:3;1694:6;1687:4;1679:6;1675:17;1628:78;:::i;:::-;1619:87;;1502:210;;;;;:::o;1732:273::-;;1837:3;1830:4;1822:6;1818:17;1814:27;1804:2;;1855:1;1852;1845:12;1804:2;1895:6;1882:20;1920:79;1995:3;1987:6;1980:4;1972:6;1968:17;1920:79;:::i;:::-;1911:88;;1794:211;;;;;:::o;2011:139::-;;2095:6;2082:20;2073:29;;2111:33;2138:5;2111:33;:::i;:::-;2063:87;;;;:::o;2156:262::-;;2264:2;2252:9;2243:7;2239:23;2235:32;2232:2;;;2280:1;2277;2270:12;2232:2;2323:1;2348:53;2393:7;2384:6;2373:9;2369:22;2348:53;:::i;:::-;2338:63;;2294:117;2222:196;;;;:::o;2424:284::-;;2543:2;2531:9;2522:7;2518:23;2514:32;2511:2;;;2559:1;2556;2549:12;2511:2;2602:1;2627:64;2683:7;2674:6;2663:9;2659:22;2627:64;:::i;:::-;2617:74;;2573:128;2501:207;;;;:::o;2714:407::-;;;2839:2;2827:9;2818:7;2814:23;2810:32;2807:2;;;2855:1;2852;2845:12;2807:2;2898:1;2923:53;2968:7;2959:6;2948:9;2944:22;2923:53;:::i;:::-;2913:63;;2869:117;3025:2;3051:53;3096:7;3087:6;3076:9;3072:22;3051:53;:::i;:::-;3041:63;;2996:118;2797:324;;;;;:::o;3127:552::-;;;;3269:2;3257:9;3248:7;3244:23;3240:32;3237:2;;;3285:1;3282;3275:12;3237:2;3328:1;3353:53;3398:7;3389:6;3378:9;3374:22;3353:53;:::i;:::-;3343:63;;3299:117;3455:2;3481:53;3526:7;3517:6;3506:9;3502:22;3481:53;:::i;:::-;3471:63;;3426:118;3583:2;3609:53;3654:7;3645:6;3634:9;3630:22;3609:53;:::i;:::-;3599:63;;3554:118;3227:452;;;;;:::o;3685:809::-;;;;;3853:3;3841:9;3832:7;3828:23;3824:33;3821:2;;;3870:1;3867;3860:12;3821:2;3913:1;3938:53;3983:7;3974:6;3963:9;3959:22;3938:53;:::i;:::-;3928:63;;3884:117;4040:2;4066:53;4111:7;4102:6;4091:9;4087:22;4066:53;:::i;:::-;4056:63;;4011:118;4168:2;4194:53;4239:7;4230:6;4219:9;4215:22;4194:53;:::i;:::-;4184:63;;4139:118;4324:2;4313:9;4309:18;4296:32;4355:18;4347:6;4344:30;4341:2;;;4387:1;4384;4377:12;4341:2;4415:62;4469:7;4460:6;4449:9;4445:22;4415:62;:::i;:::-;4405:72;;4267:220;3811:683;;;;;;;:::o;4500:401::-;;;4622:2;4610:9;4601:7;4597:23;4593:32;4590:2;;;4638:1;4635;4628:12;4590:2;4681:1;4706:53;4751:7;4742:6;4731:9;4727:22;4706:53;:::i;:::-;4696:63;;4652:117;4808:2;4834:50;4876:7;4867:6;4856:9;4852:22;4834:50;:::i;:::-;4824:60;;4779:115;4580:321;;;;;:::o;4907:407::-;;;5032:2;5020:9;5011:7;5007:23;5003:32;5000:2;;;5048:1;5045;5038:12;5000:2;5091:1;5116:53;5161:7;5152:6;5141:9;5137:22;5116:53;:::i;:::-;5106:63;;5062:117;5218:2;5244:53;5289:7;5280:6;5269:9;5265:22;5244:53;:::i;:::-;5234:63;;5189:118;4990:324;;;;;:::o;5320:260::-;;5427:2;5415:9;5406:7;5402:23;5398:32;5395:2;;;5443:1;5440;5433:12;5395:2;5486:1;5511:52;5555:7;5546:6;5535:9;5531:22;5511:52;:::i;:::-;5501:62;;5457:116;5385:195;;;;:::o;5586:282::-;;5704:2;5692:9;5683:7;5679:23;5675:32;5672:2;;;5720:1;5717;5710:12;5672:2;5763:1;5788:63;5843:7;5834:6;5823:9;5819:22;5788:63;:::i;:::-;5778:73;;5734:127;5662:206;;;;:::o;5874:375::-;;5992:2;5980:9;5971:7;5967:23;5963:32;5960:2;;;6008:1;6005;5998:12;5960:2;6079:1;6068:9;6064:17;6051:31;6109:18;6101:6;6098:30;6095:2;;;6141:1;6138;6131:12;6095:2;6169:63;6224:7;6215:6;6204:9;6200:22;6169:63;:::i;:::-;6159:73;;6022:220;5950:299;;;;:::o;6255:262::-;;6363:2;6351:9;6342:7;6338:23;6334:32;6331:2;;;6379:1;6376;6369:12;6331:2;6422:1;6447:53;6492:7;6483:6;6472:9;6468:22;6447:53;:::i;:::-;6437:63;;6393:117;6321:196;;;;:::o;6523:179::-;;6613:46;6655:3;6647:6;6613:46;:::i;:::-;6691:4;6686:3;6682:14;6668:28;;6603:99;;;;:::o;6708:142::-;6811:32;6837:5;6811:32;:::i;:::-;6806:3;6799:45;6789:61;;:::o;6856:118::-;6943:24;6961:5;6943:24;:::i;:::-;6938:3;6931:37;6921:53;;:::o;7010:732::-;;7158:54;7206:5;7158:54;:::i;:::-;7228:86;7307:6;7302:3;7228:86;:::i;:::-;7221:93;;7338:56;7388:5;7338:56;:::i;:::-;7417:7;7448:1;7433:284;7458:6;7455:1;7452:13;7433:284;;;7534:6;7528:13;7561:63;7620:3;7605:13;7561:63;:::i;:::-;7554:70;;7647:60;7700:6;7647:60;:::i;:::-;7637:70;;7493:224;7480:1;7477;7473:9;7468:14;;7433:284;;;7437:14;7733:3;7726:10;;7134:608;;;;;;;:::o;7748:109::-;7829:21;7844:5;7829:21;:::i;:::-;7824:3;7817:34;7807:50;;:::o;7863:360::-;;7977:38;8009:5;7977:38;:::i;:::-;8031:70;8094:6;8089:3;8031:70;:::i;:::-;8024:77;;8110:52;8155:6;8150:3;8143:4;8136:5;8132:16;8110:52;:::i;:::-;8187:29;8209:6;8187:29;:::i;:::-;8182:3;8178:39;8171:46;;7953:270;;;;;:::o;8229:373::-;;8361:38;8393:5;8361:38;:::i;:::-;8415:88;8496:6;8491:3;8415:88;:::i;:::-;8408:95;;8512:52;8557:6;8552:3;8545:4;8538:5;8534:16;8512:52;:::i;:::-;8589:6;8584:3;8580:16;8573:23;;8337:265;;;;;:::o;8608:364::-;;8724:39;8757:5;8724:39;:::i;:::-;8779:71;8843:6;8838:3;8779:71;:::i;:::-;8772:78;;8859:52;8904:6;8899:3;8892:4;8885:5;8881:16;8859:52;:::i;:::-;8936:29;8958:6;8936:29;:::i;:::-;8931:3;8927:39;8920:46;;8700:272;;;;;:::o;8978:377::-;;9112:39;9145:5;9112:39;:::i;:::-;9167:89;9249:6;9244:3;9167:89;:::i;:::-;9160:96;;9265:52;9310:6;9305:3;9298:4;9291:5;9287:16;9265:52;:::i;:::-;9342:6;9337:3;9333:16;9326:23;;9088:267;;;;;:::o;9385:937::-;;9507:5;9501:12;9544:1;9533:9;9529:17;9560:1;9555:281;;;;9850:1;9845:471;;;;9522:794;;9555:281;9645:4;9641:1;9630:9;9626:17;9622:28;9670:71;9734:6;9729:3;9670:71;:::i;:::-;9663:78;;9785:4;9781:9;9770;9766:25;9761:3;9754:38;9821:4;9816:3;9812:14;9805:21;;9562:274;9555:281;;9845:471;9926:1;9915:9;9911:17;9948:71;10012:6;10007:3;9948:71;:::i;:::-;9941:78;;10047:38;10079:5;10047:38;:::i;:::-;10107:1;10121:154;10135:6;10132:1;10129:13;10121:154;;;10209:7;10203:14;10199:1;10194:3;10190:11;10183:35;10259:1;10250:7;10246:15;10235:26;;10157:4;10154:1;10150:12;10145:17;;10121:154;;;10304:1;10299:3;10295:11;10288:18;;9852:464;;;9522:794;;9474:848;;;;;:::o;10328:366::-;;10491:67;10555:2;10550:3;10491:67;:::i;:::-;10484:74;;10588:34;10584:1;10579:3;10575:11;10568:55;10654:4;10649:2;10644:3;10640:12;10633:26;10685:2;10680:3;10676:12;10669:19;;10474:220;;;:::o;10700:382::-;;10863:67;10927:2;10922:3;10863:67;:::i;:::-;10856:74;;10960:34;10956:1;10951:3;10947:11;10940:55;11026:20;11021:2;11016:3;11012:12;11005:42;11073:2;11068:3;11064:12;11057:19;;10846:236;;;:::o;11088:370::-;;11251:67;11315:2;11310:3;11251:67;:::i;:::-;11244:74;;11348:34;11344:1;11339:3;11335:11;11328:55;11414:8;11409:2;11404:3;11400:12;11393:30;11449:2;11444:3;11440:12;11433:19;;11234:224;;;:::o;11464:326::-;;11627:67;11691:2;11686:3;11627:67;:::i;:::-;11620:74;;11724:30;11720:1;11715:3;11711:11;11704:51;11781:2;11776:3;11772:12;11765:19;;11610:180;;;:::o;11796:325::-;;11959:67;12023:2;12018:3;11959:67;:::i;:::-;11952:74;;12056:29;12052:1;12047:3;12043:11;12036:50;12112:2;12107:3;12103:12;12096:19;;11942:179;;;:::o;12127:368::-;;12290:67;12354:2;12349:3;12290:67;:::i;:::-;12283:74;;12387:34;12383:1;12378:3;12374:11;12367:55;12453:6;12448:2;12443:3;12439:12;12432:28;12486:2;12481:3;12477:12;12470:19;;12273:222;;;:::o;12501:323::-;;12664:67;12728:2;12723:3;12664:67;:::i;:::-;12657:74;;12761:27;12757:1;12752:3;12748:11;12741:48;12815:2;12810:3;12806:12;12799:19;;12647:177;;;:::o;12830:370::-;;12993:67;13057:2;13052:3;12993:67;:::i;:::-;12986:74;;13090:34;13086:1;13081:3;13077:11;13070:55;13156:8;13151:2;13146:3;13142:12;13135:30;13191:2;13186:3;13182:12;13175:19;;12976:224;;;:::o;13206:376::-;;13369:67;13433:2;13428:3;13369:67;:::i;:::-;13362:74;;13466:34;13462:1;13457:3;13453:11;13446:55;13532:14;13527:2;13522:3;13518:12;13511:36;13573:2;13568:3;13564:12;13557:19;;13352:230;;;:::o;13588:434::-;;13751:67;13815:2;13810:3;13751:67;:::i;:::-;13744:74;;13848:34;13844:1;13839:3;13835:11;13828:55;13914:34;13909:2;13904:3;13900:12;13893:56;13980:6;13975:2;13970:3;13966:12;13959:28;14013:2;14008:3;14004:12;13997:19;;13734:288;;;:::o;14028:369::-;;14191:67;14255:2;14250:3;14191:67;:::i;:::-;14184:74;;14288:34;14284:1;14279:3;14275:11;14268:55;14354:7;14349:2;14344:3;14340:12;14333:29;14388:2;14383:3;14379:12;14372:19;;14174:223;;;:::o;14403:388::-;;14566:67;14630:2;14625:3;14566:67;:::i;:::-;14559:74;;14663:34;14659:1;14654:3;14650:11;14643:55;14729:26;14724:2;14719:3;14715:12;14708:48;14782:2;14777:3;14773:12;14766:19;;14549:242;;;:::o;14797:374::-;;14960:67;15024:2;15019:3;14960:67;:::i;:::-;14953:74;;15057:34;15053:1;15048:3;15044:11;15037:55;15123:12;15118:2;15113:3;15109:12;15102:34;15162:2;15157:3;15153:12;15146:19;;14943:228;;;:::o;15177:383::-;;15340:67;15404:2;15399:3;15340:67;:::i;:::-;15333:74;;15437:34;15433:1;15428:3;15424:11;15417:55;15503:21;15498:2;15493:3;15489:12;15482:43;15551:2;15546:3;15542:12;15535:19;;15323:237;;;:::o;15566:368::-;;15729:67;15793:2;15788:3;15729:67;:::i;:::-;15722:74;;15826:34;15822:1;15817:3;15813:11;15806:55;15892:6;15887:2;15882:3;15878:12;15871:28;15925:2;15920:3;15916:12;15909:19;;15712:222;;;:::o;15940:366::-;;16103:67;16167:2;16162:3;16103:67;:::i;:::-;16096:74;;16200:34;16196:1;16191:3;16187:11;16180:55;16266:4;16261:2;16256:3;16252:12;16245:26;16297:2;16292:3;16288:12;16281:19;;16086:220;;;:::o;16312:330::-;;16475:67;16539:2;16534:3;16475:67;:::i;:::-;16468:74;;16572:34;16568:1;16563:3;16559:11;16552:55;16633:2;16628:3;16624:12;16617:19;;16458:184;;;:::o;16648:376::-;;16811:67;16875:2;16870:3;16811:67;:::i;:::-;16804:74;;16908:34;16904:1;16899:3;16895:11;16888:55;16974:14;16969:2;16964:3;16960:12;16953:36;17015:2;17010:3;17006:12;16999:19;;16794:230;;;:::o;17030:330::-;;17193:67;17257:2;17252:3;17193:67;:::i;:::-;17186:74;;17290:34;17286:1;17281:3;17277:11;17270:55;17351:2;17346:3;17342:12;17335:19;;17176:184;;;:::o;17366:373::-;;17529:67;17593:2;17588:3;17529:67;:::i;:::-;17522:74;;17626:34;17622:1;17617:3;17613:11;17606:55;17692:11;17687:2;17682:3;17678:12;17671:33;17730:2;17725:3;17721:12;17714:19;;17512:227;;;:::o;17745:374::-;;17908:67;17972:2;17967:3;17908:67;:::i;:::-;17901:74;;18005:34;18001:1;17996:3;17992:11;17985:55;18071:12;18066:2;18061:3;18057:12;18050:34;18110:2;18105:3;18101:12;18094:19;;17891:228;;;:::o;18125:379::-;;18288:67;18352:2;18347:3;18288:67;:::i;:::-;18281:74;;18385:34;18381:1;18376:3;18372:11;18365:55;18451:17;18446:2;18441:3;18437:12;18430:39;18495:2;18490:3;18486:12;18479:19;;18271:233;;;:::o;18510:365::-;;18673:67;18737:2;18732:3;18673:67;:::i;:::-;18666:74;;18770:34;18766:1;18761:3;18757:11;18750:55;18836:3;18831:2;18826:3;18822:12;18815:25;18866:2;18861:3;18857:12;18850:19;;18656:219;;;:::o;18881:365::-;;19044:67;19108:2;19103:3;19044:67;:::i;:::-;19037:74;;19141:34;19137:1;19132:3;19128:11;19121:55;19207:3;19202:2;19197:3;19193:12;19186:25;19237:2;19232:3;19228:12;19221:19;;19027:219;;;:::o;19252:320::-;;19415:67;19479:2;19474:3;19415:67;:::i;:::-;19408:74;;19512:24;19508:1;19503:3;19499:11;19492:45;19563:2;19558:3;19554:12;19547:19;;19398:174;;;:::o;19578:381::-;;19741:67;19805:2;19800:3;19741:67;:::i;:::-;19734:74;;19838:34;19834:1;19829:3;19825:11;19818:55;19904:19;19899:2;19894:3;19890:12;19883:41;19950:2;19945:3;19941:12;19934:19;;19724:235;;;:::o;19965:327::-;;20128:67;20192:2;20187:3;20128:67;:::i;:::-;20121:74;;20225:31;20221:1;20216:3;20212:11;20205:52;20283:2;20278:3;20274:12;20267:19;;20111:181;;;:::o;20298:372::-;;20461:67;20525:2;20520:3;20461:67;:::i;:::-;20454:74;;20558:34;20554:1;20549:3;20545:11;20538:55;20624:10;20619:2;20614:3;20610:12;20603:32;20661:2;20656:3;20652:12;20645:19;;20444:226;;;:::o;20676:108::-;20753:24;20771:5;20753:24;:::i;:::-;20748:3;20741:37;20731:53;;:::o;20790:118::-;20877:24;20895:5;20877:24;:::i;:::-;20872:3;20865:37;20855:53;;:::o;20914:271::-;;21066:93;21155:3;21146:6;21066:93;:::i;:::-;21059:100;;21176:3;21169:10;;21048:137;;;;:::o;21191:435::-;;21393:95;21484:3;21475:6;21393:95;:::i;:::-;21386:102;;21505:95;21596:3;21587:6;21505:95;:::i;:::-;21498:102;;21617:3;21610:10;;21375:251;;;;;:::o;21632:222::-;;21763:2;21752:9;21748:18;21740:26;;21776:71;21844:1;21833:9;21829:17;21820:6;21776:71;:::i;:::-;21730:124;;;;:::o;21860:672::-;;22109:3;22098:9;22094:19;22086:27;;22123:87;22207:1;22196:9;22192:17;22183:6;22123:87;:::i;:::-;22220:72;22288:2;22277:9;22273:18;22264:6;22220:72;:::i;:::-;22302;22370:2;22359:9;22355:18;22346:6;22302:72;:::i;:::-;22421:9;22415:4;22411:20;22406:2;22395:9;22391:18;22384:48;22449:76;22520:4;22511:6;22449:76;:::i;:::-;22441:84;;22076:456;;;;;;;:::o;22538:373::-;;22719:2;22708:9;22704:18;22696:26;;22768:9;22762:4;22758:20;22754:1;22743:9;22739:17;22732:47;22796:108;22899:4;22890:6;22796:108;:::i;:::-;22788:116;;22686:225;;;;:::o;22917:210::-;;23042:2;23031:9;23027:18;23019:26;;23055:65;23117:1;23106:9;23102:17;23093:6;23055:65;:::i;:::-;23009:118;;;;:::o;23133:313::-;;23284:2;23273:9;23269:18;23261:26;;23333:9;23327:4;23323:20;23319:1;23308:9;23304:17;23297:47;23361:78;23434:4;23425:6;23361:78;:::i;:::-;23353:86;;23251:195;;;;:::o;23452:307::-;;23600:2;23589:9;23585:18;23577:26;;23649:9;23643:4;23639:20;23635:1;23624:9;23620:17;23613:47;23677:75;23747:4;23738:6;23677:75;:::i;:::-;23669:83;;23567:192;;;;:::o;23765:419::-;;23969:2;23958:9;23954:18;23946:26;;24018:9;24012:4;24008:20;24004:1;23993:9;23989:17;23982:47;24046:131;24172:4;24046:131;:::i;:::-;24038:139;;23936:248;;;:::o;24190:419::-;;24394:2;24383:9;24379:18;24371:26;;24443:9;24437:4;24433:20;24429:1;24418:9;24414:17;24407:47;24471:131;24597:4;24471:131;:::i;:::-;24463:139;;24361:248;;;:::o;24615:419::-;;24819:2;24808:9;24804:18;24796:26;;24868:9;24862:4;24858:20;24854:1;24843:9;24839:17;24832:47;24896:131;25022:4;24896:131;:::i;:::-;24888:139;;24786:248;;;:::o;25040:419::-;;25244:2;25233:9;25229:18;25221:26;;25293:9;25287:4;25283:20;25279:1;25268:9;25264:17;25257:47;25321:131;25447:4;25321:131;:::i;:::-;25313:139;;25211:248;;;:::o;25465:419::-;;25669:2;25658:9;25654:18;25646:26;;25718:9;25712:4;25708:20;25704:1;25693:9;25689:17;25682:47;25746:131;25872:4;25746:131;:::i;:::-;25738:139;;25636:248;;;:::o;25890:419::-;;26094:2;26083:9;26079:18;26071:26;;26143:9;26137:4;26133:20;26129:1;26118:9;26114:17;26107:47;26171:131;26297:4;26171:131;:::i;:::-;26163:139;;26061:248;;;:::o;26315:419::-;;26519:2;26508:9;26504:18;26496:26;;26568:9;26562:4;26558:20;26554:1;26543:9;26539:17;26532:47;26596:131;26722:4;26596:131;:::i;:::-;26588:139;;26486:248;;;:::o;26740:419::-;;26944:2;26933:9;26929:18;26921:26;;26993:9;26987:4;26983:20;26979:1;26968:9;26964:17;26957:47;27021:131;27147:4;27021:131;:::i;:::-;27013:139;;26911:248;;;:::o;27165:419::-;;27369:2;27358:9;27354:18;27346:26;;27418:9;27412:4;27408:20;27404:1;27393:9;27389:17;27382:47;27446:131;27572:4;27446:131;:::i;:::-;27438:139;;27336:248;;;:::o;27590:419::-;;27794:2;27783:9;27779:18;27771:26;;27843:9;27837:4;27833:20;27829:1;27818:9;27814:17;27807:47;27871:131;27997:4;27871:131;:::i;:::-;27863:139;;27761:248;;;:::o;28015:419::-;;28219:2;28208:9;28204:18;28196:26;;28268:9;28262:4;28258:20;28254:1;28243:9;28239:17;28232:47;28296:131;28422:4;28296:131;:::i;:::-;28288:139;;28186:248;;;:::o;28440:419::-;;28644:2;28633:9;28629:18;28621:26;;28693:9;28687:4;28683:20;28679:1;28668:9;28664:17;28657:47;28721:131;28847:4;28721:131;:::i;:::-;28713:139;;28611:248;;;:::o;28865:419::-;;29069:2;29058:9;29054:18;29046:26;;29118:9;29112:4;29108:20;29104:1;29093:9;29089:17;29082:47;29146:131;29272:4;29146:131;:::i;:::-;29138:139;;29036:248;;;:::o;29290:419::-;;29494:2;29483:9;29479:18;29471:26;;29543:9;29537:4;29533:20;29529:1;29518:9;29514:17;29507:47;29571:131;29697:4;29571:131;:::i;:::-;29563:139;;29461:248;;;:::o;29715:419::-;;29919:2;29908:9;29904:18;29896:26;;29968:9;29962:4;29958:20;29954:1;29943:9;29939:17;29932:47;29996:131;30122:4;29996:131;:::i;:::-;29988:139;;29886:248;;;:::o;30140:419::-;;30344:2;30333:9;30329:18;30321:26;;30393:9;30387:4;30383:20;30379:1;30368:9;30364:17;30357:47;30421:131;30547:4;30421:131;:::i;:::-;30413:139;;30311:248;;;:::o;30565:419::-;;30769:2;30758:9;30754:18;30746:26;;30818:9;30812:4;30808:20;30804:1;30793:9;30789:17;30782:47;30846:131;30972:4;30846:131;:::i;:::-;30838:139;;30736:248;;;:::o;30990:419::-;;31194:2;31183:9;31179:18;31171:26;;31243:9;31237:4;31233:20;31229:1;31218:9;31214:17;31207:47;31271:131;31397:4;31271:131;:::i;:::-;31263:139;;31161:248;;;:::o;31415:419::-;;31619:2;31608:9;31604:18;31596:26;;31668:9;31662:4;31658:20;31654:1;31643:9;31639:17;31632:47;31696:131;31822:4;31696:131;:::i;:::-;31688:139;;31586:248;;;:::o;31840:419::-;;32044:2;32033:9;32029:18;32021:26;;32093:9;32087:4;32083:20;32079:1;32068:9;32064:17;32057:47;32121:131;32247:4;32121:131;:::i;:::-;32113:139;;32011:248;;;:::o;32265:419::-;;32469:2;32458:9;32454:18;32446:26;;32518:9;32512:4;32508:20;32504:1;32493:9;32489:17;32482:47;32546:131;32672:4;32546:131;:::i;:::-;32538:139;;32436:248;;;:::o;32690:419::-;;32894:2;32883:9;32879:18;32871:26;;32943:9;32937:4;32933:20;32929:1;32918:9;32914:17;32907:47;32971:131;33097:4;32971:131;:::i;:::-;32963:139;;32861:248;;;:::o;33115:419::-;;33319:2;33308:9;33304:18;33296:26;;33368:9;33362:4;33358:20;33354:1;33343:9;33339:17;33332:47;33396:131;33522:4;33396:131;:::i;:::-;33388:139;;33286:248;;;:::o;33540:419::-;;33744:2;33733:9;33729:18;33721:26;;33793:9;33787:4;33783:20;33779:1;33768:9;33764:17;33757:47;33821:131;33947:4;33821:131;:::i;:::-;33813:139;;33711:248;;;:::o;33965:419::-;;34169:2;34158:9;34154:18;34146:26;;34218:9;34212:4;34208:20;34204:1;34193:9;34189:17;34182:47;34246:131;34372:4;34246:131;:::i;:::-;34238:139;;34136:248;;;:::o;34390:419::-;;34594:2;34583:9;34579:18;34571:26;;34643:9;34637:4;34633:20;34629:1;34618:9;34614:17;34607:47;34671:131;34797:4;34671:131;:::i;:::-;34663:139;;34561:248;;;:::o;34815:419::-;;35019:2;35008:9;35004:18;34996:26;;35068:9;35062:4;35058:20;35054:1;35043:9;35039:17;35032:47;35096:131;35222:4;35096:131;:::i;:::-;35088:139;;34986:248;;;:::o;35240:419::-;;35444:2;35433:9;35429:18;35421:26;;35493:9;35487:4;35483:20;35479:1;35468:9;35464:17;35457:47;35521:131;35647:4;35521:131;:::i;:::-;35513:139;;35411:248;;;:::o;35665:222::-;;35796:2;35785:9;35781:18;35773:26;;35809:71;35877:1;35866:9;35862:17;35853:6;35809:71;:::i;:::-;35763:124;;;;:::o;35893:278::-;;35959:2;35953:9;35943:19;;36001:4;35993:6;35989:17;36108:6;36096:10;36093:22;36072:18;36060:10;36057:34;36054:62;36051:2;;;36119:13;;:::i;:::-;36051:2;36154:10;36150:2;36143:22;35933:238;;;;:::o;36177:326::-;;36328:18;36320:6;36317:30;36314:2;;;36350:13;;:::i;:::-;36314:2;36430:4;36426:9;36419:4;36411:6;36407:17;36403:33;36395:41;;36491:4;36485;36481:15;36473:23;;36243:260;;;:::o;36509:327::-;;36661:18;36653:6;36650:30;36647:2;;;36683:13;;:::i;:::-;36647:2;36763:4;36759:9;36752:4;36744:6;36740:17;36736:33;36728:41;;36824:4;36818;36814:15;36806:23;;36576:260;;;:::o;36842:132::-;;36932:3;36924:11;;36962:4;36957:3;36953:14;36945:22;;36914:60;;;:::o;36980:141::-;;37052:3;37044:11;;37075:3;37072:1;37065:14;37109:4;37106:1;37096:18;37088:26;;37034:87;;;:::o;37127:114::-;;37228:5;37222:12;37212:22;;37201:40;;;:::o;37247:98::-;;37332:5;37326:12;37316:22;;37305:40;;;:::o;37351:99::-;;37437:5;37431:12;37421:22;;37410:40;;;:::o;37456:113::-;;37558:4;37553:3;37549:14;37541:22;;37531:38;;;:::o;37575:184::-;;37708:6;37703:3;37696:19;37748:4;37743:3;37739:14;37724:29;;37686:73;;;;:::o;37765:168::-;;37882:6;37877:3;37870:19;37922:4;37917:3;37913:14;37898:29;;37860:73;;;;:::o;37939:147::-;;38077:3;38062:18;;38052:34;;;;:::o;38092:169::-;;38210:6;38205:3;38198:19;38250:4;38245:3;38241:14;38226:29;;38188:73;;;;:::o;38267:148::-;;38406:3;38391:18;;38381:34;;;;:::o;38421:96::-;;38487:24;38505:5;38487:24;:::i;:::-;38476:35;;38466:51;;;:::o;38523:104::-;;38597:24;38615:5;38597:24;:::i;:::-;38586:35;;38576:51;;;:::o;38633:90::-;;38710:5;38703:13;38696:21;38685:32;;38675:48;;;:::o;38729:149::-;;38805:66;38798:5;38794:78;38783:89;;38773:105;;;:::o;38884:126::-;;38961:42;38954:5;38950:54;38939:65;;38929:81;;;:::o;39016:77::-;;39082:5;39071:16;;39061:32;;;:::o;39099:154::-;39183:6;39178:3;39173;39160:30;39245:1;39236:6;39231:3;39227:16;39220:27;39150:103;;;:::o;39259:307::-;39327:1;39337:113;39351:6;39348:1;39345:13;39337:113;;;39436:1;39431:3;39427:11;39421:18;39417:1;39412:3;39408:11;39401:39;39373:2;39370:1;39366:10;39361:15;;39337:113;;;39468:6;39465:1;39462:13;39459:2;;;39548:1;39539:6;39534:3;39530:16;39523:27;39459:2;39308:258;;;;:::o;39572:48::-;39605:9;39626:102;;39718:2;39714:7;39709:2;39702:5;39698:14;39694:28;39684:38;;39674:54;;;:::o;39734:122::-;39807:24;39825:5;39807:24;:::i;:::-;39800:5;39797:35;39787:2;;39846:1;39843;39836:12;39787:2;39777:79;:::o;39862:116::-;39932:21;39947:5;39932:21;:::i;:::-;39925:5;39922:32;39912:2;;39968:1;39965;39958:12;39912:2;39902:76;:::o;39984:120::-;40056:23;40073:5;40056:23;:::i;:::-;40049:5;40046:34;40036:2;;40094:1;40091;40084:12;40036:2;40026:78;:::o;40110:122::-;40183:24;40201:5;40183:24;:::i;:::-;40176:5;40173:35;40163:2;;40222:1;40219;40212:12;40163:2;40153:79;:::o

Swarm Source

ipfs://709b8fa2a25bb7e1ea89f01ced16fb1f230a5651b475b4ac56a5a61add9043f2

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