Token

DUALITY ()

ERC-1155

Overview

Max Total Supply

1,229

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xf35e8f7701ed8528d866c7561bd7072e2096f794

Filtered by Token Holder

0x2982CEC331B781dEfd2f3BF1AAe78C53b4ed5876

Alphaglyphs: Deployer

0x2982cec331b781defd2f3bf1aae78c53b4ed5876

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Duality

Compiler Version

v0.8.12+commit.f00d7308

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-05-24
*/

// SPDX-License-Identifier: MIT

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^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;

            if (lastIndex != toDeleteIndex) {
                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] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // 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) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // 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);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // 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))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // 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));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// File: @manifoldxyz/royalty-registry-solidity/contracts/specs/IEIP2981.sol



pragma solidity ^0.8.0;

/**
 * EIP-2981
 */
interface IEIP2981 {
    /**
     * bytes4(keccak256("royaltyInfo(uint256,uint256)")) == 0x2a55205a
     *
     * => 0x2a55205a = 0x2a55205a
     */
    function royaltyInfo(uint256 tokenId, uint256 value) external view returns (address, uint256);
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^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() {
        _transferOwnership(_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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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


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

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^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: @manifoldxyz/libraries-solidity/contracts/access/IAdminControl.sol



pragma solidity ^0.8.0;

/// @author: manifold.xyz


/**
 * @dev Interface for admin control
 */
interface IAdminControl is IERC165 {

    event AdminApproved(address indexed account, address indexed sender);
    event AdminRevoked(address indexed account, address indexed sender);

    /**
     * @dev gets address of all admins
     */
    function getAdmins() external view returns (address[] memory);

    /**
     * @dev add an admin.  Can only be called by contract owner.
     */
    function approveAdmin(address admin) external;

    /**
     * @dev remove an admin.  Can only be called by contract owner.
     */
    function revokeAdmin(address admin) external;

    /**
     * @dev checks whether or not given address is an admin
     * Returns True if they are
     */
    function isAdmin(address admin) external view returns (bool);

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @manifoldxyz/libraries-solidity/contracts/access/AdminControl.sol



pragma solidity ^0.8.0;




abstract contract AdminControl is Ownable, IAdminControl, ERC165 {
    using EnumerableSet for EnumerableSet.AddressSet;

    // Track registered admins
    EnumerableSet.AddressSet private _admins;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IAdminControl).interfaceId
            || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Only allows approved admins to call the specified function
     */
    modifier adminRequired() {
        require(owner() == msg.sender || _admins.contains(msg.sender), "AdminControl: Must be owner or admin");
        _;
    }   

    /**
     * @dev See {IAdminControl-getAdmins}.
     */
    function getAdmins() external view override returns (address[] memory admins) {
        admins = new address[](_admins.length());
        for (uint i = 0; i < _admins.length(); i++) {
            admins[i] = _admins.at(i);
        }
        return admins;
    }

    /**
     * @dev See {IAdminControl-approveAdmin}.
     */
    function approveAdmin(address admin) external override onlyOwner {
        if (!_admins.contains(admin)) {
            emit AdminApproved(admin, msg.sender);
            _admins.add(admin);
        }
    }

    /**
     * @dev See {IAdminControl-revokeAdmin}.
     */
    function revokeAdmin(address admin) external override onlyOwner {
        if (_admins.contains(admin)) {
            emit AdminRevoked(admin, msg.sender);
            _admins.remove(admin);
        }
    }

    /**
     * @dev See {IAdminControl-isAdmin}.
     */
    function isAdmin(address admin) public override view returns (bool) {
        return (owner() == admin || _admins.contains(admin));
    }

}
// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol


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

pragma solidity ^0.8.0;


/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;







/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC1155).interfaceId ||
            interfaceId == type(IERC1155MetadataURI).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

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

        emit TransferSingle(operator, from, to, id, amount);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

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

        emit TransferBatch(operator, from, to, ids, amounts);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}

// File: contracts/duality.sol



pragma solidity >= 0.8.12;







contract Duality is ERC1155, AdminControl {
    
    mapping(address => uint256) public _tokensClaimed;
    mapping(address => bool) public _exchanged;

    string private _uri = "https://arweave.net/tGXT29j1OAIPHwJHoxZYA7u9CKPe3ZHSfBWdGZpGx4o/token";
    string private _name = "DUALITY";

    uint256 public _ashPrice = 10*10**18; //10 ASH
    uint256 public _exchangePrice = 5*10**18;
    uint256 private _royaltyAmount; //in % 

    address public _ashContract = 0x64D91f12Ece7362F91A6f8E7940Cd55F05060b92;
    address private _royalties_recipient;
    address private _signer;

    bool public _mintOpened = false;
    bool public _exchangesAllowed = false;

    
    constructor () ERC1155("") {
        _royalties_recipient = payable(msg.sender);
        _royaltyAmount = 10;
    } 

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC1155, AdminControl)
        returns (bool)
    {
        return
        AdminControl.supportsInterface(interfaceId) ||
        ERC1155.supportsInterface(interfaceId) ||
        interfaceId == type(IEIP2981).interfaceId ||
        super.supportsInterface(interfaceId);
    }

    function mintAllowed(uint256 quantity, uint256 ALNumber, uint8 v, bytes32 r, bytes32 s)internal view returns(bool){
        return(
            _signer ==
                ecrecover(
                    keccak256(
                        abi.encodePacked(
                            "\x19Ethereum Signed Message:\n32",
                            keccak256(
                                abi.encodePacked(
                                    msg.sender,
                                    address(this),
                                    _mintOpened,
                                    quantity <= ALNumber,
                                    ALNumber
                                )
                            )
                        )
                    )
                , v, r, s)
        );
    }

    function setSigner (address signer) external adminRequired{
        _signer = signer;
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function publicMint(
        address account,
        uint256[] calldata  tokenIds,
        uint256[] calldata quantities,
        uint256 ALNumber,
        uint8 v,
        bytes32 r, 
        bytes32 s
    ) external {
        uint256 quantity = 0; 
        for(uint256 i = 0 ; i < quantities.length; i++){
            quantity += quantities[i];
        }
        require(mintAllowed(quantity, ALNumber, v, r, s), "Mint not allowed");
        require(_tokensClaimed[account] + quantity <= ALNumber, "Cannot mint more than allowed number of tokens");
        IERC20(_ashContract).transferFrom(msg.sender, _royalties_recipient, _ashPrice * quantity);
        _mintBatch(account ,tokenIds ,quantities ,"0x00");
        _tokensClaimed[account] = _tokensClaimed[account] + quantity;
    }

    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts
    )external adminRequired{
        _mintBatch(to, ids, amounts, "0x0");
    }

    function setExchangePrice(uint256 newPrice) external adminRequired{
        _exchangePrice = newPrice;
    }

    function toggleMintState()external adminRequired{
        _mintOpened = !_mintOpened;
    }

    function toggleExchangeState()external adminRequired{
        _exchangesAllowed = !_exchangesAllowed;
    }

    function setURI(
        string calldata updatedURI
    ) external adminRequired{
        _uri = updatedURI;
    }

    function uri(uint256 tokenId) public view virtual override returns (string memory) {
        return string(abi.encodePacked(_uri, Strings.toString(tokenId), ".json"));
    }

    function exchange(address account, uint256 token, uint256 newToken) external{
        bool alreadyExchanged = _exchanged[account];
        require(_exchangesAllowed, "Exchange phase closed");
        require(isAdmin(msg.sender) || account == msg.sender,"Cannot exchange another person's token");
        require(balanceOf(account, token)>0, "You do not own this token");
        if(alreadyExchanged){
            IERC20(_ashContract).transferFrom(msg.sender, _royalties_recipient, _exchangePrice);
        }
        _burn(account, token, 1);
        _mint(account, newToken, 1, "0x00");
        if(!alreadyExchanged){
            _exchanged[account] = true;
        }
    }

    function burn(uint256 tokenId, uint256 quantity) public {
        _burn(msg.sender, tokenId, quantity);
    }

    function burnBatch(
        uint256[] memory ids,
        uint256[] memory amounts
    )external{
        _burnBatch(msg.sender, ids, amounts);
    }

    function setRoyalties(address payable _recipient, uint256 _royaltyPerCent) external adminRequired {
        _royalties_recipient = _recipient;
        _royaltyAmount = _royaltyPerCent;
    }

    function royaltyInfo(uint256 salePrice) external view returns (address, uint256) {
        if(_royalties_recipient != address(0)){
            return (_royalties_recipient, (salePrice * _royaltyAmount) / 100 );
        }
        return (address(0), 0);
    }

    function withdraw(address recipient) external adminRequired {
        payable(recipient).transfer(address(this).balance);
    }

}

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":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"AdminApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"AdminRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"_ashContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_ashPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_exchangePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_exchanged","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_exchangesAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintOpened","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_tokensClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"approveAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"newToken","type":"uint256"}],"name":"exchange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAdmins","outputs":[{"internalType":"address[]","name":"admins","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"mintBatch","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":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"quantities","type":"uint256[]"},{"internalType":"uint256","name":"ALNumber","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"publicMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"revokeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setExchangePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_royaltyPerCent","type":"uint256"}],"name":"setRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"updatedURI","type":"string"}],"name":"setURI","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":"toggleExchangeState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleMintState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

6101006040526045608081815290620034e560a03980516200002a9160089160209091019062000162565b50604080518082019091526007808252664455414c49545960c81b60209092019182526200005b9160099162000162565b50678ac7230489e80000600a55674563918244f40000600b55600d80546001600160a01b0319167364d91f12ece7362f91a6f8e7940cd55f05060b92179055600f805461ffff60a01b19169055348015620000b557600080fd5b50604080516020810190915260008152620000d033620000f9565b620000db8162000149565b50600e80546001600160a01b03191633179055600a600c5562000245565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b80516200015e90600390602084019062000162565b5050565b828054620001709062000208565b90600052602060002090601f016020900481019282620001945760008555620001df565b82601f10620001af57805160ff1916838001178555620001df565b82800160010185558215620001df579182015b82811115620001df578251825591602001919060010190620001c2565b50620001ed929150620001f1565b5090565b5b80821115620001ed5760008155600101620001f2565b600181811c908216806200021d57607f821691505b602082108114156200023f57634e487b7160e01b600052602260045260246000fd5b50919050565b61329080620002556000396000f3fe608060405234801561001057600080fd5b506004361061021b5760003560e01c8063715018a611610125578063bc8485a5116100ad578063d81d0a151161007c578063d81d0a15146104be578063debfe14c146104d1578063e985e9c5146104e4578063f242432a14610520578063f2fde38b1461053357600080fd5b8063bc8485a514610445578063c5750d5314610465578063ca5bab2d14610478578063cef6d3681461048c57600080fd5b80638c7ea24b116100f45780638c7ea24b146103df5780638da5cb5b146103f2578063a22cb46514610417578063af83937a1461042a578063b390c0ab1461043257600080fd5b8063715018a6146103a8578063762b16e2146103b057806383ca4b6f146103b95780638aa4e315146103cc57600080fd5b80632eb2c2d6116101a857806351cff8d91161017757806351cff8d9146103435780635c3716721461035657806369fd1aaa1461035f5780636c19e783146103825780636d73e6691461039557600080fd5b80632eb2c2d6146102f357806331ae450b146103065780634e1273f41461031b578063510db75a1461033b57600080fd5b80630e89341c116101ef5780630e89341c1461029357806319981dd1146102a6578063236e06f6146102ba57806324d7806c146102cd5780632d345670146102e057600080fd5b8062fdd58e1461022057806301ffc9a71461024657806302fe53051461026957806306fdde031461027e575b600080fd5b61023361022e366004612493565b610546565b6040519081526020015b60405180910390f35b6102596102543660046124d5565b6105e2565b604051901515815260200161023d565b61027c6102773660046124f2565b610626565b005b610286610681565b60405161023d91906125bb565b6102866102a13660046125ce565b610713565b600f5461025990600160a01b900460ff1681565b61027c6102c83660046125e7565b610747565b6102596102db36600461261c565b610975565b61027c6102ee36600461261c565b6109ae565b61027c610301366004612782565b610a2e565b61030e610ac5565b60405161023d919061282f565b61032e61032936600461287c565b610b73565b60405161023d9190612983565b61027c610c9c565b61027c61035136600461261c565b610d07565b610233600a5481565b61025961036d36600461261c565b60076020526000908152604090205460ff1681565b61027c61039036600461261c565b610d86565b61027c6103a336600461261c565b610df2565b61027c610e6c565b610233600b5481565b61027c6103c7366004612996565b610ea2565b61027c6103da3660046125ce565b610ead565b61027c6103ed366004612493565b610efc565b6000546001600160a01b03165b6040516001600160a01b03909116815260200161023d565b61027c6104253660046129f0565b610f6c565b61027c610f77565b61027c610440366004612a29565b610fe2565b61023361045336600461261c565b60066020526000908152604090205481565b61027c610473366004612a96565b610fed565b600f5461025990600160a81b900460ff1681565b61049f61049a3660046125ce565b611283565b604080516001600160a01b03909316835260208301919091520161023d565b61027c6104cc366004612b4d565b6112d6565b600d546103ff906001600160a01b031681565b6102596104f2366004612bc2565b6001600160a01b03918216600090815260026020908152604080832093909416825291909152205460ff1690565b61027c61052e366004612bf0565b611347565b61027c61054136600461261c565b6113ce565b60006001600160a01b0383166105b75760405162461bcd60e51b815260206004820152602b60248201527f455243313135353a2062616c616e636520717565727920666f7220746865207a60448201526a65726f206164647265737360a81b60648201526084015b60405180910390fd5b5060008181526001602090815260408083206001600160a01b03861684529091529020545b92915050565b60006105ed82611466565b806105fc57506105fc82611487565b8061061757506001600160e01b0319821663152a902d60e11b145b806105dc57506105dc82611466565b336106396000546001600160a01b031690565b6001600160a01b0316148061065457506106546004336114d7565b6106705760405162461bcd60e51b81526004016105ae90612c58565b61067c600883836123ee565b505050565b60606009805461069090612c9c565b80601f01602080910402602001604051908101604052809291908181526020018280546106bc90612c9c565b80156107095780601f106106de57610100808354040283529160200191610709565b820191906000526020600020905b8154815290600101906020018083116106ec57829003601f168201915b5050505050905090565b60606008610720836114fc565b604051602001610731929190612cf3565b6040516020818303038152906040529050919050565b6001600160a01b038316600090815260076020526040902054600f5460ff91821691600160a81b909104166107b65760405162461bcd60e51b8152602060048201526015602482015274115e18da185b99d9481c1a185cd94818db1bdcd959605a1b60448201526064016105ae565b6107bf33610975565b806107d257506001600160a01b03841633145b61082d5760405162461bcd60e51b815260206004820152602660248201527f43616e6e6f742065786368616e676520616e6f7468657220706572736f6e2773604482015265103a37b5b2b760d11b60648201526084016105ae565b60006108398585610546565b116108865760405162461bcd60e51b815260206004820152601960248201527f596f7520646f206e6f74206f776e207468697320746f6b656e0000000000000060448201526064016105ae565b801561091157600d54600e54600b546040516323b872dd60e01b81523360048201526001600160a01b03928316602482015260448101919091529116906323b872dd906064016020604051808303816000875af11580156108eb573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061090f9190612dae565b505b61091d84846001611601565b61094684836001604051806040016040528060048152602001630307830360e41b81525061170d565b8061096f576001600160a01b0384166000908152600760205260409020805460ff191660011790555b50505050565b6000816001600160a01b03166109936000546001600160a01b031690565b6001600160a01b031614806105dc57506105dc6004836114d7565b6000546001600160a01b031633146109d85760405162461bcd60e51b81526004016105ae90612dcb565b6109e36004826114d7565b15610a2b5760405133906001600160a01b038316907f7c0c3c84c67c85fcac635147348bfe374c24a1a93d0366d1cfe9d8853cbf89d590600090a3610a296004826117e0565b505b50565b6001600160a01b038516331480610a4a5750610a4a85336104f2565b610ab15760405162461bcd60e51b815260206004820152603260248201527f455243313135353a207472616e736665722063616c6c6572206973206e6f74206044820152711bdddb995c881b9bdc88185c1c1c9bdd995960721b60648201526084016105ae565b610abe85858585856117f5565b5050505050565b6060610ad16004611994565b6001600160401b03811115610ae857610ae8612639565b604051908082528060200260200182016040528015610b11578160200160208202803683370190505b50905060005b610b216004611994565b811015610b6f57610b3360048261199e565b828281518110610b4557610b45612e00565b6001600160a01b039092166020928302919091019091015280610b6781612e2c565b915050610b17565b5090565b60608151835114610bd85760405162461bcd60e51b815260206004820152602960248201527f455243313135353a206163636f756e747320616e6420696473206c656e677468604482015268040dad2e6dac2e8c6d60bb1b60648201526084016105ae565b600083516001600160401b03811115610bf357610bf3612639565b604051908082528060200260200182016040528015610c1c578160200160208202803683370190505b50905060005b8451811015610c9457610c67858281518110610c4057610c40612e00565b6020026020010151858381518110610c5a57610c5a612e00565b6020026020010151610546565b828281518110610c7957610c79612e00565b6020908102919091010152610c8d81612e2c565b9050610c22565b509392505050565b33610caf6000546001600160a01b031690565b6001600160a01b03161480610cca5750610cca6004336114d7565b610ce65760405162461bcd60e51b81526004016105ae90612c58565b600f805460ff60a01b198116600160a01b9182900460ff1615909102179055565b33610d1a6000546001600160a01b031690565b6001600160a01b03161480610d355750610d356004336114d7565b610d515760405162461bcd60e51b81526004016105ae90612c58565b6040516001600160a01b038216904780156108fc02916000818181858888f19350505050158015610a29573d6000803e3d6000fd5b33610d996000546001600160a01b031690565b6001600160a01b03161480610db45750610db46004336114d7565b610dd05760405162461bcd60e51b81526004016105ae90612c58565b600f80546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b03163314610e1c5760405162461bcd60e51b81526004016105ae90612dcb565b610e276004826114d7565b610a2b5760405133906001600160a01b038316907f7e1a1a08d52e4ba0e21554733d66165fd5151f99460116223d9e3a608eec5cb190600090a3610a296004826119aa565b6000546001600160a01b03163314610e965760405162461bcd60e51b81526004016105ae90612dcb565b610ea060006119bf565b565b610a29338383611a0f565b33610ec06000546001600160a01b031690565b6001600160a01b03161480610edb5750610edb6004336114d7565b610ef75760405162461bcd60e51b81526004016105ae90612c58565b600b55565b33610f0f6000546001600160a01b031690565b6001600160a01b03161480610f2a5750610f2a6004336114d7565b610f465760405162461bcd60e51b81526004016105ae90612c58565b600e80546001600160a01b0319166001600160a01b039390931692909217909155600c55565b610a29338383611b9c565b33610f8a6000546001600160a01b031690565b6001600160a01b03161480610fa55750610fa56004336114d7565b610fc15760405162461bcd60e51b81526004016105ae90612c58565b600f805460ff60a81b198116600160a81b9182900460ff1615909102179055565b610a29338383611601565b6000805b868110156110315787878281811061100b5761100b612e00565b905060200201358261101d9190612e47565b91508061102981612e2c565b915050610ff1565b5061103f8186868686611c7d565b61107e5760405162461bcd60e51b815260206004820152601060248201526f135a5b9d081b9bdd08185b1b1bddd95960821b60448201526064016105ae565b6001600160a01b038a1660009081526006602052604090205485906110a4908390612e47565b11156111095760405162461bcd60e51b815260206004820152602e60248201527f43616e6e6f74206d696e74206d6f7265207468616e20616c6c6f776564206e7560448201526d6d626572206f6620746f6b656e7360901b60648201526084016105ae565b600d54600e54600a546001600160a01b03928316926323b872dd923392911690611134908690612e5f565b6040516001600160e01b031960e086901b1681526001600160a01b03938416600482015292909116602483015260448201526064016020604051808303816000875af1158015611188573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111ac9190612dae565b506112378a8a8a8080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050604080516020808e0282810182019093528d82529093508d92508c918291850190849080828437600092019190915250506040805180820190915260048152630307830360e41b60208201529150611da69050565b6001600160a01b038a1660009081526006602052604090205461125b908290612e47565b6001600160a01b03909a16600090815260066020526040902099909955505050505050505050565b600e5460009081906001600160a01b0316156112cb57600e54600c546001600160a01b03909116906064906112b89086612e5f565b6112c29190612e94565b91509150915091565b506000928392509050565b336112e96000546001600160a01b031690565b6001600160a01b0316148061130457506113046004336114d7565b6113205760405162461bcd60e51b81526004016105ae90612c58565b61067c8383836040518060400160405280600381526020016203078360ec1b815250611da6565b6001600160a01b038516331480611363575061136385336104f2565b6113c15760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f7260448201526808185c1c1c9bdd995960ba1b60648201526084016105ae565b610abe8585858585611ef2565b6000546001600160a01b031633146113f85760405162461bcd60e51b81526004016105ae90612dcb565b6001600160a01b03811661145d5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016105ae565b610a2b816119bf565b60006001600160e01b03198216632a9f3abf60e11b14806105dc57506105dc825b60006001600160e01b03198216636cdb3d1360e11b14806114b857506001600160e01b031982166303a24d0760e21b145b806105dc57506301ffc9a760e01b6001600160e01b03198316146105dc565b6001600160a01b038116600090815260018301602052604081205415155b9392505050565b6060816115205750506040805180820190915260018152600360fc1b602082015290565b8160005b811561154a578061153481612e2c565b91506115439050600a83612e94565b9150611524565b6000816001600160401b0381111561156457611564612639565b6040519080825280601f01601f19166020018201604052801561158e576020820181803683370190505b5090505b84156115f9576115a3600183612ea8565b91506115b0600a86612ebf565b6115bb906030612e47565b60f81b8183815181106115d0576115d0612e00565b60200101906001600160f81b031916908160001a9053506115f2600a86612e94565b9450611592565b949350505050565b6001600160a01b0383166116275760405162461bcd60e51b81526004016105ae90612ed3565b33600061163384612020565b9050600061164084612020565b6040805160208082018352600091829052888252600181528282206001600160a01b038b168352905220549091508481101561168e5760405162461bcd60e51b81526004016105ae90612f16565b60008681526001602090815260408083206001600160a01b038b81168086529184528285208a8703905582518b81529384018a90529092908816917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a46040805160208101909152600090525b50505050505050565b6001600160a01b0384166117335760405162461bcd60e51b81526004016105ae90612f5a565b33600061173f85612020565b9050600061174c85612020565b905060008681526001602090815260408083206001600160a01b038b16845290915281208054879290611780908490612e47565b909155505060408051878152602081018790526001600160a01b03808a1692600092918716917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a46117048360008989898961206b565b60006114f5836001600160a01b0384166121c7565b81518351146118165760405162461bcd60e51b81526004016105ae90612f9b565b6001600160a01b03841661183c5760405162461bcd60e51b81526004016105ae90612fe3565b3360005b845181101561192657600085828151811061185d5761185d612e00565b60200260200101519050600085838151811061187b5761187b612e00565b60209081029190910181015160008481526001835260408082206001600160a01b038e1683529093529190912054909150818110156118cc5760405162461bcd60e51b81526004016105ae90613028565b60008381526001602090815260408083206001600160a01b038e8116855292528083208585039055908b1682528120805484929061190b908490612e47565b925050819055505050508061191f90612e2c565b9050611840565b50846001600160a01b0316866001600160a01b0316826001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8787604051611976929190613072565b60405180910390a461198c8187878787876122ba565b505050505050565b60006105dc825490565b60006114f58383612375565b60006114f5836001600160a01b03841661239f565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6001600160a01b038316611a355760405162461bcd60e51b81526004016105ae90612ed3565b8051825114611a565760405162461bcd60e51b81526004016105ae90612f9b565b604080516020810190915260009081905233905b8351811015611b2f576000848281518110611a8757611a87612e00565b602002602001015190506000848381518110611aa557611aa5612e00565b60209081029190910181015160008481526001835260408082206001600160a01b038c168352909352919091205490915081811015611af65760405162461bcd60e51b81526004016105ae90612f16565b60009283526001602090815260408085206001600160a01b038b1686529091529092209103905580611b2781612e2c565b915050611a6a565b5060006001600160a01b0316846001600160a01b0316826001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8686604051611b80929190613072565b60405180910390a460408051602081019091526000905261096f565b816001600160a01b0316836001600160a01b03161415611c105760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2073657474696e6720617070726f76616c20737461747573604482015268103337b91039b2b63360b91b60648201526084016105ae565b6001600160a01b03838116600081815260026020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b600f546040516bffffffffffffffffffffffff1933606090811b8216602084015230901b166034820152600160a01b90910460ff16151560f890811b604883015285871115901b6049820152604a8101859052600090600190606a0160408051601f198184030181529082905280516020918201207f19457468657265756d205369676e6564204d6573736167653a0a33320000000091830191909152603c820152605c0160408051601f198184030181528282528051602091820120600084529083018083525260ff871690820152606081018590526080810184905260a0016020604051602081039080840390855afa158015611d80573d6000803e3d6000fd5b5050604051601f190151600f546001600160a01b03918216911614979650505050505050565b6001600160a01b038416611dcc5760405162461bcd60e51b81526004016105ae90612f5a565b8151835114611ded5760405162461bcd60e51b81526004016105ae90612f9b565b3360005b8451811015611e8a57838181518110611e0c57611e0c612e00565b602002602001015160016000878481518110611e2a57611e2a612e00565b602002602001015181526020019081526020016000206000886001600160a01b03166001600160a01b031681526020019081526020016000206000828254611e729190612e47565b90915550819050611e8281612e2c565b915050611df1565b50846001600160a01b031660006001600160a01b0316826001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8787604051611edb929190613072565b60405180910390a4610abe816000878787876122ba565b6001600160a01b038416611f185760405162461bcd60e51b81526004016105ae90612fe3565b336000611f2485612020565b90506000611f3185612020565b905060008681526001602090815260408083206001600160a01b038c16845290915290205485811015611f765760405162461bcd60e51b81526004016105ae90613028565b60008781526001602090815260408083206001600160a01b038d8116855292528083208985039055908a16825281208054889290611fb5908490612e47565b909155505060408051888152602081018890526001600160a01b03808b16928c821692918816917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a4612015848a8a8a8a8a61206b565b505050505050505050565b6040805160018082528183019092526060916000919060208083019080368337019050509050828160008151811061205a5761205a612e00565b602090810291909101015292915050565b6001600160a01b0384163b1561198c5760405163f23a6e6160e01b81526001600160a01b0385169063f23a6e61906120af9089908990889088908890600401613097565b6020604051808303816000875af19250505080156120ea575060408051601f3d908101601f191682019092526120e7918101906130dc565b60015b612197576120f66130f9565b806308c379a01415612130575061210b613115565b806121165750612132565b8060405162461bcd60e51b81526004016105ae91906125bb565b505b60405162461bcd60e51b815260206004820152603460248201527f455243313135353a207472616e7366657220746f206e6f6e20455243313135356044820152732932b1b2b4bb32b91034b6b83632b6b2b73a32b960611b60648201526084016105ae565b6001600160e01b0319811663f23a6e6160e01b146117045760405162461bcd60e51b81526004016105ae9061319e565b600081815260018301602052604081205480156122b05760006121eb600183612ea8565b85549091506000906121ff90600190612ea8565b905081811461226457600086600001828154811061221f5761221f612e00565b906000526020600020015490508087600001848154811061224257612242612e00565b6000918252602080832090910192909255918252600188019052604090208390555b8554869080612275576122756131e6565b6001900381819060005260206000200160009055905585600101600086815260200190815260200160002060009055600193505050506105dc565b60009150506105dc565b6001600160a01b0384163b1561198c5760405163bc197c8160e01b81526001600160a01b0385169063bc197c81906122fe90899089908890889088906004016131fc565b6020604051808303816000875af1925050508015612339575060408051601f3d908101601f19168201909252612336918101906130dc565b60015b612345576120f66130f9565b6001600160e01b0319811663bc197c8160e01b146117045760405162461bcd60e51b81526004016105ae9061319e565b600082600001828154811061238c5761238c612e00565b9060005260206000200154905092915050565b60008181526001830160205260408120546123e6575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556105dc565b5060006105dc565b8280546123fa90612c9c565b90600052602060002090601f01602090048101928261241c5760008555612462565b82601f106124355782800160ff19823516178555612462565b82800160010185558215612462579182015b82811115612462578235825591602001919060010190612447565b50610b6f9291505b80821115610b6f576000815560010161246a565b6001600160a01b0381168114610a2b57600080fd5b600080604083850312156124a657600080fd5b82356124b18161247e565b946020939093013593505050565b6001600160e01b031981168114610a2b57600080fd5b6000602082840312156124e757600080fd5b81356114f5816124bf565b6000806020838503121561250557600080fd5b82356001600160401b038082111561251c57600080fd5b818501915085601f83011261253057600080fd5b81358181111561253f57600080fd5b86602082850101111561255157600080fd5b60209290920196919550909350505050565b60005b8381101561257e578181015183820152602001612566565b8381111561096f5750506000910152565b600081518084526125a7816020860160208601612563565b601f01601f19169290920160200192915050565b6020815260006114f5602083018461258f565b6000602082840312156125e057600080fd5b5035919050565b6000806000606084860312156125fc57600080fd5b83356126078161247e565b95602085013595506040909401359392505050565b60006020828403121561262e57600080fd5b81356114f58161247e565b634e487b7160e01b600052604160045260246000fd5b601f8201601f191681016001600160401b038111828210171561267457612674612639565b6040525050565b60006001600160401b0382111561269457612694612639565b5060051b60200190565b600082601f8301126126af57600080fd5b813560206126bc8261267b565b6040516126c9828261264f565b83815260059390931b85018201928281019150868411156126e957600080fd5b8286015b8481101561270457803583529183019183016126ed565b509695505050505050565b600082601f83011261272057600080fd5b81356001600160401b0381111561273957612739612639565b604051612750601f8301601f19166020018261264f565b81815284602083860101111561276557600080fd5b816020850160208301376000918101602001919091529392505050565b600080600080600060a0868803121561279a57600080fd5b85356127a58161247e565b945060208601356127b58161247e565b935060408601356001600160401b03808211156127d157600080fd5b6127dd89838a0161269e565b945060608801359150808211156127f357600080fd5b6127ff89838a0161269e565b9350608088013591508082111561281557600080fd5b506128228882890161270f565b9150509295509295909350565b6020808252825182820181905260009190848201906040850190845b818110156128705783516001600160a01b03168352928401929184019160010161284b565b50909695505050505050565b6000806040838503121561288f57600080fd5b82356001600160401b03808211156128a657600080fd5b818501915085601f8301126128ba57600080fd5b813560206128c78261267b565b6040516128d4828261264f565b83815260059390931b85018201928281019150898411156128f457600080fd5b948201945b8386101561291b57853561290c8161247e565b825294820194908201906128f9565b9650508601359250508082111561293157600080fd5b5061293e8582860161269e565b9150509250929050565b600081518084526020808501945080840160005b838110156129785781518752958201959082019060010161295c565b509495945050505050565b6020815260006114f56020830184612948565b600080604083850312156129a957600080fd5b82356001600160401b03808211156129c057600080fd5b6129cc8683870161269e565b9350602085013591508082111561293157600080fd5b8015158114610a2b57600080fd5b60008060408385031215612a0357600080fd5b8235612a0e8161247e565b91506020830135612a1e816129e2565b809150509250929050565b60008060408385031215612a3c57600080fd5b50508035926020909101359150565b60008083601f840112612a5d57600080fd5b5081356001600160401b03811115612a7457600080fd5b6020830191508360208260051b8501011115612a8f57600080fd5b9250929050565b600080600080600080600080600060e08a8c031215612ab457600080fd5b8935612abf8161247e565b985060208a01356001600160401b0380821115612adb57600080fd5b612ae78d838e01612a4b565b909a50985060408c0135915080821115612b0057600080fd5b50612b0d8c828d01612a4b565b90975095505060608a0135935060808a013560ff81168114612b2e57600080fd5b8093505060a08a0135915060c08a013590509295985092959850929598565b600080600060608486031215612b6257600080fd5b8335612b6d8161247e565b925060208401356001600160401b0380821115612b8957600080fd5b612b958783880161269e565b93506040860135915080821115612bab57600080fd5b50612bb88682870161269e565b9150509250925092565b60008060408385031215612bd557600080fd5b8235612be08161247e565b91506020830135612a1e8161247e565b600080600080600060a08688031215612c0857600080fd5b8535612c138161247e565b94506020860135612c238161247e565b9350604086013592506060860135915060808601356001600160401b03811115612c4c57600080fd5b6128228882890161270f565b60208082526024908201527f41646d696e436f6e74726f6c3a204d757374206265206f776e6572206f7220616040820152633236b4b760e11b606082015260800190565b600181811c90821680612cb057607f821691505b60208210811415612cd157634e487b7160e01b600052602260045260246000fd5b50919050565b60008151612ce9818560208601612563565b9290920192915050565b600080845481600182811c915080831680612d0f57607f831692505b6020808410821415612d2f57634e487b7160e01b86526022600452602486fd5b818015612d435760018114612d5457612d81565b60ff19861689528489019650612d81565b60008b81526020902060005b86811015612d795781548b820152908501908301612d60565b505084890196505b505050505050612da5612d948286612cd7565b64173539b7b760d91b815260050190565b95945050505050565b600060208284031215612dc057600080fd5b81516114f5816129e2565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b6000600019821415612e4057612e40612e16565b5060010190565b60008219821115612e5a57612e5a612e16565b500190565b6000816000190483118215151615612e7957612e79612e16565b500290565b634e487b7160e01b600052601260045260246000fd5b600082612ea357612ea3612e7e565b500490565b600082821015612eba57612eba612e16565b500390565b600082612ece57612ece612e7e565b500690565b60208082526023908201527f455243313135353a206275726e2066726f6d20746865207a65726f206164647260408201526265737360e81b606082015260800190565b60208082526024908201527f455243313135353a206275726e20616d6f756e7420657863656564732062616c604082015263616e636560e01b606082015260800190565b60208082526021908201527f455243313135353a206d696e7420746f20746865207a65726f206164647265736040820152607360f81b606082015260800190565b60208082526028908201527f455243313135353a2069647320616e6420616d6f756e7473206c656e677468206040820152670dad2e6dac2e8c6d60c31b606082015260800190565b60208082526025908201527f455243313135353a207472616e7366657220746f20746865207a65726f206164604082015264647265737360d81b606082015260800190565b6020808252602a908201527f455243313135353a20696e73756666696369656e742062616c616e636520666f60408201526939103a3930b739b332b960b11b606082015260800190565b6040815260006130856040830185612948565b8281036020840152612da58185612948565b6001600160a01b03868116825285166020820152604081018490526060810183905260a0608082018190526000906130d19083018461258f565b979650505050505050565b6000602082840312156130ee57600080fd5b81516114f5816124bf565b600060033d11156131125760046000803e5060005160e01c5b90565b600060443d10156131235790565b6040516003193d81016004833e81513d6001600160401b03816024840111818411171561315257505050505090565b828501915081518181111561316a5750505050505090565b843d87010160208285010111156131845750505050505090565b6131936020828601018761264f565b509095945050505050565b60208082526028908201527f455243313135353a204552433131353552656365697665722072656a656374656040820152676420746f6b656e7360c01b606082015260800190565b634e487b7160e01b600052603160045260246000fd5b6001600160a01b0386811682528516602082015260a06040820181905260009061322890830186612948565b828103606084015261323a8186612948565b9050828103608084015261324e818561258f565b9897505050505050505056fea2646970667358221220299a7b1d9f772b80b35c98898c44d6aa9eaa036e03e2216eaa7a1be799a08ad564736f6c634300080c003368747470733a2f2f617277656176652e6e65742f7447585432396a314f41495048774a486f785a5941377539434b5065335a485366425764475a704778346f2f746f6b656e

Deployed Bytecode

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

Deployed Bytecode Sourcemap

59840:5491:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44380:231;;;;;;:::i;:::-;;:::i;:::-;;;616:25:1;;;604:2;589:18;44380:231:0;;;;;;;;60660:396;;;;;;:::i;:::-;;:::i;:::-;;;1203:14:1;;1196:22;1178:41;;1166:2;1151:18;60660:396:0;1038:187:1;63441:118:0;;;;;;:::i;:::-;;:::i;:::-;;62007:83;;;:::i;:::-;;;;;;;:::i;63567:175::-;;;;;;:::i;:::-;;:::i;60443:31::-;;;;;-1:-1:-1;;;60443:31:0;;;;;;63750:686;;;;;;:::i;:::-;;:::i;34714:139::-;;;;;;:::i;:::-;;:::i;34436:210::-;;;;;;:::i;:::-;;:::i;46319:442::-;;;;;;:::i;:::-;;:::i;33814:267::-;;;:::i;:::-;;;;;;;:::i;44777:524::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;63223:93::-;;;:::i;65197:129::-;;;;;;:::i;:::-;;:::i;60143:36::-;;;;;;59951:42;;;;;;:::i;:::-;;;;;;;;;;;;;;;;61906:93;;;;;;:::i;:::-;;:::i;34154:210::-;;;;;;:::i;:::-;;:::i;20628:103::-;;;:::i;60195:40::-;;;;;;64563:154;;;;;;:::i;:::-;;:::i;63105:110::-;;;;;;:::i;:::-;;:::i;64725:193::-;;;;;;:::i;:::-;;:::i;19977:87::-;20023:7;20050:6;-1:-1:-1;;;;;20050:6:0;19977:87;;;-1:-1:-1;;;;;10107:32:1;;;10089:51;;10077:2;10062:18;19977:87:0;9943:203:1;45374:155:0;;;;;;:::i;:::-;;:::i;63324:109::-;;;:::i;64444:111::-;;;;;;:::i;:::-;;:::i;59895:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;62098:803;;;;;;:::i;:::-;;:::i;60481:37::-;;;;;-1:-1:-1;;;60481:37:0;;;;;;64926:263;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;12764:32:1;;;12746:51;;12828:2;12813:18;;12806:34;;;;12719:18;64926:263:0;12572:274:1;62909:188:0;;;;;;:::i;:::-;;:::i;60289:72::-;;;;;-1:-1:-1;;;;;60289:72:0;;;45601:168;;;;;;:::i;:::-;-1:-1:-1;;;;;45724:27:0;;;45700:4;45724:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;45601:168;45841:401;;;;;;:::i;:::-;;:::i;20886:201::-;;;;;;:::i;:::-;;:::i;44380:231::-;44466:7;-1:-1:-1;;;;;44494:21:0;;44486:77;;;;-1:-1:-1;;;44486:77:0;;14920:2:1;44486:77:0;;;14902:21:1;14959:2;14939:18;;;14932:30;14998:34;14978:18;;;14971:62;-1:-1:-1;;;15049:18:1;;;15042:41;15100:19;;44486:77:0;;;;;;;;;-1:-1:-1;44581:13:0;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;44581:22:0;;;;;;;;;;44380:231;;;;;:::o;60660:396::-;60813:4;60851:43;60882:11;60851:30;:43::i;:::-;:94;;;;60907:38;60933:11;60907:25;:38::i;:::-;60851:148;;;-1:-1:-1;;;;;;;60958:41:0;;-1:-1:-1;;;60958:41:0;60851:148;:197;;;;61012:36;61036:11;61012:23;:36::i;63441:118::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;63534:17:::1;:4;63541:10:::0;;63534:17:::1;:::i;:::-;;63441:118:::0;;:::o;62007:83::-;62044:13;62077:5;62070:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62007:83;:::o;63567:175::-;63635:13;63692:4;63698:25;63715:7;63698:16;:25::i;:::-;63675:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63661:73;;63567:175;;;:::o;63750:686::-;-1:-1:-1;;;;;63861:19:0;;63837:21;63861:19;;;:10;:19;;;;;;63899:17;;63861:19;;;;;-1:-1:-1;;;63899:17:0;;;;63891:51;;;;-1:-1:-1;;;63891:51:0;;17862:2:1;63891:51:0;;;17844:21:1;17901:2;17881:18;;;17874:30;-1:-1:-1;;;17920:18:1;;;17913:51;17981:18;;63891:51:0;17660:345:1;63891:51:0;63961:19;63969:10;63961:7;:19::i;:::-;:44;;;-1:-1:-1;;;;;;63984:21:0;;63995:10;63984:21;63961:44;63953:94;;;;-1:-1:-1;;;63953:94:0;;18212:2:1;63953:94:0;;;18194:21:1;18251:2;18231:18;;;18224:30;18290:34;18270:18;;;18263:62;-1:-1:-1;;;18341:18:1;;;18334:36;18387:19;;63953:94:0;18010:402:1;63953:94:0;64092:1;64066:25;64076:7;64085:5;64066:9;:25::i;:::-;:27;64058:65;;;;-1:-1:-1;;;64058:65:0;;18619:2:1;64058:65:0;;;18601:21:1;18658:2;18638:18;;;18631:30;18697:27;18677:18;;;18670:55;18742:18;;64058:65:0;18417:349:1;64058:65:0;64137:16;64134:130;;;64176:12;;64215:20;;64237:14;;64169:83;;-1:-1:-1;;;64169:83:0;;64203:10;64169:83;;;19011:34:1;-1:-1:-1;;;;;64215:20:0;;;19061:18:1;;;19054:43;19113:18;;;19106:34;;;;64176:12:0;;;64169:33;;18946:18:1;;64169:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64134:130;64274:24;64280:7;64289:5;64296:1;64274:5;:24::i;:::-;64309:35;64315:7;64324:8;64334:1;64309:35;;;;;;;;;;;;;-1:-1:-1;;;64309:35:0;;;:5;:35::i;:::-;64359:16;64355:74;;-1:-1:-1;;;;;64391:19:0;;;;;;:10;:19;;;;;:26;;-1:-1:-1;;64391:26:0;64413:4;64391:26;;;64355:74;63826:610;63750:686;;;:::o;34714:139::-;34776:4;34812:5;-1:-1:-1;;;;;34801:16:0;:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;34801:7;-1:-1:-1;;;;;34801:16:0;;:43;;;-1:-1:-1;34821:23:0;:7;34838:5;34821:16;:23::i;34436:210::-;20023:7;20050:6;-1:-1:-1;;;;;20050:6:0;18781:10;20197:23;20189:68;;;;-1:-1:-1;;;20189:68:0;;;;;;;:::i;:::-;34515:23:::1;:7;34532:5:::0;34515:16:::1;:23::i;:::-;34511:128;;;34560:31;::::0;34580:10:::1;::::0;-1:-1:-1;;;;;34560:31:0;::::1;::::0;::::1;::::0;;;::::1;34606:21;:7;34621:5:::0;34606:14:::1;:21::i;:::-;;34511:128;34436:210:::0;:::o;46319:442::-;-1:-1:-1;;;;;46552:20:0;;18781:10;46552:20;;:60;;-1:-1:-1;46576:36:0;46593:4;18781:10;45601:168;:::i;46576:36::-;46530:160;;;;-1:-1:-1;;;46530:160:0;;19964:2:1;46530:160:0;;;19946:21:1;20003:2;19983:18;;;19976:30;20042:34;20022:18;;;20015:62;-1:-1:-1;;;20093:18:1;;;20086:48;20151:19;;46530:160:0;19762:414:1;46530:160:0;46701:52;46724:4;46730:2;46734:3;46739:7;46748:4;46701:22;:52::i;:::-;46319:442;;;;;:::o;33814:267::-;33867:23;33926:16;:7;:14;:16::i;:::-;-1:-1:-1;;;;;33912:31:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33912:31:0;;33903:40;;33959:6;33954:96;33975:16;:7;:14;:16::i;:::-;33971:1;:20;33954:96;;;34025:13;:7;34036:1;34025:10;:13::i;:::-;34013:6;34020:1;34013:9;;;;;;;;:::i;:::-;-1:-1:-1;;;;;34013:25:0;;;:9;;;;;;;;;;;:25;33993:3;;;;:::i;:::-;;;;33954:96;;;;33814:267;:::o;44777:524::-;44933:16;44994:3;:10;44975:8;:15;:29;44967:83;;;;-1:-1:-1;;;44967:83:0;;20787:2:1;44967:83:0;;;20769:21:1;20826:2;20806:18;;;20799:30;20865:34;20845:18;;;20838:62;-1:-1:-1;;;20916:18:1;;;20909:39;20965:19;;44967:83:0;20585:405:1;44967:83:0;45063:30;45110:8;:15;-1:-1:-1;;;;;45096:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45096:30:0;;45063:63;;45144:9;45139:122;45163:8;:15;45159:1;:19;45139:122;;;45219:30;45229:8;45238:1;45229:11;;;;;;;;:::i;:::-;;;;;;;45242:3;45246:1;45242:6;;;;;;;;:::i;:::-;;;;;;;45219:9;:30::i;:::-;45200:13;45214:1;45200:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;45180:3;;;:::i;:::-;;;45139:122;;;-1:-1:-1;45280:13:0;44777:524;-1:-1:-1;;;44777:524:0:o;63223:93::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;63297:11:::1;::::0;;-1:-1:-1;;;;63282:26:0;::::1;-1:-1:-1::0;;;63297:11:0;;;::::1;;;63296:12;63282:26:::0;;::::1;;::::0;;63223:93::o;65197:129::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;65268:50:::1;::::0;-1:-1:-1;;;;;65268:27:0;::::1;::::0;65296:21:::1;65268:50:::0;::::1;;;::::0;::::1;::::0;;;65296:21;65268:27;:50;::::1;;;;;;;;;;;;;::::0;::::1;;;;61906:93:::0;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;61975:7:::1;:16:::0;;-1:-1:-1;;;;;;61975:16:0::1;-1:-1:-1::0;;;;;61975:16:0;;;::::1;::::0;;;::::1;::::0;;61906:93::o;34154:210::-;20023:7;20050:6;-1:-1:-1;;;;;20050:6:0;18781:10;20197:23;20189:68;;;;-1:-1:-1;;;20189:68:0;;;;;;;:::i;:::-;34235:23:::1;:7;34252:5:::0;34235:16:::1;:23::i;:::-;34230:127;;34280:32;::::0;34301:10:::1;::::0;-1:-1:-1;;;;;34280:32:0;::::1;::::0;::::1;::::0;;;::::1;34327:18;:7;34339:5:::0;34327:11:::1;:18::i;20628:103::-:0;20023:7;20050:6;-1:-1:-1;;;;;20050:6:0;18781:10;20197:23;20189:68;;;;-1:-1:-1;;;20189:68:0;;;;;;;:::i;:::-;20693:30:::1;20720:1;20693:18;:30::i;:::-;20628:103::o:0;64563:154::-;64673:36;64684:10;64696:3;64701:7;64673:10;:36::i;63105:110::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;63182:14:::1;:25:::0;63105:110::o;64725:193::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;64834:20:::1;:33:::0;;-1:-1:-1;;;;;;64834:33:0::1;-1:-1:-1::0;;;;;64834:33:0;;;::::1;::::0;;;::::1;::::0;;;64878:14:::1;:32:::0;64725:193::o;45374:155::-;45469:52;18781:10;45502:8;45512;45469:18;:52::i;63324:109::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;63408:17:::1;::::0;;-1:-1:-1;;;;63387:38:0;::::1;-1:-1:-1::0;;;63408:17:0;;;::::1;;;63407:18;63387:38:::0;;::::1;;::::0;;63324:109::o;64444:111::-;64511:36;64517:10;64529:7;64538:8;64511:5;:36::i;62098:803::-;62336:16;62372:9;62368:99;62388:21;;;62368:99;;;62442:10;;62453:1;62442:13;;;;;;;:::i;:::-;;;;;;;62430:25;;;;;:::i;:::-;;-1:-1:-1;62411:3:0;;;;:::i;:::-;;;;62368:99;;;;62485:40;62497:8;62507;62517:1;62520;62523;62485:11;:40::i;:::-;62477:69;;;;-1:-1:-1;;;62477:69:0;;21330:2:1;62477:69:0;;;21312:21:1;21369:2;21349:18;;;21342:30;-1:-1:-1;;;21388:18:1;;;21381:46;21444:18;;62477:69:0;21128:340:1;62477:69:0;-1:-1:-1;;;;;62565:23:0;;;;;;:14;:23;;;;;;62603:8;;62565:34;;62591:8;;62565:34;:::i;:::-;:46;;62557:105;;;;-1:-1:-1;;;62557:105:0;;21675:2:1;62557:105:0;;;21657:21:1;21714:2;21694:18;;;21687:30;21753:34;21733:18;;;21726:62;-1:-1:-1;;;21804:18:1;;;21797:44;21858:19;;62557:105:0;21473:410:1;62557:105:0;62680:12;;62719:20;;62741:9;;-1:-1:-1;;;;;62680:12:0;;;;62673:33;;62707:10;;62719:20;;;62741;;62753:8;;62741:20;:::i;:::-;62673:89;;-1:-1:-1;;;;;;62673:89:0;;;;;;;-1:-1:-1;;;;;19029:15:1;;;62673:89:0;;;19011:34:1;19081:15;;;;19061:18;;;19054:43;19113:18;;;19106:34;18946:18;;62673:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;62773:49;62784:7;62793:8;;62773:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;62773:49:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62803:10:0;;-1:-1:-1;62803:10:0;;;;62773:49;;;62803:10;;62773:49;62803:10;62773:49;;;;;;;;;-1:-1:-1;;62773:49:0;;;;;;;;;;;;-1:-1:-1;;;62773:49:0;;;;;-1:-1:-1;62773:10:0;;-1:-1:-1;62773:49:0:i;:::-;-1:-1:-1;;;;;62859:23:0;;;;;;:14;:23;;;;;;:34;;62885:8;;62859:34;:::i;:::-;-1:-1:-1;;;;;62833:23:0;;;;;;;:14;:23;;;;;:60;;;;-1:-1:-1;;;;;;;;;62098:803:0:o;64926:263::-;65021:20;;64989:7;;;;-1:-1:-1;;;;;65021:20:0;:34;65018:131;;65079:20;;65114:14;;-1:-1:-1;;;;;65079:20:0;;;;65132:3;;65102:26;;:9;:26;:::i;:::-;65101:34;;;;:::i;:::-;65071:66;;;;64926:263;;;:::o;65018:131::-;-1:-1:-1;65175:1:0;;;;-1:-1:-1;64926:263:0;-1:-1:-1;64926:263:0:o;62909:188::-;33638:10;33627:7;20023;20050:6;-1:-1:-1;;;;;20050:6:0;;19977:87;33627:7;-1:-1:-1;;;;;33627:21:0;;:53;;;-1:-1:-1;33652:28:0;:7;33669:10;33652:16;:28::i;:::-;33619:102;;;;-1:-1:-1;;;33619:102:0;;;;;;;:::i;:::-;63054:35:::1;63065:2;63069:3;63074:7;63054:35;;;;;;;;;;;;;-1:-1:-1::0;;;63054:35:0::1;;::::0;:10:::1;:35::i;45841:401::-:0;-1:-1:-1;;;;;46049:20:0;;18781:10;46049:20;;:60;;-1:-1:-1;46073:36:0;46090:4;18781:10;45601:168;:::i;46073:36::-;46027:151;;;;-1:-1:-1;;;46027:151:0;;22520:2:1;46027:151:0;;;22502:21:1;22559:2;22539:18;;;22532:30;22598:34;22578:18;;;22571:62;-1:-1:-1;;;22649:18:1;;;22642:39;22698:19;;46027:151:0;22318:405:1;46027:151:0;46189:45;46207:4;46213:2;46217;46221:6;46229:4;46189:17;:45::i;20886:201::-;20023:7;20050:6;-1:-1:-1;;;;;20050:6:0;18781:10;20197:23;20189:68;;;;-1:-1:-1;;;20189:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20975:22:0;::::1;20967:73;;;::::0;-1:-1:-1;;;20967:73:0;;22930:2:1;20967:73:0::1;::::0;::::1;22912:21:1::0;22969:2;22949:18;;;22942:30;23008:34;22988:18;;;22981:62;-1:-1:-1;;;23059:18:1;;;23052:36;23105:19;;20967:73:0::1;22728:402:1::0;20967:73:0::1;21051:28;21070:8;21051:18;:28::i;33252:233::-:0;33354:4;-1:-1:-1;;;;;;33378:46:0;;-1:-1:-1;;;33378:46:0;;:99;;;33441:36;33465:11;43403:310;43505:4;-1:-1:-1;;;;;;43542:41:0;;-1:-1:-1;;;43542:41:0;;:110;;-1:-1:-1;;;;;;;43600:52:0;;-1:-1:-1;;;43600:52:0;43542:110;:163;;;-1:-1:-1;;;;;;;;;;32808:40:0;;;43669:36;32699:157;10618:167;-1:-1:-1;;;;;10752:23:0;;10698:4;6154:19;;;:12;;;:19;;;;;;:24;;10722:55;10715:62;10618:167;-1:-1:-1;;;10618:167:0:o;400:723::-;456:13;677:10;673:53;;-1:-1:-1;;704:10:0;;;;;;;;;;;;-1:-1:-1;;;704:10:0;;;;;400:723::o;673:53::-;751:5;736:12;792:78;799:9;;792:78;;825:8;;;;:::i;:::-;;-1:-1:-1;848:10:0;;-1:-1:-1;856:2:0;848:10;;:::i;:::-;;;792:78;;;880:19;912:6;-1:-1:-1;;;;;902:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;902:17:0;;880:39;;930:154;937:10;;930:154;;964:11;974:1;964:11;;:::i;:::-;;-1:-1:-1;1033:10:0;1041:2;1033:5;:10;:::i;:::-;1020:24;;:2;:24;:::i;:::-;1007:39;;990:6;997;990:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;990:56:0;;;;;;;;-1:-1:-1;1061:11:0;1070:2;1061:11;;:::i;:::-;;;930:154;;;1108:6;400:723;-1:-1:-1;;;;400:723:0:o;53169:808::-;-1:-1:-1;;;;;53296:18:0;;53288:66;;;;-1:-1:-1;;;53288:66:0;;;;;;;:::i;:::-;18781:10;53367:16;53432:21;53450:2;53432:17;:21::i;:::-;53409:44;;53464:24;53491:25;53509:6;53491:17;:25::i;:::-;53529:66;;;;;;;;;-1:-1:-1;53529:66:0;;;;53630:13;;;:9;:13;;;;;-1:-1:-1;;;;;53630:19:0;;;;;;;;53464:52;;-1:-1:-1;53668:21:0;;;;53660:70;;;;-1:-1:-1;;;53660:70:0;;;;;;;:::i;:::-;53766:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;53766:19:0;;;;;;;;;;;;53788:20;;;53766:42;;53837:54;;24365:25:1;;;24406:18;;;24399:34;;;53766:19:0;;53837:54;;;;;;24338:18:1;53837:54:0;;;;;;;53904:65;;;;;;;;;53948:1;53904:65;;;53277:700;;;;53169:808;;;:::o;51021:729::-;-1:-1:-1;;;;;51174:16:0;;51166:62;;;;-1:-1:-1;;;51166:62:0;;;;;;;:::i;:::-;18781:10;51241:16;51306:21;51324:2;51306:17;:21::i;:::-;51283:44;;51338:24;51365:25;51383:6;51365:17;:25::i;:::-;51338:52;;51482:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;51482:17:0;;;;;;;;;:27;;51503:6;;51482:13;:27;;51503:6;;51482:27;:::i;:::-;;;;-1:-1:-1;;51525:52:0;;;24365:25:1;;;24421:2;24406:18;;24399:34;;;-1:-1:-1;;;;;51525:52:0;;;;51558:1;;51525:52;;;;;;24338:18:1;51525:52:0;;;;;;;51668:74;51699:8;51717:1;51721:2;51725;51729:6;51737:4;51668:30;:74::i;10374:158::-;10447:4;10471:53;10479:3;-1:-1:-1;;;;;10499:23:0;;10471:7;:53::i;48557:1146::-;48784:7;:14;48770:3;:10;:28;48762:81;;;;-1:-1:-1;;;48762:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48862:16:0;;48854:66;;;;-1:-1:-1;;;48854:66:0;;;;;;;:::i;:::-;18781:10;48933:16;49050:421;49074:3;:10;49070:1;:14;49050:421;;;49106:10;49119:3;49123:1;49119:6;;;;;;;;:::i;:::-;;;;;;;49106:19;;49140:14;49157:7;49165:1;49157:10;;;;;;;;:::i;:::-;;;;;;;;;;;;49184:19;49206:13;;;:9;:13;;;;;;-1:-1:-1;;;;;49206:19:0;;;;;;;;;;;;49157:10;;-1:-1:-1;49248:21:0;;;;49240:76;;;;-1:-1:-1;;;49240:76:0;;;;;;;:::i;:::-;49360:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;49360:19:0;;;;;;;;;;49382:20;;;49360:42;;49432:17;;;;;;;:27;;49382:20;;49360:13;49432:27;;49382:20;;49432:27;:::i;:::-;;;;;;;;49091:380;;;49086:3;;;;:::i;:::-;;;49050:421;;;;49518:2;-1:-1:-1;;;;;49488:47:0;49512:4;-1:-1:-1;;;;;49488:47:0;49502:8;-1:-1:-1;;;;;49488:47:0;;49522:3;49527:7;49488:47;;;;;;;:::i;:::-;;;;;;;;49620:75;49656:8;49666:4;49672:2;49676:3;49681:7;49690:4;49620:35;:75::i;:::-;48751:952;48557:1146;;;;;:::o;10871:117::-;10934:7;10961:19;10969:3;6355:18;;6272:109;11342:158;11416:7;11467:22;11471:3;11483:5;11467:3;:22::i;10046:152::-;10116:4;10140:50;10145:3;-1:-1:-1;;;;;10165:23:0;;10140:4;:50::i;21247:191::-;21321:16;21340:6;;-1:-1:-1;;;;;21357:17:0;;;-1:-1:-1;;;;;;21357:17:0;;;;;;21390:40;;21340:6;;;;;;;21390:40;;21321:16;21390:40;21310:128;21247:191;:::o;54180:969::-;-1:-1:-1;;;;;54332:18:0;;54324:66;;;;-1:-1:-1;;;54324:66:0;;;;;;;:::i;:::-;54423:7;:14;54409:3;:10;:28;54401:81;;;;-1:-1:-1;;;54401:81:0;;;;;;;:::i;:::-;54539:66;;;;;;;;;54495:16;54539:66;;;;18781:10;;54618:373;54642:3;:10;54638:1;:14;54618:373;;;54674:10;54687:3;54691:1;54687:6;;;;;;;;:::i;:::-;;;;;;;54674:19;;54708:14;54725:7;54733:1;54725:10;;;;;;;;:::i;:::-;;;;;;;;;;;;54752:19;54774:13;;;:9;:13;;;;;;-1:-1:-1;;;;;54774:19:0;;;;;;;;;;;;54725:10;;-1:-1:-1;54816:21:0;;;;54808:70;;;;-1:-1:-1;;;54808:70:0;;;;;;;:::i;:::-;54922:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;54922:19:0;;;;;;;;;;54944:20;;54922:42;;54654:3;;;;:::i;:::-;;;;54618:373;;;;55046:1;-1:-1:-1;;;;;55008:55:0;55032:4;-1:-1:-1;;;;;55008:55:0;55022:8;-1:-1:-1;;;;;55008:55:0;;55050:3;55055:7;55008:55;;;;;;;:::i;:::-;;;;;;;;55076:65;;;;;;;;;55120:1;55076:65;;;48557:1146;55291:331;55446:8;-1:-1:-1;;;;;55437:17:0;:5;-1:-1:-1;;;;;55437:17:0;;;55429:71;;;;-1:-1:-1;;;55429:71:0;;26744:2:1;55429:71:0;;;26726:21:1;26783:2;26763:18;;;26756:30;26822:34;26802:18;;;26795:62;-1:-1:-1;;;26873:18:1;;;26866:39;26922:19;;55429:71:0;26542:405:1;55429:71:0;-1:-1:-1;;;;;55511:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;55511:46:0;;;;;;;;;;55573:41;;1178::1;;;55573::0;;1151:18:1;55573:41:0;;;;;;;55291:331;;;:::o;61064:834::-;61618:11;;61462:308;;-1:-1:-1;;61517:10:0;27251:2:1;27247:15;;;27243:24;;61462:308:0;;;27231:37:1;61574:4:0;27302:15:1;;27298:24;27284:12;;;27277:46;-1:-1:-1;;;61618:11:0;;;;;27369:14:1;27362:22;27357:3;27353:32;;;27339:12;;;27332:54;61668:20:0;;;;27416:32:1;;27402:12;;;27395:54;27465:12;;;27458:28;;;61173:4:0;;61238:641;;27502:12:1;;61462:308:0;;;-1:-1:-1;;61462:308:0;;;;;;;;;;61418:383;;61462:308;61418:383;;;;27767:66:1;61306:522:0;;;27755:79:1;;;;27850:12;;;27843:28;27887:12;;61306:522:0;;;-1:-1:-1;;61306:522:0;;;;;;;;;61270:581;;61306:522;61270:581;;;;61238:641;;;;;;;;;28137:25:1;28210:4;28198:17;;28178:18;;;28171:45;28232:18;;;28225:34;;;28275:18;;;28268:34;;;28109:19;;61238:641:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;61238:641:0;;-1:-1:-1;;61238:641:0;;61210:7;;-1:-1:-1;;;;;61210:669:0;;;:7;;:669;;61064:834;-1:-1:-1;;;;;;;61064:834:0:o;52106:813::-;-1:-1:-1;;;;;52284:16:0;;52276:62;;;;-1:-1:-1;;;52276:62:0;;;;;;;:::i;:::-;52371:7;:14;52357:3;:10;:28;52349:81;;;;-1:-1:-1;;;52349:81:0;;;;;;;:::i;:::-;18781:10;52443:16;52566:103;52590:3;:10;52586:1;:14;52566:103;;;52647:7;52655:1;52647:10;;;;;;;;:::i;:::-;;;;;;;52622:9;:17;52632:3;52636:1;52632:6;;;;;;;;:::i;:::-;;;;;;;52622:17;;;;;;;;;;;:21;52640:2;-1:-1:-1;;;;;52622:21:0;-1:-1:-1;;;;;52622:21:0;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;52602:3:0;;-1:-1:-1;52602:3:0;;;:::i;:::-;;;;52566:103;;;;52722:2;-1:-1:-1;;;;;52686:53:0;52718:1;-1:-1:-1;;;;;52686:53:0;52700:8;-1:-1:-1;;;;;52686:53:0;;52726:3;52731:7;52686:53;;;;;;;:::i;:::-;;;;;;;;52830:81;52866:8;52884:1;52888:2;52892:3;52897:7;52906:4;52830:35;:81::i;47225:974::-;-1:-1:-1;;;;;47413:16:0;;47405:66;;;;-1:-1:-1;;;47405:66:0;;;;;;;:::i;:::-;18781:10;47484:16;47549:21;47567:2;47549:17;:21::i;:::-;47526:44;;47581:24;47608:25;47626:6;47608:17;:25::i;:::-;47581:52;;47719:19;47741:13;;;:9;:13;;;;;;;;-1:-1:-1;;;;;47741:19:0;;;;;;;;;;47779:21;;;;47771:76;;;;-1:-1:-1;;;47771:76:0;;;;;;;:::i;:::-;47883:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;47883:19:0;;;;;;;;;;47905:20;;;47883:42;;47947:17;;;;;;;:27;;47905:20;;47883:13;47947:27;;47905:20;;47947:27;:::i;:::-;;;;-1:-1:-1;;47992:46:0;;;24365:25:1;;;24421:2;24406:18;;24399:34;;;-1:-1:-1;;;;;47992:46:0;;;;;;;;;;;;;;24338:18:1;47992:46:0;;;;;;;48123:68;48154:8;48164:4;48170:2;48174;48178:6;48186:4;48123:30;:68::i;:::-;47394:805;;;;47225:974;;;;;:::o;59555:198::-;59675:16;;;59689:1;59675:16;;;;;;;;;59621;;59650:22;;59675:16;;;;;;;;;;;;-1:-1:-1;59675:16:0;59650:41;;59713:7;59702:5;59708:1;59702:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;59740:5;59555:198;-1:-1:-1;;59555:198:0:o;57982:744::-;-1:-1:-1;;;;;58197:13:0;;22973:19;:23;58193:526;;58233:72;;-1:-1:-1;;;58233:72:0;;-1:-1:-1;;;;;58233:38:0;;;;;:72;;58272:8;;58282:4;;58288:2;;58292:6;;58300:4;;58233:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58233:72:0;;;;;;;;-1:-1:-1;;58233:72:0;;;;;;;;;;;;:::i;:::-;;;58229:479;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;58581:6;58574:14;;-1:-1:-1;;;58574:14:0;;;;;;;;:::i;58229:479::-;;;58630:62;;-1:-1:-1;;;58630:62:0;;30206:2:1;58630:62:0;;;30188:21:1;30245:2;30225:18;;;30218:30;30284:34;30264:18;;;30257:62;-1:-1:-1;;;30335:18:1;;;30328:50;30395:19;;58630:62:0;30004:416:1;58229:479:0;-1:-1:-1;;;;;;58355:55:0;;-1:-1:-1;;;58355:55:0;58351:154;;58435:50;;-1:-1:-1;;;58435:50:0;;;;;;;:::i;4551:1420::-;4617:4;4756:19;;;:12;;;:19;;;;;;4792:15;;4788:1176;;5167:21;5191:14;5204:1;5191:10;:14;:::i;:::-;5240:18;;5167:38;;-1:-1:-1;5220:17:0;;5240:22;;5261:1;;5240:22;:::i;:::-;5220:42;;5296:13;5283:9;:26;5279:405;;5330:17;5350:3;:11;;5362:9;5350:22;;;;;;;;:::i;:::-;;;;;;;;;5330:42;;5504:9;5475:3;:11;;5487:13;5475:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;5589:23;;;:12;;;:23;;;;;:36;;;5279:405;5765:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;5860:3;:12;;:19;5873:5;5860:19;;;;;;;;;;;5853:26;;;5903:4;5896:11;;;;;;;4788:1176;5947:5;5940:12;;;;;58734:813;-1:-1:-1;;;;;58974:13:0;;22973:19;:23;58970:570;;59010:79;;-1:-1:-1;;;59010:79:0;;-1:-1:-1;;;;;59010:43:0;;;;;:79;;59054:8;;59064:4;;59070:3;;59075:7;;59084:4;;59010:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59010:79:0;;;;;;;;-1:-1:-1;;59010:79:0;;;;;;;;;;;;:::i;:::-;;;59006:523;;;;:::i;:::-;-1:-1:-1;;;;;;59171:60:0;;-1:-1:-1;;;59171:60:0;59167:159;;59256:50;;-1:-1:-1;;;59256:50:0;;;;;;;:::i;6735:120::-;6802:7;6829:3;:11;;6841:5;6829:18;;;;;;;;:::i;:::-;;;;;;;;;6822:25;;6735:120;;;;:::o;3961:414::-;4024:4;6154:19;;;:12;;;:19;;;;;;4041:327;;-1:-1:-1;4084:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;4267:18;;4245:19;;;:12;;;:19;;;;;;:40;;;;4300:11;;4041:327;-1:-1:-1;4351:5:0;4344:12;;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:315;218:6;226;279:2;267:9;258:7;254:23;250:32;247:52;;;295:1;292;285:12;247:52;334:9;321:23;353:31;378:5;353:31;:::i;:::-;403:5;455:2;440:18;;;;427:32;;-1:-1:-1;;;150:315:1:o;652:131::-;-1:-1:-1;;;;;;726:32:1;;716:43;;706:71;;773:1;770;763:12;788:245;846:6;899:2;887:9;878:7;874:23;870:32;867:52;;;915:1;912;905:12;867:52;954:9;941:23;973:30;997:5;973:30;:::i;1230:592::-;1301:6;1309;1362:2;1350:9;1341:7;1337:23;1333:32;1330:52;;;1378:1;1375;1368:12;1330:52;1418:9;1405:23;-1:-1:-1;;;;;1488:2:1;1480:6;1477:14;1474:34;;;1504:1;1501;1494:12;1474:34;1542:6;1531:9;1527:22;1517:32;;1587:7;1580:4;1576:2;1572:13;1568:27;1558:55;;1609:1;1606;1599:12;1558:55;1649:2;1636:16;1675:2;1667:6;1664:14;1661:34;;;1691:1;1688;1681:12;1661:34;1736:7;1731:2;1722:6;1718:2;1714:15;1710:24;1707:37;1704:57;;;1757:1;1754;1747:12;1704:57;1788:2;1780:11;;;;;1810:6;;-1:-1:-1;1230:592:1;;-1:-1:-1;;;;1230:592:1:o;1827:258::-;1899:1;1909:113;1923:6;1920:1;1917:13;1909:113;;;1999:11;;;1993:18;1980:11;;;1973:39;1945:2;1938:10;1909:113;;;2040:6;2037:1;2034:13;2031:48;;;-1:-1:-1;;2075:1:1;2057:16;;2050:27;1827:258::o;2090:269::-;2143:3;2181:5;2175:12;2208:6;2203:3;2196:19;2224:63;2280:6;2273:4;2268:3;2264:14;2257:4;2250:5;2246:16;2224:63;:::i;:::-;2341:2;2320:15;-1:-1:-1;;2316:29:1;2307:39;;;;2348:4;2303:50;;2090:269;-1:-1:-1;;2090:269:1:o;2364:231::-;2513:2;2502:9;2495:21;2476:4;2533:56;2585:2;2574:9;2570:18;2562:6;2533:56;:::i;2600:180::-;2659:6;2712:2;2700:9;2691:7;2687:23;2683:32;2680:52;;;2728:1;2725;2718:12;2680:52;-1:-1:-1;2751:23:1;;2600:180;-1:-1:-1;2600:180:1:o;2785:383::-;2862:6;2870;2878;2931:2;2919:9;2910:7;2906:23;2902:32;2899:52;;;2947:1;2944;2937:12;2899:52;2986:9;2973:23;3005:31;3030:5;3005:31;:::i;:::-;3055:5;3107:2;3092:18;;3079:32;;-1:-1:-1;3158:2:1;3143:18;;;3130:32;;2785:383;-1:-1:-1;;;2785:383:1:o;3173:247::-;3232:6;3285:2;3273:9;3264:7;3260:23;3256:32;3253:52;;;3301:1;3298;3291:12;3253:52;3340:9;3327:23;3359:31;3384:5;3359:31;:::i;3425:127::-;3486:10;3481:3;3477:20;3474:1;3467:31;3517:4;3514:1;3507:15;3541:4;3538:1;3531:15;3557:249;3667:2;3648:13;;-1:-1:-1;;3644:27:1;3632:40;;-1:-1:-1;;;;;3687:34:1;;3723:22;;;3684:62;3681:88;;;3749:18;;:::i;:::-;3785:2;3778:22;-1:-1:-1;;3557:249:1:o;3811:183::-;3871:4;-1:-1:-1;;;;;3896:6:1;3893:30;3890:56;;;3926:18;;:::i;:::-;-1:-1:-1;3971:1:1;3967:14;3983:4;3963:25;;3811:183::o;3999:724::-;4053:5;4106:3;4099:4;4091:6;4087:17;4083:27;4073:55;;4124:1;4121;4114:12;4073:55;4160:6;4147:20;4186:4;4209:43;4249:2;4209:43;:::i;:::-;4281:2;4275:9;4293:31;4321:2;4313:6;4293:31;:::i;:::-;4359:18;;;4451:1;4447:10;;;;4435:23;;4431:32;;;4393:15;;;;-1:-1:-1;4475:15:1;;;4472:35;;;4503:1;4500;4493:12;4472:35;4539:2;4531:6;4527:15;4551:142;4567:6;4562:3;4559:15;4551:142;;;4633:17;;4621:30;;4671:12;;;;4584;;4551:142;;;-1:-1:-1;4711:6:1;3999:724;-1:-1:-1;;;;;;3999:724:1:o;4728:555::-;4770:5;4823:3;4816:4;4808:6;4804:17;4800:27;4790:55;;4841:1;4838;4831:12;4790:55;4877:6;4864:20;-1:-1:-1;;;;;4899:2:1;4896:26;4893:52;;;4925:18;;:::i;:::-;4974:2;4968:9;4986:67;5041:2;5022:13;;-1:-1:-1;;5018:27:1;5047:4;5014:38;4968:9;4986:67;:::i;:::-;5077:2;5069:6;5062:18;5123:3;5116:4;5111:2;5103:6;5099:15;5095:26;5092:35;5089:55;;;5140:1;5137;5130:12;5089:55;5204:2;5197:4;5189:6;5185:17;5178:4;5170:6;5166:17;5153:54;5251:1;5227:15;;;5244:4;5223:26;5216:37;;;;5231:6;4728:555;-1:-1:-1;;;4728:555:1:o;5288:1071::-;5442:6;5450;5458;5466;5474;5527:3;5515:9;5506:7;5502:23;5498:33;5495:53;;;5544:1;5541;5534:12;5495:53;5583:9;5570:23;5602:31;5627:5;5602:31;:::i;:::-;5652:5;-1:-1:-1;5709:2:1;5694:18;;5681:32;5722:33;5681:32;5722:33;:::i;:::-;5774:7;-1:-1:-1;5832:2:1;5817:18;;5804:32;-1:-1:-1;;;;;5885:14:1;;;5882:34;;;5912:1;5909;5902:12;5882:34;5935:61;5988:7;5979:6;5968:9;5964:22;5935:61;:::i;:::-;5925:71;;6049:2;6038:9;6034:18;6021:32;6005:48;;6078:2;6068:8;6065:16;6062:36;;;6094:1;6091;6084:12;6062:36;6117:63;6172:7;6161:8;6150:9;6146:24;6117:63;:::i;:::-;6107:73;;6233:3;6222:9;6218:19;6205:33;6189:49;;6263:2;6253:8;6250:16;6247:36;;;6279:1;6276;6269:12;6247:36;;6302:51;6345:7;6334:8;6323:9;6319:24;6302:51;:::i;:::-;6292:61;;;5288:1071;;;;;;;;:::o;6364:658::-;6535:2;6587:21;;;6657:13;;6560:18;;;6679:22;;;6506:4;;6535:2;6758:15;;;;6732:2;6717:18;;;6506:4;6801:195;6815:6;6812:1;6809:13;6801:195;;;6880:13;;-1:-1:-1;;;;;6876:39:1;6864:52;;6971:15;;;;6936:12;;;;6912:1;6830:9;6801:195;;;-1:-1:-1;7013:3:1;;6364:658;-1:-1:-1;;;;;;6364:658:1:o;7027:1277::-;7145:6;7153;7206:2;7194:9;7185:7;7181:23;7177:32;7174:52;;;7222:1;7219;7212:12;7174:52;7262:9;7249:23;-1:-1:-1;;;;;7332:2:1;7324:6;7321:14;7318:34;;;7348:1;7345;7338:12;7318:34;7386:6;7375:9;7371:22;7361:32;;7431:7;7424:4;7420:2;7416:13;7412:27;7402:55;;7453:1;7450;7443:12;7402:55;7489:2;7476:16;7511:4;7534:43;7574:2;7534:43;:::i;:::-;7606:2;7600:9;7618:31;7646:2;7638:6;7618:31;:::i;:::-;7684:18;;;7772:1;7768:10;;;;7760:19;;7756:28;;;7718:15;;;;-1:-1:-1;7796:19:1;;;7793:39;;;7828:1;7825;7818:12;7793:39;7852:11;;;;7872:217;7888:6;7883:3;7880:15;7872:217;;;7968:3;7955:17;7985:31;8010:5;7985:31;:::i;:::-;8029:18;;7905:12;;;;8067;;;;7872:217;;;8108:6;-1:-1:-1;;8152:18:1;;8139:32;;-1:-1:-1;;8183:16:1;;;8180:36;;;8212:1;8209;8202:12;8180:36;;8235:63;8290:7;8279:8;8268:9;8264:24;8235:63;:::i;:::-;8225:73;;;7027:1277;;;;;:::o;8309:435::-;8362:3;8400:5;8394:12;8427:6;8422:3;8415:19;8453:4;8482:2;8477:3;8473:12;8466:19;;8519:2;8512:5;8508:14;8540:1;8550:169;8564:6;8561:1;8558:13;8550:169;;;8625:13;;8613:26;;8659:12;;;;8694:15;;;;8586:1;8579:9;8550:169;;;-1:-1:-1;8735:3:1;;8309:435;-1:-1:-1;;;;;8309:435:1:o;8749:261::-;8928:2;8917:9;8910:21;8891:4;8948:56;9000:2;8989:9;8985:18;8977:6;8948:56;:::i;9015:595::-;9133:6;9141;9194:2;9182:9;9173:7;9169:23;9165:32;9162:52;;;9210:1;9207;9200:12;9162:52;9250:9;9237:23;-1:-1:-1;;;;;9320:2:1;9312:6;9309:14;9306:34;;;9336:1;9333;9326:12;9306:34;9359:61;9412:7;9403:6;9392:9;9388:22;9359:61;:::i;:::-;9349:71;;9473:2;9462:9;9458:18;9445:32;9429:48;;9502:2;9492:8;9489:16;9486:36;;;9518:1;9515;9508:12;10151:118;10237:5;10230:13;10223:21;10216:5;10213:32;10203:60;;10259:1;10256;10249:12;10274:382;10339:6;10347;10400:2;10388:9;10379:7;10375:23;10371:32;10368:52;;;10416:1;10413;10406:12;10368:52;10455:9;10442:23;10474:31;10499:5;10474:31;:::i;:::-;10524:5;-1:-1:-1;10581:2:1;10566:18;;10553:32;10594:30;10553:32;10594:30;:::i;:::-;10643:7;10633:17;;;10274:382;;;;;:::o;10661:248::-;10729:6;10737;10790:2;10778:9;10769:7;10765:23;10761:32;10758:52;;;10806:1;10803;10796:12;10758:52;-1:-1:-1;;10829:23:1;;;10899:2;10884:18;;;10871:32;;-1:-1:-1;10661:248:1:o;10914:367::-;10977:8;10987:6;11041:3;11034:4;11026:6;11022:17;11018:27;11008:55;;11059:1;11056;11049:12;11008:55;-1:-1:-1;11082:20:1;;-1:-1:-1;;;;;11114:30:1;;11111:50;;;11157:1;11154;11147:12;11111:50;11194:4;11186:6;11182:17;11170:29;;11254:3;11247:4;11237:6;11234:1;11230:14;11222:6;11218:27;11214:38;11211:47;11208:67;;;11271:1;11268;11261:12;11208:67;10914:367;;;;;:::o;11286:1281::-;11451:6;11459;11467;11475;11483;11491;11499;11507;11515;11568:3;11556:9;11547:7;11543:23;11539:33;11536:53;;;11585:1;11582;11575:12;11536:53;11624:9;11611:23;11643:31;11668:5;11643:31;:::i;:::-;11693:5;-1:-1:-1;11749:2:1;11734:18;;11721:32;-1:-1:-1;;;;;11802:14:1;;;11799:34;;;11829:1;11826;11819:12;11799:34;11868:70;11930:7;11921:6;11910:9;11906:22;11868:70;:::i;:::-;11957:8;;-1:-1:-1;11842:96:1;-1:-1:-1;12045:2:1;12030:18;;12017:32;;-1:-1:-1;12061:16:1;;;12058:36;;;12090:1;12087;12080:12;12058:36;;12129:72;12193:7;12182:8;12171:9;12167:24;12129:72;:::i;:::-;12220:8;;-1:-1:-1;12103:98:1;-1:-1:-1;;12302:2:1;12287:18;;12274:32;;-1:-1:-1;12358:3:1;12343:19;;12330:33;12407:4;12394:18;;12382:31;;12372:59;;12427:1;12424;12417:12;12372:59;12450:7;12440:17;;;12504:3;12493:9;12489:19;12476:33;12466:43;;12556:3;12545:9;12541:19;12528:33;12518:43;;11286:1281;;;;;;;;;;;:::o;12851:730::-;12978:6;12986;12994;13047:2;13035:9;13026:7;13022:23;13018:32;13015:52;;;13063:1;13060;13053:12;13015:52;13102:9;13089:23;13121:31;13146:5;13121:31;:::i;:::-;13171:5;-1:-1:-1;13227:2:1;13212:18;;13199:32;-1:-1:-1;;;;;13280:14:1;;;13277:34;;;13307:1;13304;13297:12;13277:34;13330:61;13383:7;13374:6;13363:9;13359:22;13330:61;:::i;:::-;13320:71;;13444:2;13433:9;13429:18;13416:32;13400:48;;13473:2;13463:8;13460:16;13457:36;;;13489:1;13486;13479:12;13457:36;;13512:63;13567:7;13556:8;13545:9;13541:24;13512:63;:::i;:::-;13502:73;;;12851:730;;;;;:::o;13586:388::-;13654:6;13662;13715:2;13703:9;13694:7;13690:23;13686:32;13683:52;;;13731:1;13728;13721:12;13683:52;13770:9;13757:23;13789:31;13814:5;13789:31;:::i;:::-;13839:5;-1:-1:-1;13896:2:1;13881:18;;13868:32;13909:33;13868:32;13909:33;:::i;13979:734::-;14083:6;14091;14099;14107;14115;14168:3;14156:9;14147:7;14143:23;14139:33;14136:53;;;14185:1;14182;14175:12;14136:53;14224:9;14211:23;14243:31;14268:5;14243:31;:::i;:::-;14293:5;-1:-1:-1;14350:2:1;14335:18;;14322:32;14363:33;14322:32;14363:33;:::i;:::-;14415:7;-1:-1:-1;14469:2:1;14454:18;;14441:32;;-1:-1:-1;14520:2:1;14505:18;;14492:32;;-1:-1:-1;14575:3:1;14560:19;;14547:33;-1:-1:-1;;;;;14592:30:1;;14589:50;;;14635:1;14632;14625:12;14589:50;14658:49;14699:7;14690:6;14679:9;14675:22;14658:49;:::i;15130:400::-;15332:2;15314:21;;;15371:2;15351:18;;;15344:30;15410:34;15405:2;15390:18;;15383:62;-1:-1:-1;;;15476:2:1;15461:18;;15454:34;15520:3;15505:19;;15130:400::o;15535:380::-;15614:1;15610:12;;;;15657;;;15678:61;;15732:4;15724:6;15720:17;15710:27;;15678:61;15785:2;15777:6;15774:14;15754:18;15751:38;15748:161;;;15831:10;15826:3;15822:20;15819:1;15812:31;15866:4;15863:1;15856:15;15894:4;15891:1;15884:15;15748:161;;15535:380;;;:::o;16046:185::-;16088:3;16126:5;16120:12;16141:52;16186:6;16181:3;16174:4;16167:5;16163:16;16141:52;:::i;:::-;16209:16;;;;;16046:185;-1:-1:-1;;16046:185:1:o;16354:1301::-;16631:3;16660:1;16693:6;16687:13;16723:3;16745:1;16773:9;16769:2;16765:18;16755:28;;16833:2;16822:9;16818:18;16855;16845:61;;16899:4;16891:6;16887:17;16877:27;;16845:61;16925:2;16973;16965:6;16962:14;16942:18;16939:38;16936:165;;;-1:-1:-1;;;17000:33:1;;17056:4;17053:1;17046:15;17086:4;17007:3;17074:17;16936:165;17117:18;17144:104;;;;17262:1;17257:320;;;;17110:467;;17144:104;-1:-1:-1;;17177:24:1;;17165:37;;17222:16;;;;-1:-1:-1;17144:104:1;;17257:320;15993:1;15986:14;;;16030:4;16017:18;;17352:1;17366:165;17380:6;17377:1;17374:13;17366:165;;;17458:14;;17445:11;;;17438:35;17501:16;;;;17395:10;;17366:165;;;17370:3;;17560:6;17555:3;17551:16;17544:23;;17110:467;;;;;;;17593:56;17618:30;17644:3;17636:6;17618:30;:::i;:::-;-1:-1:-1;;;16296:20:1;;16341:1;16332:11;;16236:113;17593:56;17586:63;16354:1301;-1:-1:-1;;;;;16354:1301:1:o;19151:245::-;19218:6;19271:2;19259:9;19250:7;19246:23;19242:32;19239:52;;;19287:1;19284;19277:12;19239:52;19319:9;19313:16;19338:28;19360:5;19338:28;:::i;19401:356::-;19603:2;19585:21;;;19622:18;;;19615:30;19681:34;19676:2;19661:18;;19654:62;19748:2;19733:18;;19401:356::o;20181:127::-;20242:10;20237:3;20233:20;20230:1;20223:31;20273:4;20270:1;20263:15;20297:4;20294:1;20287:15;20313:127;20374:10;20369:3;20365:20;20362:1;20355:31;20405:4;20402:1;20395:15;20429:4;20426:1;20419:15;20445:135;20484:3;-1:-1:-1;;20505:17:1;;20502:43;;;20525:18;;:::i;:::-;-1:-1:-1;20572:1:1;20561:13;;20445:135::o;20995:128::-;21035:3;21066:1;21062:6;21059:1;21056:13;21053:39;;;21072:18;;:::i;:::-;-1:-1:-1;21108:9:1;;20995:128::o;21888:168::-;21928:7;21994:1;21990;21986:6;21982:14;21979:1;21976:21;21971:1;21964:9;21957:17;21953:45;21950:71;;;22001:18;;:::i;:::-;-1:-1:-1;22041:9:1;;21888:168::o;22061:127::-;22122:10;22117:3;22113:20;22110:1;22103:31;22153:4;22150:1;22143:15;22177:4;22174:1;22167:15;22193:120;22233:1;22259;22249:35;;22264:18;;:::i;:::-;-1:-1:-1;22298:9:1;;22193:120::o;23135:125::-;23175:4;23203:1;23200;23197:8;23194:34;;;23208:18;;:::i;:::-;-1:-1:-1;23245:9:1;;23135:125::o;23265:112::-;23297:1;23323;23313:35;;23328:18;;:::i;:::-;-1:-1:-1;23362:9:1;;23265:112::o;23382:399::-;23584:2;23566:21;;;23623:2;23603:18;;;23596:30;23662:34;23657:2;23642:18;;23635:62;-1:-1:-1;;;23728:2:1;23713:18;;23706:33;23771:3;23756:19;;23382:399::o;23786:400::-;23988:2;23970:21;;;24027:2;24007:18;;;24000:30;24066:34;24061:2;24046:18;;24039:62;-1:-1:-1;;;24132:2:1;24117:18;;24110:34;24176:3;24161:19;;23786:400::o;24444:397::-;24646:2;24628:21;;;24685:2;24665:18;;;24658:30;24724:34;24719:2;24704:18;;24697:62;-1:-1:-1;;;24790:2:1;24775:18;;24768:31;24831:3;24816:19;;24444:397::o;24846:404::-;25048:2;25030:21;;;25087:2;25067:18;;;25060:30;25126:34;25121:2;25106:18;;25099:62;-1:-1:-1;;;25192:2:1;25177:18;;25170:38;25240:3;25225:19;;24846:404::o;25255:401::-;25457:2;25439:21;;;25496:2;25476:18;;;25469:30;25535:34;25530:2;25515:18;;25508:62;-1:-1:-1;;;25601:2:1;25586:18;;25579:35;25646:3;25631:19;;25255:401::o;25661:406::-;25863:2;25845:21;;;25902:2;25882:18;;;25875:30;25941:34;25936:2;25921:18;;25914:62;-1:-1:-1;;;26007:2:1;25992:18;;25985:40;26057:3;26042:19;;25661:406::o;26072:465::-;26329:2;26318:9;26311:21;26292:4;26355:56;26407:2;26396:9;26392:18;26384:6;26355:56;:::i;:::-;26459:9;26451:6;26447:22;26442:2;26431:9;26427:18;26420:50;26487:44;26524:6;26516;26487:44;:::i;28313:572::-;-1:-1:-1;;;;;28610:15:1;;;28592:34;;28662:15;;28657:2;28642:18;;28635:43;28709:2;28694:18;;28687:34;;;28752:2;28737:18;;28730:34;;;28572:3;28795;28780:19;;28773:32;;;28535:4;;28822:57;;28859:19;;28851:6;28822:57;:::i;:::-;28814:65;28313:572;-1:-1:-1;;;;;;;28313:572:1:o;28890:249::-;28959:6;29012:2;29000:9;28991:7;28987:23;28983:32;28980:52;;;29028:1;29025;29018:12;28980:52;29060:9;29054:16;29079:30;29103:5;29079:30;:::i;29144:179::-;29179:3;29221:1;29203:16;29200:23;29197:120;;;29267:1;29264;29261;29246:23;-1:-1:-1;29304:1:1;29298:8;29293:3;29289:18;29197:120;29144:179;:::o;29328:671::-;29367:3;29409:4;29391:16;29388:26;29385:39;;;29328:671;:::o;29385:39::-;29451:2;29445:9;-1:-1:-1;;29516:16:1;29512:25;;29509:1;29445:9;29488:50;29567:4;29561:11;29591:16;-1:-1:-1;;;;;29697:2:1;29690:4;29682:6;29678:17;29675:25;29670:2;29662:6;29659:14;29656:45;29653:58;;;29704:5;;;;;29328:671;:::o;29653:58::-;29741:6;29735:4;29731:17;29720:28;;29777:3;29771:10;29804:2;29796:6;29793:14;29790:27;;;29810:5;;;;;;29328:671;:::o;29790:27::-;29894:2;29875:16;29869:4;29865:27;29861:36;29854:4;29845:6;29840:3;29836:16;29832:27;29829:69;29826:82;;;29901:5;;;;;;29328:671;:::o;29826:82::-;29917:57;29968:4;29959:6;29951;29947:19;29943:30;29937:4;29917:57;:::i;:::-;-1:-1:-1;29990:3:1;;29328:671;-1:-1:-1;;;;;29328:671:1:o;30425:404::-;30627:2;30609:21;;;30666:2;30646:18;;;30639:30;30705:34;30700:2;30685:18;;30678:62;-1:-1:-1;;;30771:2:1;30756:18;;30749:38;30819:3;30804:19;;30425:404::o;30834:127::-;30895:10;30890:3;30886:20;30883:1;30876:31;30926:4;30923:1;30916:15;30950:4;30947:1;30940:15;30966:838;-1:-1:-1;;;;;31363:15:1;;;31345:34;;31415:15;;31410:2;31395:18;;31388:43;31325:3;31462:2;31447:18;;31440:31;;;31288:4;;31494:57;;31531:19;;31523:6;31494:57;:::i;:::-;31599:9;31591:6;31587:22;31582:2;31571:9;31567:18;31560:50;31633:44;31670:6;31662;31633:44;:::i;:::-;31619:58;;31726:9;31718:6;31714:22;31708:3;31697:9;31693:19;31686:51;31754:44;31791:6;31783;31754:44;:::i;:::-;31746:52;30966:838;-1:-1:-1;;;;;;;;30966:838:1:o

Swarm Source

ipfs://299a7b1d9f772b80b35c98898c44d6aa9eaa036e03e2216eaa7a1be799a08ad5

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