Contract Source Code (Solidity)

IDE

• Blockscan IDE

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Sepolia.Arbiscan.io on 2024-03-13
*/

// File: @openzeppelin/[email protected]/utils/Counters.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/[email protected]/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/[email protected]/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts v4.4.1 (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: @openzeppelin/[email protected]/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: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/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/[email protected]/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: @openzeppelin/[email protected]/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/[email protected]/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/[email protected]/token/ERC1155/ERC1155.sol


// OpenZeppelin Contracts v4.4.1 (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();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), 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);

        _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);

        _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();

        _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);

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

        _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);

        _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();

        _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

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

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

    /**
     * @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 {}

    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: @openzeppelin/[email protected]/token/ERC1155/extensions/ERC1155Supply.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 */
abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 => uint256) private _totalSupply;

    /**
     * @dev Total amount of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return ERC1155Supply.totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] += amounts[i];
            }
        }

        if (to == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] -= amounts[i];
            }
        }
    }
}

// File: @openzeppelin/[email protected]/access/IAccessControl.sol


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

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// File: @openzeppelin/[email protected]/access/AccessControl.sol


// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;





/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// File: @openzeppelin/[email protected]/access/IAccessControlEnumerable.sol


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

pragma solidity ^0.8.0;


/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

// File: @openzeppelin/[email protected]/access/AccessControlEnumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)

pragma solidity ^0.8.0;




/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }
}

// File: NftFaucet/Contracts/Erc1155Faucet.sol


pragma solidity ^0.8.7;





contract Erc1155Faucet is Context, AccessControlEnumerable, ERC1155Supply {
    string internal nftName;
    string internal nftSymbol;

    using Counters for Counters.Counter;
    Counters.Counter private _tokenIdCounter;

    mapping(uint256 => string) internal _uriDict;

    constructor() ERC1155("https://token-cdn-domain/{id}.json")
    {
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
        nftName = "ERC-1155 Faucet";
        nftSymbol = "FA1155";
    }

    function mint(
        address to,
        uint256 amount,
        string calldata tokenUri)
        public
        virtual
    {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _mint(to, tokenId, amount, "0x1234");
        _uriDict[tokenId] = tokenUri;
    }

    function uri(uint256 id)
        public
        view
        virtual
        override
        returns (string memory)
    {
        return _uriDict[id];
    }

    function name()
        external
        view
        returns (string memory _name)
    {
        _name = nftName;
    }

    function symbol()
        external
        view
        returns (string memory _symbol)
    {
        _symbol = nftSymbol;
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC1155, AccessControlEnumerable)
        returns (bool)
    {
        return ERC1155.supportsInterface(interfaceId) || AccessControlEnumerable.supportsInterface(interfaceId);
    }

    function totalSupply()
        public
        view
        returns (uint256)
    {
        uint256 result = 0;
        uint256 maxId = _tokenIdCounter.current();

        for(uint256 i = 0; i < maxId; i++)
        {
            result = result + totalSupply(i);
        }

        return result;
    }
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","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":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","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":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","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":"amount","type":"uint256"},{"internalType":"string","name":"tokenUri","type":"string"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"_symbol","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

66779:1878:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37079:231;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68051:280;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67775:126;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67601:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68339:315;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59454:131;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39018:442;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59847:147;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60895:218;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37476:524;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51524:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65686:153;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58323:147;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67909:134;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57414:49;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38073:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51313:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66013:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67273:320;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60239:149;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38300:168;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38540:401;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37079:231;37165:7;37212:1;37193:21;;:7;:21;;;37185:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;37280:9;:13;37290:2;37280:13;;;;;;;;;;;:22;37294:7;37280:22;;;;;;;;;;;;;;;;37273:29;;37079:231;;;;:::o;68051:280::-;68198:4;68227:38;68253:11;68227:25;:38::i;:::-;:96;;;;68269:54;68311:11;68269:41;:54::i;:::-;68227:96;68220:103;;68051:280;;;:::o;67775:126::-;67841:19;67886:7;67878:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67775:126;:::o;67601:166::-;67709:13;67747:8;:12;67756:2;67747:12;;;;;;;;;;;67740:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67601:166;;;:::o;68339:315::-;68410:7;68435:14;68452:1;68435:18;;68464:13;68480:25;:15;:23;:25::i;:::-;68464:41;;68522:9;68518:103;68541:5;68537:1;:9;68518:103;;;68595:14;68607:1;68595:11;:14::i;:::-;68586:6;:23;;;;:::i;:::-;68577:32;;68548:3;;;;;;;68518:103;;;;68640:6;68633:13;;;;68339:315;:::o;59454:131::-;59528:7;59555:6;:12;59562:4;59555:12;;;;;;;;;;;:22;;;59548:29;;59454:131;;;:::o;39018:442::-;39259:12;:10;:12::i;:::-;39251:20;;:4;:20;;;:60;;;;39275:36;39292:4;39298:12;:10;:12::i;:::-;39275:16;:36::i;:::-;39251:60;39229:160;;;;;;;;;;;;:::i;:::-;;;;;;;;;39400:52;39423:4;39429:2;39433:3;39438:7;39447:4;39400:22;:52::i;:::-;39018:442;;;;;:::o;59847:147::-;59930:18;59943:4;59930:12;:18::i;:::-;57905:30;57916:4;57922:12;:10;:12::i;:::-;57905:10;:30::i;:::-;59961:25:::1;59972:4;59978:7;59961:10;:25::i;:::-;59847:147:::0;;;:::o;60895:218::-;61002:12;:10;:12::i;:::-;60991:23;;:7;:23;;;60983:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;61079:26;61091:4;61097:7;61079:11;:26::i;:::-;60895:218;;:::o;37476:524::-;37632:16;37693:3;:10;37674:8;:15;:29;37666:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;37762:30;37809:8;:15;37795:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37762:63;;37843:9;37838:122;37862:8;:15;37858:1;:19;37838:122;;;37918:30;37928:8;37937:1;37928:11;;;;;;;;:::i;:::-;;;;;;;;37941:3;37945:1;37941:6;;;;;;;;:::i;:::-;;;;;;;;37918:9;:30::i;:::-;37899:13;37913:1;37899:16;;;;;;;;:::i;:::-;;;;;;;:49;;;;;37879:3;;;;;37838:122;;;;37979:13;37972:20;;;37476:524;;;;:::o;51524:122::-;51581:4;51637:1;51605:29;51631:2;51605:25;:29::i;:::-;:33;51598:40;;51524:122;;;:::o;65686:153::-;65776:7;65803:28;65825:5;65803:12;:18;65816:4;65803:18;;;;;;;;;;;:21;;:28;;;;:::i;:::-;65796:35;;65686:153;;;;:::o;58323:147::-;58409:4;58433:6;:12;58440:4;58433:12;;;;;;;;;;;:20;;:29;58454:7;58433:29;;;;;;;;;;;;;;;;;;;;;;;;;58426:36;;58323:147;;;;:::o;67909:134::-;67977:21;68026:9;68016:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67909:134;:::o;57414:49::-;57459:4;57414:49;;;:::o;38073:155::-;38168:52;38187:12;:10;:12::i;:::-;38201:8;38211;38168:18;:52::i;:::-;38073:155;;:::o;51313:113::-;51375:7;51402:12;:16;51415:2;51402:16;;;;;;;;;;;;51395:23;;51313:113;;;:::o;66013:142::-;66093:7;66120:27;:12;:18;66133:4;66120:18;;;;;;;;;;;:25;:27::i;:::-;66113:34;;66013:142;;;:::o;67273:320::-;67418:15;67436:25;:15;:23;:25::i;:::-;67418:43;;67472:27;:15;:25;:27::i;:::-;67510:36;67516:2;67520:7;67529:6;67510:36;;;;;;;;;;;;;;;;;:5;:36::i;:::-;67577:8;;67557;:17;67566:7;67557:17;;;;;;;;;;;:28;;;;;;;:::i;:::-;;67407:186;67273:320;;;;:::o;60239:149::-;60323:18;60336:4;60323:12;:18::i;:::-;57905:30;57916:4;57922:12;:10;:12::i;:::-;57905:10;:30::i;:::-;60354:26:::1;60366:4;60372:7;60354:11;:26::i;:::-;60239:149:::0;;;:::o;38300:168::-;38399:4;38423:18;:27;38442:7;38423:27;;;;;;;;;;;;;;;:37;38451:8;38423:37;;;;;;;;;;;;;;;;;;;;;;;;;38416:44;;38300:168;;;;:::o;38540:401::-;38756:12;:10;:12::i;:::-;38748:20;;:4;:20;;;:60;;;;38772:36;38789:4;38795:12;:10;:12::i;:::-;38772:16;:36::i;:::-;38748:60;38726:151;;;;;;;;;;;;:::i;:::-;;;;;;;;;38888:45;38906:4;38912:2;38916;38920:6;38928:4;38888:17;:45::i;:::-;38540:401;;;;;:::o;36102:310::-;36204:4;36256:26;36241:41;;;:11;:41;;;;:110;;;;36314:37;36299:52;;;:11;:52;;;;36241:110;:163;;;;36368:36;36392:11;36368:23;:36::i;:::-;36241:163;36221:183;;36102:310;;;:::o;64873:214::-;64958:4;64997:42;64982:57;;;:11;:57;;;;:97;;;;65043:36;65067:11;65043:23;:36::i;:::-;64982:97;64975:104;;64873:214;;;:::o;878:114::-;943:7;970;:14;;;963:21;;878:114;;;:::o;34805:98::-;34858:7;34885:10;34878:17;;34805:98;:::o;41102:1074::-;41329:7;:14;41315:3;:10;:28;41307:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;41421:1;41407:16;;:2;:16;;;41399:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;41478:16;41497:12;:10;:12::i;:::-;41478:31;;41522:60;41543:8;41553:4;41559:2;41563:3;41568:7;41577:4;41522:20;:60::i;:::-;41600:9;41595:421;41619:3;:10;41615:1;:14;41595:421;;;41651:10;41664:3;41668:1;41664:6;;;;;;;;:::i;:::-;;;;;;;;41651:19;;41685:14;41702:7;41710:1;41702:10;;;;;;;;:::i;:::-;;;;;;;;41685:27;;41729:19;41751:9;:13;41761:2;41751:13;;;;;;;;;;;:19;41765:4;41751:19;;;;;;;;;;;;;;;;41729:41;;41808:6;41793:11;:21;;41785:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;41941:6;41927:11;:20;41905:9;:13;41915:2;41905:13;;;;;;;;;;;:19;41919:4;41905:19;;;;;;;;;;;;;;;:42;;;;41998:6;41977:9;:13;41987:2;41977:13;;;;;;;;;;;:17;41991:2;41977:17;;;;;;;;;;;;;;;;:27;;;;;;;:::i;:::-;;;;;;;;41636:380;;;41631:3;;;;;41595:421;;;;42063:2;42033:47;;42057:4;42033:47;;42047:8;42033:47;;;42067:3;42072:7;42033:47;;;;;;;:::i;:::-;;;;;;;;42093:75;42129:8;42139:4;42145:2;42149:3;42154:7;42163:4;42093:35;:75::i;:::-;41296:880;41102:1074;;;;;:::o;58760:505::-;58849:22;58857:4;58863:7;58849;:22::i;:::-;58844:414;;59037:41;59065:7;59037:41;;59075:2;59037:19;:41::i;:::-;59151:38;59179:4;59171:13;;59186:2;59151:19;:38::i;:::-;58942:270;;;;;;;;;:::i;:::-;;;;;;;;;;;;;58888:358;;;;;;;;;;;:::i;:::-;;;;;;;;58844:414;58760:505;;:::o;66248:169::-;66336:31;66353:4;66359:7;66336:16;:31::i;:::-;66378;66401:7;66378:12;:18;66391:4;66378:18;;;;;;;;;;;:22;;:31;;;;:::i;:::-;;66248:169;;:::o;66511:174::-;66600:32;66618:4;66624:7;66600:17;:32::i;:::-;66643:34;66669:7;66643:12;:18;66656:4;66643:18;;;;;;;;;;;:25;;:34;;;;:::i;:::-;;66511:174;;:::o;19154:158::-;19228:7;19279:22;19283:3;:10;;19295:5;19279:3;:22::i;:::-;19271:31;;19248:56;;19154:158;;;;:::o;47288:331::-;47443:8;47434:17;;:5;:17;;;47426:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;47546:8;47508:18;:25;47527:5;47508:25;;;;;;;;;;;;;;;:35;47534:8;47508:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;47592:8;47570:41;;47585:5;47570:41;;;47602:8;47570:41;;;;;;:::i;:::-;;;;;;;;47288:331;;;:::o;18683:117::-;18746:7;18773:19;18781:3;:10;;18773:7;:19::i;:::-;18766:26;;18683:117;;;:::o;1000:127::-;1107:1;1089:7;:14;;;:19;;;;;;;;;;;1000:127;:::o;43494:569::-;43661:1;43647:16;;:2;:16;;;43639:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;43714:16;43733:12;:10;:12::i;:::-;43714:31;;43758:102;43779:8;43797:1;43801:2;43805:21;43823:2;43805:17;:21::i;:::-;43828:25;43846:6;43828:17;:25::i;:::-;43855:4;43758:20;:102::i;:::-;43894:6;43873:9;:13;43883:2;43873:13;;;;;;;;;;;:17;43887:2;43873:17;;;;;;;;;;;;;;;;:27;;;;;;;:::i;:::-;;;;;;;;43953:2;43916:52;;43949:1;43916:52;;43931:8;43916:52;;;43957:2;43961:6;43916:52;;;;;;;:::i;:::-;;;;;;;;43981:74;44012:8;44030:1;44034:2;44038;44042:6;44050:4;43981:30;:74::i;:::-;43628:435;43494:569;;;;:::o;39924:820::-;40126:1;40112:16;;:2;:16;;;40104:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;40183:16;40202:12;:10;:12::i;:::-;40183:31;;40227:96;40248:8;40258:4;40264:2;40268:21;40286:2;40268:17;:21::i;:::-;40291:25;40309:6;40291:17;:25::i;:::-;40318:4;40227:20;:96::i;:::-;40336:19;40358:9;:13;40368:2;40358:13;;;;;;;;;;;:19;40372:4;40358:19;;;;;;;;;;;;;;;;40336:41;;40411:6;40396:11;:21;;40388:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;40536:6;40522:11;:20;40500:9;:13;40510:2;40500:13;;;;;;;;;;;:19;40514:4;40500:19;;;;;;;;;;;;;;;:42;;;;40585:6;40564:9;:13;40574:2;40564:13;;;;;;;;;;;:17;40578:2;40564:17;;;;;;;;;;;;;;;;:27;;;;;;;:::i;:::-;;;;;;;;40640:2;40609:46;;40634:4;40609:46;;40624:8;40609:46;;;40644:2;40648:6;40609:46;;;;;;;:::i;:::-;;;;;;;;40668:68;40699:8;40709:4;40715:2;40719;40723:6;40731:4;40668:30;:68::i;:::-;40093:651;;39924:820;;;;;:::o;58027:204::-;58112:4;58151:32;58136:47;;;:11;:47;;;;:87;;;;58187:36;58211:11;58187:23;:36::i;:::-;58136:87;58129:94;;58027:204;;;:::o;51721:655::-;51960:66;51987:8;51997:4;52003:2;52007:3;52012:7;52021:4;51960:26;:66::i;:::-;52059:1;52043:18;;:4;:18;;;52039:160;;52083:9;52078:110;52102:3;:10;52098:1;:14;52078:110;;;52162:7;52170:1;52162:10;;;;;;;;:::i;:::-;;;;;;;;52138:12;:20;52151:3;52155:1;52151:6;;;;;;;;:::i;:::-;;;;;;;;52138:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;;;;;52114:3;;;;;52078:110;;;;52039:160;52229:1;52215:16;;:2;:16;;;52211:158;;52253:9;52248:110;52272:3;:10;52268:1;:14;52248:110;;;52332:7;52340:1;52332:10;;;;;;;;:::i;:::-;;;;;;;;52308:12;:20;52321:3;52325:1;52321:6;;;;;;;;:::i;:::-;;;;;;;;52308:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;;;;;52284:3;;;;;52248:110;;;;52211:158;51721:655;;;;;;:::o;49556:813::-;49796:15;:2;:13;;;:15::i;:::-;49792:570;;;49849:2;49832:43;;;49876:8;49886:4;49892:3;49897:7;49906:4;49832:79;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;49828:523;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;50224:6;50217:14;;;;;;;;;;;:::i;:::-;;;;;;;;49828:523;;;50273:62;;;;;;;;;;:::i;:::-;;;;;;;;49828:523;50005:48;;;49993:60;;;:8;:60;;;;49989:159;;50078:50;;;;;;;;;;:::i;:::-;;;;;;;;49989:159;49912:251;49792:570;49556:813;;;;;;:::o;33662:451::-;33737:13;33763:19;33808:1;33799:6;33795:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;33785:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33763:47;;33821:15;:6;33828:1;33821:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;33847;:6;33854:1;33847:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;33878:9;33903:1;33894:6;33890:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;33878:26;;33873:135;33910:1;33906;:5;33873:135;;;33945:12;33966:3;33958:5;:11;33945:25;;;;;;;:::i;:::-;;;;;33933:6;33940:1;33933:9;;;;;;;;:::i;:::-;;;;;:37;;;;;;;;;;;33995:1;33985:11;;;;;33913:3;;;;:::i;:::-;;;33873:135;;;;34035:1;34026:5;:10;34018:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;34098:6;34084:21;;;33662:451;;;;:::o;62396:238::-;62480:22;62488:4;62494:7;62480;:22::i;:::-;62475:152;;62551:4;62519:6;:12;62526:4;62519:12;;;;;;;;;;;:20;;:29;62540:7;62519:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;62602:12;:10;:12::i;:::-;62575:40;;62593:7;62575:40;;62587:4;62575:40;;;;;;;;;;62475:152;62396:238;;:::o;17858:152::-;17928:4;17952:50;17957:3;:10;;17993:5;17977:23;;17969:32;;17952:4;:50::i;:::-;17945:57;;17858:152;;;;:::o;62766:239::-;62850:22;62858:4;62864:7;62850;:22::i;:::-;62846:152;;;62921:5;62889:6;:12;62896:4;62889:12;;;;;;;;;;;:20;;:29;62910:7;62889:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;62973:12;:10;:12::i;:::-;62946:40;;62964:7;62946:40;;62958:4;62946:40;;;;;;;;;;62846:152;62766:239;;:::o;18186:158::-;18259:4;18283:53;18291:3;:10;;18327:5;18311:23;;18303:32;;18283:7;:53::i;:::-;18276:60;;18186:158;;;;:::o;14547:120::-;14614:7;14641:3;:11;;14653:5;14641:18;;;;;;;;:::i;:::-;;;;;;;;;;14634:25;;14547:120;;;;:::o;14084:109::-;14140:7;14167:3;:11;;:18;;;;14160:25;;14084:109;;;:::o;50377:198::-;50443:16;50472:22;50511:1;50497:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50472:41;;50535:7;50524:5;50530:1;50524:8;;;;;;;;:::i;:::-;;;;;;;:18;;;;;50562:5;50555:12;;;50377:198;;;:::o;48804:744::-;49019:15;:2;:13;;;:15::i;:::-;49015:526;;;49072:2;49055:38;;;49094:8;49104:4;49110:2;49114:6;49122:4;49055:72;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;49051:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;49403:6;49396:14;;;;;;;;;;;:::i;:::-;;;;;;;;49051:479;;;49452:62;;;;;;;;;;:::i;:::-;;;;;;;;49051:479;49189:43;;;49177:55;;;:8;:55;;;;49173:154;;49257:50;;;;;;;;;;:::i;:::-;;;;;;;;49173:154;49128:214;49015:526;48804:744;;;;;;:::o;31826:157::-;31911:4;31950:25;31935:40;;;:11;:40;;;;31928:47;;31826:157;;;:::o;48575:221::-;;;;;;;:::o;2710:326::-;2770:4;3027:1;3005:7;:19;;;:23;2998:30;;2710:326;;;:::o;11773:414::-;11836:4;11858:21;11868:3;11873:5;11858:9;:21::i;:::-;11853:327;;11896:3;:11;;11913:5;11896:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12079:3;:11;;:18;;;;12057:3;:12;;:19;12070:5;12057:19;;;;;;;;;;;:40;;;;12119:4;12112:11;;;;11853:327;12163:5;12156:12;;11773:414;;;;;:::o;12363:1420::-;12429:4;12547:18;12568:3;:12;;:19;12581:5;12568:19;;;;;;;;;;;;12547:40;;12618:1;12604:10;:15;12600:1176;;12979:21;13016:1;13003:10;:14;;;;:::i;:::-;12979:38;;13032:17;13073:1;13052:3;:11;;:18;;;;:22;;;;:::i;:::-;13032:42;;13108:13;13095:9;:26;13091:405;;13142:17;13162:3;:11;;13174:9;13162:22;;;;;;;;:::i;:::-;;;;;;;;;;13142:42;;13316:9;13287:3;:11;;13299:13;13287:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;13427:10;13401:3;:12;;:23;13414:9;13401:23;;;;;;;;;;;:36;;;;13123:373;13091:405;13577:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;13672:3;:12;;:19;13685:5;13672:19;;;;;;;;;;;13665:26;;;13715:4;13708:11;;;;;;;12600:1176;13759:5;13752:12;;;12363:1420;;;;;:::o;13869:129::-;13942:4;13989:1;13966:3;:12;;:19;13979:5;13966:19;;;;;;;;;;;;:24;;13959:31;;13869:129;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:474::-;1265:6;1273;1322:2;1310:9;1301:7;1297:23;1293:32;1290:119;;;1328:79;;:::i;:::-;1290:119;1448:1;1473:53;1518:7;1509:6;1498:9;1494:22;1473:53;:::i;:::-;1463:63;;1419:117;1575:2;1601:53;1646:7;1637:6;1626:9;1622:22;1601:53;:::i;:::-;1591:63;;1546:118;1197:474;;;;;:::o;1677:118::-;1764:24;1782:5;1764:24;:::i;:::-;1759:3;1752:37;1677:118;;:::o;1801:222::-;1894:4;1932:2;1921:9;1917:18;1909:26;;1945:71;2013:1;2002:9;1998:17;1989:6;1945:71;:::i;:::-;1801:222;;;;:::o;2029:149::-;2065:7;2105:66;2098:5;2094:78;2083:89;;2029:149;;;:::o;2184:120::-;2256:23;2273:5;2256:23;:::i;:::-;2249:5;2246:34;2236:62;;2294:1;2291;2284:12;2236:62;2184:120;:::o;2310:137::-;2355:5;2393:6;2380:20;2371:29;;2409:32;2435:5;2409:32;:::i;:::-;2310:137;;;;:::o;2453:327::-;2511:6;2560:2;2548:9;2539:7;2535:23;2531:32;2528:119;;;2566:79;;:::i;:::-;2528:119;2686:1;2711:52;2755:7;2746:6;2735:9;2731:22;2711:52;:::i;:::-;2701:62;;2657:116;2453:327;;;;:::o;2786:90::-;2820:7;2863:5;2856:13;2849:21;2838:32;;2786:90;;;:::o;2882:109::-;2963:21;2978:5;2963:21;:::i;:::-;2958:3;2951:34;2882:109;;:::o;2997:210::-;3084:4;3122:2;3111:9;3107:18;3099:26;;3135:65;3197:1;3186:9;3182:17;3173:6;3135:65;:::i;:::-;2997:210;;;;:::o;3213:99::-;3265:6;3299:5;3293:12;3283:22;;3213:99;;;:::o;3318:169::-;3402:11;3436:6;3431:3;3424:19;3476:4;3471:3;3467:14;3452:29;;3318:169;;;;:::o;3493:246::-;3574:1;3584:113;3598:6;3595:1;3592:13;3584:113;;;3683:1;3678:3;3674:11;3668:18;3664:1;3659:3;3655:11;3648:39;3620:2;3617:1;3613:10;3608:15;;3584:113;;;3731:1;3722:6;3717:3;3713:16;3706:27;3555:184;3493:246;;;:::o;3745:102::-;3786:6;3837:2;3833:7;3828:2;3821:5;3817:14;3813:28;3803:38;;3745:102;;;:::o;3853:377::-;3941:3;3969:39;4002:5;3969:39;:::i;:::-;4024:71;4088:6;4083:3;4024:71;:::i;:::-;4017:78;;4104:65;4162:6;4157:3;4150:4;4143:5;4139:16;4104:65;:::i;:::-;4194:29;4216:6;4194:29;:::i;:::-;4189:3;4185:39;4178:46;;3945:285;3853:377;;;;:::o;4236:313::-;4349:4;4387:2;4376:9;4372:18;4364:26;;4436:9;4430:4;4426:20;4422:1;4411:9;4407:17;4400:47;4464:78;4537:4;4528:6;4464:78;:::i;:::-;4456:86;;4236:313;;;;:::o;4555:329::-;4614:6;4663:2;4651:9;4642:7;4638:23;4634:32;4631:119;;;4669:79;;:::i;:::-;4631:119;4789:1;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4760:117;4555:329;;;;:::o;4890:77::-;4927:7;4956:5;4945:16;;4890:77;;;:::o;4973:122::-;5046:24;5064:5;5046:24;:::i;:::-;5039:5;5036:35;5026:63;;5085:1;5082;5075:12;5026:63;4973:122;:::o;5101:139::-;5147:5;5185:6;5172:20;5163:29;;5201:33;5228:5;5201:33;:::i;:::-;5101:139;;;;:::o;5246:329::-;5305:6;5354:2;5342:9;5333:7;5329:23;5325:32;5322:119;;;5360:79;;:::i;:::-;5322:119;5480:1;5505:53;5550:7;5541:6;5530:9;5526:22;5505:53;:::i;:::-;5495:63;;5451:117;5246:329;;;;:::o;5581:118::-;5668:24;5686:5;5668:24;:::i;:::-;5663:3;5656:37;5581:118;;:::o;5705:222::-;5798:4;5836:2;5825:9;5821:18;5813:26;;5849:71;5917:1;5906:9;5902:17;5893:6;5849:71;:::i;:::-;5705:222;;;;:::o;5933:117::-;6042:1;6039;6032:12;6056:180;6104:77;6101:1;6094:88;6201:4;6198:1;6191:15;6225:4;6222:1;6215:15;6242:281;6325:27;6347:4;6325:27;:::i;:::-;6317:6;6313:40;6455:6;6443:10;6440:22;6419:18;6407:10;6404:34;6401:62;6398:88;;;6466:18;;:::i;:::-;6398:88;6506:10;6502:2;6495:22;6285:238;6242:281;;:::o;6529:129::-;6563:6;6590:20;;:::i;:::-;6580:30;;6619:33;6647:4;6639:6;6619:33;:::i;:::-;6529:129;;;:::o;6664:311::-;6741:4;6831:18;6823:6;6820:30;6817:56;;;6853:18;;:::i;:::-;6817:56;6903:4;6895:6;6891:17;6883:25;;6963:4;6957;6953:15;6945:23;;6664:311;;;:::o;6981:117::-;7090:1;7087;7080:12;7121:710;7217:5;7242:81;7258:64;7315:6;7258:64;:::i;:::-;7242:81;:::i;:::-;7233:90;;7343:5;7372:6;7365:5;7358:21;7406:4;7399:5;7395:16;7388:23;;7459:4;7451:6;7447:17;7439:6;7435:30;7488:3;7480:6;7477:15;7474:122;;;7507:79;;:::i;:::-;7474:122;7622:6;7605:220;7639:6;7634:3;7631:15;7605:220;;;7714:3;7743:37;7776:3;7764:10;7743:37;:::i;:::-;7738:3;7731:50;7810:4;7805:3;7801:14;7794:21;;7681:144;7665:4;7660:3;7656:14;7649:21;;7605:220;;;7609:21;7223:608;;7121:710;;;;;:::o;7854:370::-;7925:5;7974:3;7967:4;7959:6;7955:17;7951:27;7941:122;;7982:79;;:::i;:::-;7941:122;8099:6;8086:20;8124:94;8214:3;8206:6;8199:4;8191:6;8187:17;8124:94;:::i;:::-;8115:103;;7931:293;7854:370;;;;:::o;8230:117::-;8339:1;8336;8329:12;8353:307;8414:4;8504:18;8496:6;8493:30;8490:56;;;8526:18;;:::i;:::-;8490:56;8564:29;8586:6;8564:29;:::i;:::-;8556:37;;8648:4;8642;8638:15;8630:23;;8353:307;;;:::o;8666:146::-;8763:6;8758:3;8753;8740:30;8804:1;8795:6;8790:3;8786:16;8779:27;8666:146;;;:::o;8818:423::-;8895:5;8920:65;8936:48;8977:6;8936:48;:::i;:::-;8920:65;:::i;:::-;8911:74;;9008:6;9001:5;8994:21;9046:4;9039:5;9035:16;9084:3;9075:6;9070:3;9066:16;9063:25;9060:112;;;9091:79;;:::i;:::-;9060:112;9181:54;9228:6;9223:3;9218;9181:54;:::i;:::-;8901:340;8818:423;;;;;:::o;9260:338::-;9315:5;9364:3;9357:4;9349:6;9345:17;9341:27;9331:122;;9372:79;;:::i;:::-;9331:122;9489:6;9476:20;9514:78;9588:3;9580:6;9573:4;9565:6;9561:17;9514:78;:::i;:::-;9505:87;;9321:277;9260:338;;;;:::o;9604:1509::-;9758:6;9766;9774;9782;9790;9839:3;9827:9;9818:7;9814:23;9810:33;9807:120;;;9846:79;;:::i;:::-;9807:120;9966:1;9991:53;10036:7;10027:6;10016:9;10012:22;9991:53;:::i;:::-;9981:63;;9937:117;10093:2;10119:53;10164:7;10155:6;10144:9;10140:22;10119:53;:::i;:::-;10109:63;;10064:118;10249:2;10238:9;10234:18;10221:32;10280:18;10272:6;10269:30;10266:117;;;10302:79;;:::i;:::-;10266:117;10407:78;10477:7;10468:6;10457:9;10453:22;10407:78;:::i;:::-;10397:88;;10192:303;10562:2;10551:9;10547:18;10534:32;10593:18;10585:6;10582:30;10579:117;;;10615:79;;:::i;:::-;10579:117;10720:78;10790:7;10781:6;10770:9;10766:22;10720:78;:::i;:::-;10710:88;;10505:303;10875:3;10864:9;10860:19;10847:33;10907:18;10899:6;10896:30;10893:117;;;10929:79;;:::i;:::-;10893:117;11034:62;11088:7;11079:6;11068:9;11064:22;11034:62;:::i;:::-;11024:72;;10818:288;9604:1509;;;;;;;;:::o;11119:474::-;11187:6;11195;11244:2;11232:9;11223:7;11219:23;11215:32;11212:119;;;11250:79;;:::i;:::-;11212:119;11370:1;11395:53;11440:7;11431:6;11420:9;11416:22;11395:53;:::i;:::-;11385:63;;11341:117;11497:2;11523:53;11568:7;11559:6;11548:9;11544:22;11523:53;:::i;:::-;11513:63;;11468:118;11119:474;;;;;:::o;11599:311::-;11676:4;11766:18;11758:6;11755:30;11752:56;;;11788:18;;:::i;:::-;11752:56;11838:4;11830:6;11826:17;11818:25;;11898:4;11892;11888:15;11880:23;;11599:311;;;:::o;11933:710::-;12029:5;12054:81;12070:64;12127:6;12070:64;:::i;:::-;12054:81;:::i;:::-;12045:90;;12155:5;12184:6;12177:5;12170:21;12218:4;12211:5;12207:16;12200:23;;12271:4;12263:6;12259:17;12251:6;12247:30;12300:3;12292:6;12289:15;12286:122;;;12319:79;;:::i;:::-;12286:122;12434:6;12417:220;12451:6;12446:3;12443:15;12417:220;;;12526:3;12555:37;12588:3;12576:10;12555:37;:::i;:::-;12550:3;12543:50;12622:4;12617:3;12613:14;12606:21;;12493:144;12477:4;12472:3;12468:14;12461:21;;12417:220;;;12421:21;12035:608;;11933:710;;;;;:::o;12666:370::-;12737:5;12786:3;12779:4;12771:6;12767:17;12763:27;12753:122;;12794:79;;:::i;:::-;12753:122;12911:6;12898:20;12936:94;13026:3;13018:6;13011:4;13003:6;12999:17;12936:94;:::i;:::-;12927:103;;12743:293;12666:370;;;;:::o;13042:894::-;13160:6;13168;13217:2;13205:9;13196:7;13192:23;13188:32;13185:119;;;13223:79;;:::i;:::-;13185:119;13371:1;13360:9;13356:17;13343:31;13401:18;13393:6;13390:30;13387:117;;;13423:79;;:::i;:::-;13387:117;13528:78;13598:7;13589:6;13578:9;13574:22;13528:78;:::i;:::-;13518:88;;13314:302;13683:2;13672:9;13668:18;13655:32;13714:18;13706:6;13703:30;13700:117;;;13736:79;;:::i;:::-;13700:117;13841:78;13911:7;13902:6;13891:9;13887:22;13841:78;:::i;:::-;13831:88;;13626:303;13042:894;;;;;:::o;13942:114::-;14009:6;14043:5;14037:12;14027:22;;13942:114;;;:::o;14062:184::-;14161:11;14195:6;14190:3;14183:19;14235:4;14230:3;14226:14;14211:29;;14062:184;;;;:::o;14252:132::-;14319:4;14342:3;14334:11;;14372:4;14367:3;14363:14;14355:22;;14252:132;;;:::o;14390:108::-;14467:24;14485:5;14467:24;:::i;:::-;14462:3;14455:37;14390:108;;:::o;14504:179::-;14573:10;14594:46;14636:3;14628:6;14594:46;:::i;:::-;14672:4;14667:3;14663:14;14649:28;;14504:179;;;;:::o;14689:113::-;14759:4;14791;14786:3;14782:14;14774:22;;14689:113;;;:::o;14838:732::-;14957:3;14986:54;15034:5;14986:54;:::i;:::-;15056:86;15135:6;15130:3;15056:86;:::i;:::-;15049:93;;15166:56;15216:5;15166:56;:::i;:::-;15245:7;15276:1;15261:284;15286:6;15283:1;15280:13;15261:284;;;15362:6;15356:13;15389:63;15448:3;15433:13;15389:63;:::i;:::-;15382:70;;15475:60;15528:6;15475:60;:::i;:::-;15465:70;;15321:224;15308:1;15305;15301:9;15296:14;;15261:284;;;15265:14;15561:3;15554:10;;14962:608;;;14838:732;;;;:::o;15576:373::-;15719:4;15757:2;15746:9;15742:18;15734:26;;15806:9;15800:4;15796:20;15792:1;15781:9;15777:17;15770:47;15834:108;15937:4;15928:6;15834:108;:::i;:::-;15826:116;;15576:373;;;;:::o;15955:474::-;16023:6;16031;16080:2;16068:9;16059:7;16055:23;16051:32;16048:119;;;16086:79;;:::i;:::-;16048:119;16206:1;16231:53;16276:7;16267:6;16256:9;16252:22;16231:53;:::i;:::-;16221:63;;16177:117;16333:2;16359:53;16404:7;16395:6;16384:9;16380:22;16359:53;:::i;:::-;16349:63;;16304:118;15955:474;;;;;:::o;16435:118::-;16522:24;16540:5;16522:24;:::i;:::-;16517:3;16510:37;16435:118;;:::o;16559:222::-;16652:4;16690:2;16679:9;16675:18;16667:26;;16703:71;16771:1;16760:9;16756:17;16747:6;16703:71;:::i;:::-;16559:222;;;;:::o;16787:116::-;16857:21;16872:5;16857:21;:::i;:::-;16850:5;16847:32;16837:60;;16893:1;16890;16883:12;16837:60;16787:116;:::o;16909:133::-;16952:5;16990:6;16977:20;16968:29;;17006:30;17030:5;17006:30;:::i;:::-;16909:133;;;;:::o;17048:468::-;17113:6;17121;17170:2;17158:9;17149:7;17145:23;17141:32;17138:119;;;17176:79;;:::i;:::-;17138:119;17296:1;17321:53;17366:7;17357:6;17346:9;17342:22;17321:53;:::i;:::-;17311:63;;17267:117;17423:2;17449:50;17491:7;17482:6;17471:9;17467:22;17449:50;:::i;:::-;17439:60;;17394:115;17048:468;;;;;:::o;17522:117::-;17631:1;17628;17621:12;17659:553;17717:8;17727:6;17777:3;17770:4;17762:6;17758:17;17754:27;17744:122;;17785:79;;:::i;:::-;17744:122;17898:6;17885:20;17875:30;;17928:18;17920:6;17917:30;17914:117;;;17950:79;;:::i;:::-;17914:117;18064:4;18056:6;18052:17;18040:29;;18118:3;18110:4;18102:6;18098:17;18088:8;18084:32;18081:41;18078:128;;;18125:79;;:::i;:::-;18078:128;17659:553;;;;;:::o;18218:819::-;18307:6;18315;18323;18331;18380:2;18368:9;18359:7;18355:23;18351:32;18348:119;;;18386:79;;:::i;:::-;18348:119;18506:1;18531:53;18576:7;18567:6;18556:9;18552:22;18531:53;:::i;:::-;18521:63;;18477:117;18633:2;18659:53;18704:7;18695:6;18684:9;18680:22;18659:53;:::i;:::-;18649:63;;18604:118;18789:2;18778:9;18774:18;18761:32;18820:18;18812:6;18809:30;18806:117;;;18842:79;;:::i;:::-;18806:117;18955:65;19012:7;19003:6;18992:9;18988:22;18955:65;:::i;:::-;18937:83;;;;18732:298;18218:819;;;;;;;:::o;19043:474::-;19111:6;19119;19168:2;19156:9;19147:7;19143:23;19139:32;19136:119;;;19174:79;;:::i;:::-;19136:119;19294:1;19319:53;19364:7;19355:6;19344:9;19340:22;19319:53;:::i;:::-;19309:63;;19265:117;19421:2;19447:53;19492:7;19483:6;19472:9;19468:22;19447:53;:::i;:::-;19437:63;;19392:118;19043:474;;;;;:::o;19523:1089::-;19627:6;19635;19643;19651;19659;19708:3;19696:9;19687:7;19683:23;19679:33;19676:120;;;19715:79;;:::i;:::-;19676:120;19835:1;19860:53;19905:7;19896:6;19885:9;19881:22;19860:53;:::i;:::-;19850:63;;19806:117;19962:2;19988:53;20033:7;20024:6;20013:9;20009:22;19988:53;:::i;:::-;19978:63;;19933:118;20090:2;20116:53;20161:7;20152:6;20141:9;20137:22;20116:53;:::i;:::-;20106:63;;20061:118;20218:2;20244:53;20289:7;20280:6;20269:9;20265:22;20244:53;:::i;:::-;20234:63;;20189:118;20374:3;20363:9;20359:19;20346:33;20406:18;20398:6;20395:30;20392:117;;;20428:79;;:::i;:::-;20392:117;20533:62;20587:7;20578:6;20567:9;20563:22;20533:62;:::i;:::-;20523:72;;20317:288;19523:1089;;;;;;;;:::o;20618:230::-;20758:34;20754:1;20746:6;20742:14;20735:58;20827:13;20822:2;20814:6;20810:15;20803:38;20618:230;:::o;20854:366::-;20996:3;21017:67;21081:2;21076:3;21017:67;:::i;:::-;21010:74;;21093:93;21182:3;21093:93;:::i;:::-;21211:2;21206:3;21202:12;21195:19;;20854:366;;;:::o;21226:419::-;21392:4;21430:2;21419:9;21415:18;21407:26;;21479:9;21473:4;21469:20;21465:1;21454:9;21450:17;21443:47;21507:131;21633:4;21507:131;:::i;:::-;21499:139;;21226:419;;;:::o;21651:180::-;21699:77;21696:1;21689:88;21796:4;21793:1;21786:15;21820:4;21817:1;21810:15;21837:320;21881:6;21918:1;21912:4;21908:12;21898:22;;21965:1;21959:4;21955:12;21986:18;21976:81;;22042:4;22034:6;22030:17;22020:27;;21976:81;22104:2;22096:6;22093:14;22073:18;22070:38;22067:84;;22123:18;;:::i;:::-;22067:84;21888:269;21837:320;;;:::o;22163:180::-;22211:77;22208:1;22201:88;22308:4;22305:1;22298:15;22332:4;22329:1;22322:15;22349:191;22389:3;22408:20;22426:1;22408:20;:::i;:::-;22403:25;;22442:20;22460:1;22442:20;:::i;:::-;22437:25;;22485:1;22482;22478:9;22471:16;;22506:3;22503:1;22500:10;22497:36;;;22513:18;;:::i;:::-;22497:36;22349:191;;;;:::o;22546:237::-;22686:34;22682:1;22674:6;22670:14;22663:58;22755:20;22750:2;22742:6;22738:15;22731:45;22546:237;:::o;22789:366::-;22931:3;22952:67;23016:2;23011:3;22952:67;:::i;:::-;22945:74;;23028:93;23117:3;23028:93;:::i;:::-;23146:2;23141:3;23137:12;23130:19;;22789:366;;;:::o;23161:419::-;23327:4;23365:2;23354:9;23350:18;23342:26;;23414:9;23408:4;23404:20;23400:1;23389:9;23385:17;23378:47;23442:131;23568:4;23442:131;:::i;:::-;23434:139;;23161:419;;;:::o;23586:234::-;23726:34;23722:1;23714:6;23710:14;23703:58;23795:17;23790:2;23782:6;23778:15;23771:42;23586:234;:::o;23826:366::-;23968:3;23989:67;24053:2;24048:3;23989:67;:::i;:::-;23982:74;;24065:93;24154:3;24065:93;:::i;:::-;24183:2;24178:3;24174:12;24167:19;;23826:366;;;:::o;24198:419::-;24364:4;24402:2;24391:9;24387:18;24379:26;;24451:9;24445:4;24441:20;24437:1;24426:9;24422:17;24415:47;24479:131;24605:4;24479:131;:::i;:::-;24471:139;;24198:419;;;:::o;24623:228::-;24763:34;24759:1;24751:6;24747:14;24740:58;24832:11;24827:2;24819:6;24815:15;24808:36;24623:228;:::o;24857:366::-;24999:3;25020:67;25084:2;25079:3;25020:67;:::i;:::-;25013:74;;25096:93;25185:3;25096:93;:::i;:::-;25214:2;25209:3;25205:12;25198:19;;24857:366;;;:::o;25229:419::-;25395:4;25433:2;25422:9;25418:18;25410:26;;25482:9;25476:4;25472:20;25468:1;25457:9;25453:17;25446:47;25510:131;25636:4;25510:131;:::i;:::-;25502:139;;25229:419;;;:::o;25654:180::-;25702:77;25699:1;25692:88;25799:4;25796:1;25789:15;25823:4;25820:1;25813:15;25840:97;25899:6;25927:3;25917:13;;25840:97;;;;:::o;25943:141::-;25992:4;26015:3;26007:11;;26038:3;26035:1;26028:14;26072:4;26069:1;26059:18;26051:26;;25943:141;;;:::o;26090:93::-;26127:6;26174:2;26169;26162:5;26158:14;26154:23;26144:33;;26090:93;;;:::o;26189:107::-;26233:8;26283:5;26277:4;26273:16;26252:37;;26189:107;;;;:::o;26302:393::-;26371:6;26421:1;26409:10;26405:18;26444:97;26474:66;26463:9;26444:97;:::i;:::-;26562:39;26592:8;26581:9;26562:39;:::i;:::-;26550:51;;26634:4;26630:9;26623:5;26619:21;26610:30;;26683:4;26673:8;26669:19;26662:5;26659:30;26649:40;;26378:317;;26302:393;;;;;:::o;26701:60::-;26729:3;26750:5;26743:12;;26701:60;;;:::o;26767:142::-;26817:9;26850:53;26868:34;26877:24;26895:5;26877:24;:::i;:::-;26868:34;:::i;:::-;26850:53;:::i;:::-;26837:66;;26767:142;;;:::o;26915:75::-;26958:3;26979:5;26972:12;;26915:75;;;:::o;26996:269::-;27106:39;27137:7;27106:39;:::i;:::-;27167:91;27216:41;27240:16;27216:41;:::i;:::-;27208:6;27201:4;27195:11;27167:91;:::i;:::-;27161:4;27154:105;27072:193;26996:269;;;:::o;27271:73::-;27316:3;27271:73;:::o;27350:189::-;27427:32;;:::i;:::-;27468:65;27526:6;27518;27512:4;27468:65;:::i;:::-;27403:136;27350:189;;:::o;27545:186::-;27605:120;27622:3;27615:5;27612:14;27605:120;;;27676:39;27713:1;27706:5;27676:39;:::i;:::-;27649:1;27642:5;27638:13;27629:22;;27605:120;;;27545:186;;:::o;27737:543::-;27838:2;27833:3;27830:11;27827:446;;;27872:38;27904:5;27872:38;:::i;:::-;27956:29;27974:10;27956:29;:::i;:::-;27946:8;27942:44;28139:2;28127:10;28124:18;28121:49;;;28160:8;28145:23;;28121:49;28183:80;28239:22;28257:3;28239:22;:::i;:::-;28229:8;28225:37;28212:11;28183:80;:::i;:::-;27842:431;;27827:446;27737:543;;;:::o;28286:117::-;28340:8;28390:5;28384:4;28380:16;28359:37;;28286:117;;;;:::o;28409:169::-;28453:6;28486:51;28534:1;28530:6;28522:5;28519:1;28515:13;28486:51;:::i;:::-;28482:56;28567:4;28561;28557:15;28547:25;;28460:118;28409:169;;;;:::o;28583:295::-;28659:4;28805:29;28830:3;28824:4;28805:29;:::i;:::-;28797:37;;28867:3;28864:1;28860:11;28854:4;28851:21;28843:29;;28583:295;;;;:::o;28883:1403::-;29007:44;29047:3;29042;29007:44;:::i;:::-;29116:18;29108:6;29105:30;29102:56;;;29138:18;;:::i;:::-;29102:56;29182:38;29214:4;29208:11;29182:38;:::i;:::-;29267:67;29327:6;29319;29313:4;29267:67;:::i;:::-;29361:1;29390:2;29382:6;29379:14;29407:1;29402:632;;;;30078:1;30095:6;30092:84;;;30151:9;30146:3;30142:19;30129:33;30120:42;;30092:84;30202:67;30262:6;30255:5;30202:67;:::i;:::-;30196:4;30189:81;30051:229;29372:908;;29402:632;29454:4;29450:9;29442:6;29438:22;29488:37;29520:4;29488:37;:::i;:::-;29547:1;29561:215;29575:7;29572:1;29569:14;29561:215;;;29661:9;29656:3;29652:19;29639:33;29631:6;29624:49;29712:1;29704:6;29700:14;29690:24;;29759:2;29748:9;29744:18;29731:31;;29598:4;29595:1;29591:12;29586:17;;29561:215;;;29804:6;29795:7;29792:19;29789:186;;;29869:9;29864:3;29860:19;29847:33;29912:48;29954:4;29946:6;29942:17;29931:9;29912:48;:::i;:::-;29904:6;29897:64;29812:163;29789:186;30021:1;30017;30009:6;30005:14;30001:22;29995:4;29988:36;29409:625;;;29372:908;;28982:1304;;;28883:1403;;;:::o;30292:228::-;30432:34;30428:1;30420:6;30416:14;30409:58;30501:11;30496:2;30488:6;30484:15;30477:36;30292:228;:::o;30526:366::-;30668:3;30689:67;30753:2;30748:3;30689:67;:::i;:::-;30682:74;;30765:93;30854:3;30765:93;:::i;:::-;30883:2;30878:3;30874:12;30867:19;;30526:366;;;:::o;30898:419::-;31064:4;31102:2;31091:9;31087:18;31079:26;;31151:9;31145:4;31141:20;31137:1;31126:9;31122:17;31115:47;31179:131;31305:4;31179:131;:::i;:::-;31171:139;;30898:419;;;:::o;31323:227::-;31463:34;31459:1;31451:6;31447:14;31440:58;31532:10;31527:2;31519:6;31515:15;31508:35;31323:227;:::o;31556:366::-;31698:3;31719:67;31783:2;31778:3;31719:67;:::i;:::-;31712:74;;31795:93;31884:3;31795:93;:::i;:::-;31913:2;31908:3;31904:12;31897:19;;31556:366;;;:::o;31928:419::-;32094:4;32132:2;32121:9;32117:18;32109:26;;32181:9;32175:4;32171:20;32167:1;32156:9;32152:17;32145:47;32209:131;32335:4;32209:131;:::i;:::-;32201:139;;31928:419;;;:::o;32353:224::-;32493:34;32489:1;32481:6;32477:14;32470:58;32562:7;32557:2;32549:6;32545:15;32538:32;32353:224;:::o;32583:366::-;32725:3;32746:67;32810:2;32805:3;32746:67;:::i;:::-;32739:74;;32822:93;32911:3;32822:93;:::i;:::-;32940:2;32935:3;32931:12;32924:19;;32583:366;;;:::o;32955:419::-;33121:4;33159:2;33148:9;33144:18;33136:26;;33208:9;33202:4;33198:20;33194:1;33183:9;33179:17;33172:47;33236:131;33362:4;33236:131;:::i;:::-;33228:139;;32955:419;;;:::o;33380:229::-;33520:34;33516:1;33508:6;33504:14;33497:58;33589:12;33584:2;33576:6;33572:15;33565:37;33380:229;:::o;33615:366::-;33757:3;33778:67;33842:2;33837:3;33778:67;:::i;:::-;33771:74;;33854:93;33943:3;33854:93;:::i;:::-;33972:2;33967:3;33963:12;33956:19;;33615:366;;;:::o;33987:419::-;34153:4;34191:2;34180:9;34176:18;34168:26;;34240:9;34234:4;34230:20;34226:1;34215:9;34211:17;34204:47;34268:131;34394:4;34268:131;:::i;:::-;34260:139;;33987:419;;;:::o;34412:634::-;34633:4;34671:2;34660:9;34656:18;34648:26;;34720:9;34714:4;34710:20;34706:1;34695:9;34691:17;34684:47;34748:108;34851:4;34842:6;34748:108;:::i;:::-;34740:116;;34903:9;34897:4;34893:20;34888:2;34877:9;34873:18;34866:48;34931:108;35034:4;35025:6;34931:108;:::i;:::-;34923:116;;34412:634;;;;;:::o;35052:148::-;35154:11;35191:3;35176:18;;35052:148;;;;:::o;35206:173::-;35346:25;35342:1;35334:6;35330:14;35323:49;35206:173;:::o;35385:402::-;35545:3;35566:85;35648:2;35643:3;35566:85;:::i;:::-;35559:92;;35660:93;35749:3;35660:93;:::i;:::-;35778:2;35773:3;35769:12;35762:19;;35385:402;;;:::o;35793:390::-;35899:3;35927:39;35960:5;35927:39;:::i;:::-;35982:89;36064:6;36059:3;35982:89;:::i;:::-;35975:96;;36080:65;36138:6;36133:3;36126:4;36119:5;36115:16;36080:65;:::i;:::-;36170:6;36165:3;36161:16;36154:23;;35903:280;35793:390;;;;:::o;36189:167::-;36329:19;36325:1;36317:6;36313:14;36306:43;36189:167;:::o;36362:402::-;36522:3;36543:85;36625:2;36620:3;36543:85;:::i;:::-;36536:92;;36637:93;36726:3;36637:93;:::i;:::-;36755:2;36750:3;36746:12;36739:19;;36362:402;;;:::o;36770:967::-;37152:3;37174:148;37318:3;37174:148;:::i;:::-;37167:155;;37339:95;37430:3;37421:6;37339:95;:::i;:::-;37332:102;;37451:148;37595:3;37451:148;:::i;:::-;37444:155;;37616:95;37707:3;37698:6;37616:95;:::i;:::-;37609:102;;37728:3;37721:10;;36770:967;;;;;:::o;37743:228::-;37883:34;37879:1;37871:6;37867:14;37860:58;37952:11;37947:2;37939:6;37935:15;37928:36;37743:228;:::o;37977:366::-;38119:3;38140:67;38204:2;38199:3;38140:67;:::i;:::-;38133:74;;38216:93;38305:3;38216:93;:::i;:::-;38334:2;38329:3;38325:12;38318:19;;37977:366;;;:::o;38349:419::-;38515:4;38553:2;38542:9;38538:18;38530:26;;38602:9;38596:4;38592:20;38588:1;38577:9;38573:17;38566:47;38630:131;38756:4;38630:131;:::i;:::-;38622:139;;38349:419;;;:::o;38774:220::-;38914:34;38910:1;38902:6;38898:14;38891:58;38983:3;38978:2;38970:6;38966:15;38959:28;38774:220;:::o;39000:366::-;39142:3;39163:67;39227:2;39222:3;39163:67;:::i;:::-;39156:74;;39239:93;39328:3;39239:93;:::i;:::-;39357:2;39352:3;39348:12;39341:19;;39000:366;;;:::o;39372:419::-;39538:4;39576:2;39565:9;39561:18;39553:26;;39625:9;39619:4;39615:20;39611:1;39600:9;39596:17;39589:47;39653:131;39779:4;39653:131;:::i;:::-;39645:139;;39372:419;;;:::o;39797:332::-;39918:4;39956:2;39945:9;39941:18;39933:26;;39969:71;40037:1;40026:9;40022:17;40013:6;39969:71;:::i;:::-;40050:72;40118:2;40107:9;40103:18;40094:6;40050:72;:::i;:::-;39797:332;;;;;:::o;40135:194::-;40175:4;40195:20;40213:1;40195:20;:::i;:::-;40190:25;;40229:20;40247:1;40229:20;:::i;:::-;40224:25;;40273:1;40270;40266:9;40258:17;;40297:1;40291:4;40288:11;40285:37;;;40302:18;;:::i;:::-;40285:37;40135:194;;;;:::o;40335:98::-;40386:6;40420:5;40414:12;40404:22;;40335:98;;;:::o;40439:168::-;40522:11;40556:6;40551:3;40544:19;40596:4;40591:3;40587:14;40572:29;;40439:168;;;;:::o;40613:373::-;40699:3;40727:38;40759:5;40727:38;:::i;:::-;40781:70;40844:6;40839:3;40781:70;:::i;:::-;40774:77;;40860:65;40918:6;40913:3;40906:4;40899:5;40895:16;40860:65;:::i;:::-;40950:29;40972:6;40950:29;:::i;:::-;40945:3;40941:39;40934:46;;40703:283;40613:373;;;;:::o;40992:1053::-;41315:4;41353:3;41342:9;41338:19;41330:27;;41367:71;41435:1;41424:9;41420:17;41411:6;41367:71;:::i;:::-;41448:72;41516:2;41505:9;41501:18;41492:6;41448:72;:::i;:::-;41567:9;41561:4;41557:20;41552:2;41541:9;41537:18;41530:48;41595:108;41698:4;41689:6;41595:108;:::i;:::-;41587:116;;41750:9;41744:4;41740:20;41735:2;41724:9;41720:18;41713:48;41778:108;41881:4;41872:6;41778:108;:::i;:::-;41770:116;;41934:9;41928:4;41924:20;41918:3;41907:9;41903:19;41896:49;41962:76;42033:4;42024:6;41962:76;:::i;:::-;41954:84;;40992:1053;;;;;;;;:::o;42051:141::-;42107:5;42138:6;42132:13;42123:22;;42154:32;42180:5;42154:32;:::i;:::-;42051:141;;;;:::o;42198:349::-;42267:6;42316:2;42304:9;42295:7;42291:23;42287:32;42284:119;;;42322:79;;:::i;:::-;42284:119;42442:1;42467:63;42522:7;42513:6;42502:9;42498:22;42467:63;:::i;:::-;42457:73;;42413:127;42198:349;;;;:::o;42553:106::-;42597:8;42646:5;42641:3;42637:15;42616:36;;42553:106;;;:::o;42665:183::-;42700:3;42738:1;42720:16;42717:23;42714:128;;;42776:1;42773;42770;42755:23;42798:34;42829:1;42823:8;42798:34;:::i;:::-;42791:41;;42714:128;42665:183;:::o;42854:711::-;42893:3;42931:4;42913:16;42910:26;42939:5;42907:39;42968:20;;:::i;:::-;43043:1;43025:16;43021:24;43018:1;43012:4;42997:49;43076:4;43070:11;43175:16;43168:4;43160:6;43156:17;43153:39;43120:18;43112:6;43109:30;43093:113;43090:146;;;43221:5;;;;43090:146;43267:6;43261:4;43257:17;43303:3;43297:10;43330:18;43322:6;43319:30;43316:43;;;43352:5;;;;;;43316:43;43400:6;43393:4;43388:3;43384:14;43380:27;43459:1;43441:16;43437:24;43431:4;43427:35;43422:3;43419:44;43416:57;;;43466:5;;;;;;;43416:57;43483;43531:6;43525:4;43521:17;43513:6;43509:30;43503:4;43483:57;:::i;:::-;43556:3;43549:10;;42897:668;;;;;42854:711;;:::o;43571:239::-;43711:34;43707:1;43699:6;43695:14;43688:58;43780:22;43775:2;43767:6;43763:15;43756:47;43571:239;:::o;43816:366::-;43958:3;43979:67;44043:2;44038:3;43979:67;:::i;:::-;43972:74;;44055:93;44144:3;44055:93;:::i;:::-;44173:2;44168:3;44164:12;44157:19;;43816:366;;;:::o;44188:419::-;44354:4;44392:2;44381:9;44377:18;44369:26;;44441:9;44435:4;44431:20;44427:1;44416:9;44412:17;44405:47;44469:131;44595:4;44469:131;:::i;:::-;44461:139;;44188:419;;;:::o;44613:227::-;44753:34;44749:1;44741:6;44737:14;44730:58;44822:10;44817:2;44809:6;44805:15;44798:35;44613:227;:::o;44846:366::-;44988:3;45009:67;45073:2;45068:3;45009:67;:::i;:::-;45002:74;;45085:93;45174:3;45085:93;:::i;:::-;45203:2;45198:3;45194:12;45187:19;;44846:366;;;:::o;45218:419::-;45384:4;45422:2;45411:9;45407:18;45399:26;;45471:9;45465:4;45461:20;45457:1;45446:9;45442:17;45435:47;45499:131;45625:4;45499:131;:::i;:::-;45491:139;;45218:419;;;:::o;45643:410::-;45683:7;45706:20;45724:1;45706:20;:::i;:::-;45701:25;;45740:20;45758:1;45740:20;:::i;:::-;45735:25;;45795:1;45792;45788:9;45817:30;45835:11;45817:30;:::i;:::-;45806:41;;45996:1;45987:7;45983:15;45980:1;45977:22;45957:1;45950:9;45930:83;45907:139;;46026:18;;:::i;:::-;45907:139;45691:362;45643:410;;;;:::o;46059:171::-;46098:3;46121:24;46139:5;46121:24;:::i;:::-;46112:33;;46167:4;46160:5;46157:15;46154:41;;46175:18;;:::i;:::-;46154:41;46222:1;46215:5;46211:13;46204:20;;46059:171;;;:::o;46236:182::-;46376:34;46372:1;46364:6;46360:14;46353:58;46236:182;:::o;46424:366::-;46566:3;46587:67;46651:2;46646:3;46587:67;:::i;:::-;46580:74;;46663:93;46752:3;46663:93;:::i;:::-;46781:2;46776:3;46772:12;46765:19;;46424:366;;;:::o;46796:419::-;46962:4;47000:2;46989:9;46985:18;46977:26;;47049:9;47043:4;47039:20;47035:1;47024:9;47020:17;47013:47;47077:131;47203:4;47077:131;:::i;:::-;47069:139;;46796:419;;;:::o;47221:751::-;47444:4;47482:3;47471:9;47467:19;47459:27;;47496:71;47564:1;47553:9;47549:17;47540:6;47496:71;:::i;:::-;47577:72;47645:2;47634:9;47630:18;47621:6;47577:72;:::i;:::-;47659;47727:2;47716:9;47712:18;47703:6;47659:72;:::i;:::-;47741;47809:2;47798:9;47794:18;47785:6;47741:72;:::i;:::-;47861:9;47855:4;47851:20;47845:3;47834:9;47830:19;47823:49;47889:76;47960:4;47951:6;47889:76;:::i;:::-;47881:84;;47221:751;;;;;;;;:::o;47978:180::-;48026:77;48023:1;48016:88;48123:4;48120:1;48113:15;48147:4;48144:1;48137:15

ipfs://53fd22f1a11ed2954f9c4eb45fd265169fe6b847010ef7b2ee51523e2f92d648