Token OpenSea Collections

 

Overview ERC-1155

Total Supply:
0 OPENSTORE

Holders:
4,477,239 addresses
 
Balance
0 OPENSTORE
0x30C35aD6e723AD52D269D176842d5A319B19bBc1
Loading
[ Download CSV Export  ] 
Loading
Loading

OVERVIEW

Discover, collect, and sell extraordinary NFTs on the world's first & largest NFT marketplace.


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
AssetContractShared

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2021-08-11
*/

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol



pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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



pragma solidity ^0.8.0;

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

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

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



pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

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

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

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/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/contracts/token/ERC1155/IERC1155.sol



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC1155/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.
        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. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

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



pragma solidity ^0.8.0;


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

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



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/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/contracts/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 {
        require(_msgSender() != operator, "ERC1155: setting approval status for self");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_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 `account`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(account != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

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

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

        _doSafeTransferAcceptanceCheck(operator, address(0), account, 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 `account`
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address account,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(account != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

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

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

        emit TransferSingle(operator, account, 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 account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(account != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

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

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

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

        emit TransferBatch(operator, account, address(0), ids, amounts);
    }

    /**
     * @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(to).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(to).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/contracts/security/Pausable.sol



pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: contracts/common/meta-transactions/ContentMixin.sol



pragma solidity 0.8.4;

abstract contract ContextMixin {
    function msgSender() internal view returns (address payable sender) {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

// File: contracts/common/meta-transactions/Initializable.sol



pragma solidity 0.8.4;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

// File: contracts/common/meta-transactions/EIP712Base.sol



pragma solidity 0.8.4;


contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string public constant ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH =
        keccak256(
            bytes(
                "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
            )
        );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(string memory name) internal initializer {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}

// File: contracts/common/meta-transactions/NativeMetaTransaction.sol



pragma solidity 0.8.4;


contract NativeMetaTransaction is EIP712Base {
    bytes32 private constant META_TRANSACTION_TYPEHASH =
        keccak256(
            bytes(
                "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
            )
        );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) external payable returns (bytes memory) {
        MetaTransaction memory metaTx =
            MetaTransaction({
                nonce: nonces[userAddress],
                from: userAddress,
                functionSignature: functionSignature
            });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] += 1;

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) =
            address(this).call(
                abi.encodePacked(functionSignature, userAddress)
            );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}

// File: contracts/ERC1155Tradable.sol



pragma solidity 0.8.4;







contract OwnableDelegateProxy {}

contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

/**
 * @title ERC1155Tradable
 * ERC1155Tradable - ERC1155 contract that whitelists an operator address, has create and mint functionality, and supports useful standards from OpenZeppelin,
  like exists(), name(), symbol(), and totalSupply()
 */
contract ERC1155Tradable is
    ContextMixin,
    ERC1155,
    NativeMetaTransaction,
    Ownable,
    Pausable
{
    using Address for address;

    // Proxy registry address
    address public proxyRegistryAddress;
    // Contract name
    string public name;
    // Contract symbol
    string public symbol;

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

    mapping(uint256 => uint256) private _supply;

    constructor(
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress
    ) ERC1155("") {
        name = _name;
        symbol = _symbol;
        proxyRegistryAddress = _proxyRegistryAddress;
        _initializeEIP712(name);
    }

    /**
     * @dev Throws if called by any account other than the owner or their proxy
     */
    modifier onlyOwnerOrProxy() {
        require(
            _isOwnerOrProxy(_msgSender()),
            "ERC1155Tradable#onlyOwner: CALLER_IS_NOT_OWNER"
        );
        _;
    }

    /**
     * @dev Throws if called by any account other than _from or their proxy
     */
    modifier onlyApproved(address _from) {
        require(
            _from == _msgSender() || isApprovedForAll(_from, _msgSender()),
            "ERC1155Tradable#onlyApproved: CALLER_NOT_ALLOWED"
        );
        _;
    }

    function _isOwnerOrProxy(address _address) internal view returns (bool) {
        return owner() == _address || _isProxyForUser(owner(), _address);
    }

    function pause() external onlyOwnerOrProxy {
        _pause();
    }

    function unpause() external onlyOwnerOrProxy {
        _unpause();
    }

    /**
     * @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 Returns the total quantity for a token ID
     * @param _id uint256 ID of the token to query
     * @return amount of token in existence
     */
    function totalSupply(uint256 _id) public view returns (uint256) {
        return _supply[_id];
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-free listings.
     */
    function isApprovedForAll(address _owner, address _operator)
        public
        view
        override
        returns (bool isOperator)
    {
        // Whitelist OpenSea proxy contracts for easy trading.
        if (_isProxyForUser(_owner, _operator)) {
            return true;
        }

        return super.isApprovedForAll(_owner, _operator);
    }

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override whenNotPaused onlyApproved(from) {
        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"
        );
        balances[id][from] = fromBalance - amount;
        balances[id][to] += amount;

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

        doSafeTransferAcceptanceCheck(operator, 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 whenNotPaused onlyApproved(from) {
        require(
            ids.length == amounts.length,
            "ERC1155: IDS_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"
            );
            balances[id][from] = fromBalance - amount;
            balances[id][to] += amount;
        }

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

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

    /**
     * @dev Hook to be called right before minting
     * @param _id          Token ID to mint
     * @param _quantity    Amount of tokens to mint
     */
    function _beforeMint(uint256 _id, uint256 _quantity) internal virtual {}

    /**
     * @dev Mints some amount of tokens to an address
     * @param _to          Address of the future owner of the token
     * @param _id          Token ID to mint
     * @param _quantity    Amount of tokens to mint
     * @param _data        Data to pass if receiver is contract
     */
    function mint(
        address _to,
        uint256 _id,
        uint256 _quantity,
        bytes memory _data
    ) public virtual onlyOwnerOrProxy {
        _mint(_to, _id, _quantity, _data);
    }

    /**
     * @dev Mint tokens for each id in _ids
     * @param _to          The address to mint tokens to
     * @param _ids         Array of ids to mint
     * @param _quantities  Array of amounts of tokens to mint per id
     * @param _data        Data to pass if receiver is contract
     */
    function batchMint(
        address _to,
        uint256[] memory _ids,
        uint256[] memory _quantities,
        bytes memory _data
    ) public virtual onlyOwnerOrProxy {
        _batchMint(_to, _ids, _quantities, _data);
    }

    /**
     * @dev Burns amount of a given token id
     * @param _from          The address to burn tokens from
     * @param _id          Token ID to burn
     * @param _quantity    Amount to burn
     */
    function burn(
        address _from,
        uint256 _id,
        uint256 _quantity
    ) public virtual onlyApproved(_from) {
        _burn(_from, _id, _quantity);
    }

    /**
     * @dev Burns tokens for each id in _ids
     * @param _from          The address to burn tokens from
     * @param _ids         Array of token ids to burn
     * @param _quantities  Array of the amount to be burned
     */
    function batchBurn(
        address _from,
        uint256[] memory _ids,
        uint256[] memory _quantities
    ) public virtual onlyApproved(_from) {
        _burnBatch(_from, _ids, _quantities);
    }

    /**
     * @dev Returns whether the specified token is minted
     * @param _id uint256 ID of the token to query the existence of
     * @return bool whether the token exists
     */
    function exists(uint256 _id) public view returns (bool) {
        return _supply[_id] > 0;
    }

    // Overrides ERC1155 _mint to allow changing birth events to creator transfers,
    // and to set _supply
    function _mint(
        address _to,
        uint256 _id,
        uint256 _amount,
        bytes memory _data
    ) internal virtual override whenNotPaused {
        address operator = _msgSender();

        _beforeTokenTransfer(
            operator,
            address(0),
            _to,
            asSingletonArray(_id),
            asSingletonArray(_amount),
            _data
        );

        _beforeMint(_id, _amount);

        // Add _amount
        balances[_id][_to] += _amount;
        _supply[_id] += _amount;

        // Origin of token will be the _from parameter
        address origin = _origin(_id);

        // Emit event
        emit TransferSingle(operator, origin, _to, _id, _amount);

        // Calling onReceive method if recipient is contract
        doSafeTransferAcceptanceCheck(
            operator,
            origin,
            _to,
            _id,
            _amount,
            _data
        );
    }

    // Overrides ERC1155MintBurn to change the batch birth events to creator transfers, and to set _supply
    function _batchMint(
        address _to,
        uint256[] memory _ids,
        uint256[] memory _amounts,
        bytes memory _data
    ) internal virtual whenNotPaused {
        require(
            _ids.length == _amounts.length,
            "ERC1155Tradable#batchMint: INVALID_ARRAYS_LENGTH"
        );

        // Number of mints to execute
        uint256 nMint = _ids.length;

        // Origin of tokens will be the _from parameter
        address origin = _origin(_ids[0]);

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), _to, _ids, _amounts, _data);

        // Executing all minting
        for (uint256 i = 0; i < nMint; i++) {
            // Update storage balance
            uint256 id = _ids[i];
            uint256 amount = _amounts[i];
            _beforeMint(id, amount);
            require(
                _origin(id) == origin,
                "ERC1155Tradable#batchMint: MULTIPLE_ORIGINS_NOT_ALLOWED"
            );
            balances[id][_to] += amount;
            _supply[id] += amount;
        }

        // Emit batch mint event
        emit TransferBatch(operator, origin, _to, _ids, _amounts);

        // Calling onReceive method if recipient is contract
        doSafeBatchTransferAcceptanceCheck(
            operator,
            origin,
            _to,
            _ids,
            _amounts,
            _data
        );
    }

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

        address operator = _msgSender();

        _beforeTokenTransfer(
            operator,
            account,
            address(0),
            asSingletonArray(id),
            asSingletonArray(amount),
            ""
        );

        uint256 accountBalance = balances[id][account];
        require(
            accountBalance >= amount,
            "ERC1155#_burn: AMOUNT_EXCEEDS_BALANCE"
        );
        balances[id][account] = accountBalance - amount;
        _supply[id] -= amount;

        emit TransferSingle(operator, account, 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 account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal override whenNotPaused {
        require(account != address(0), "ERC1155: BURN_FROM_ZERO_ADDRESS");
        require(
            ids.length == amounts.length,
            "ERC1155: IDS_AMOUNTS_LENGTH_MISMATCH"
        );

        address operator = _msgSender();

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

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

            uint256 accountBalance = balances[id][account];
            require(
                accountBalance >= amount,
                "ERC1155#_burnBatch: AMOUNT_EXCEEDS_BALANCE"
            );
            balances[id][account] = accountBalance - amount;
            _supply[id] -= amount;
        }

        emit TransferBatch(operator, account, address(0), ids, amounts);
    }

    // Override this to change birth events' _from address
    function _origin(
        uint256 /* _id */
    ) internal view virtual returns (address) {
        return address(0);
    }

    // PROXY HELPER METHODS

    function _isProxyForUser(address _user, address _address)
        internal
        view
        virtual
        returns (bool)
    {
        if (!proxyRegistryAddress.isContract()) {
            return false;
        }
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        return address(proxyRegistry.proxies(_user)) == _address;
    }

    // Copied from OpenZeppelin
    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/c3ae4790c71b7f53cc8fff743536dcb7031fed74/contracts/token/ERC1155/ERC1155.sol#L394
    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(to).onERC1155Received.selector
                ) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    // Copied from OpenZeppelin
    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/c3ae4790c71b7f53cc8fff743536dcb7031fed74/contracts/token/ERC1155/ERC1155.sol#L417
    function doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155BatchReceived(
                    operator,
                    from,
                    ids,
                    amounts,
                    data
                )
            returns (bytes4 response) {
                if (
                    response !=
                    IERC1155Receiver(to).onERC1155BatchReceived.selector
                ) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    // Copied from OpenZeppelin
    // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/c3ae4790c71b7f53cc8fff743536dcb7031fed74/contracts/token/ERC1155/ERC1155.sol#L440
    function asSingletonArray(uint256 element)
        private
        pure
        returns (uint256[] memory)
    {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender() internal view override returns (address sender) {
        return ContextMixin.msgSender();
    }
}

// File: contracts/AssetContract.sol



pragma solidity 0.8.4;


/**
 * @title AssetContract
 * AssetContract - A contract for easily creating non-fungible assets on OpenSea.
 */
contract AssetContract is ERC1155Tradable {
    event PermanentURI(string _value, uint256 indexed _id);

    uint256 constant TOKEN_SUPPLY_CAP = 1;

    string public templateURI;

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

    // Mapping for whether a token URI is set permanently
    mapping(uint256 => bool) private _isPermanentURI;

    modifier onlyTokenAmountOwned(
        address _from,
        uint256 _id,
        uint256 _quantity
    ) {
        require(
            _ownsTokenAmount(_from, _id, _quantity),
            "AssetContract#onlyTokenAmountOwned: ONLY_TOKEN_AMOUNT_OWNED_ALLOWED"
        );
        _;
    }

    /**
     * @dev Require the URI to be impermanent
     */
    modifier onlyImpermanentURI(uint256 id) {
        require(
            !isPermanentURI(id),
            "AssetContract#onlyImpermanentURI: URI_CANNOT_BE_CHANGED"
        );
        _;
    }

    constructor(
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress,
        string memory _templateURI
    ) ERC1155Tradable(_name, _symbol, _proxyRegistryAddress) {
        if (bytes(_templateURI).length > 0) {
            setTemplateURI(_templateURI);
        }
    }

    function openSeaVersion() public pure returns (string memory) {
        return "2.1.0";
    }

    /**
     * @dev Require _from to own a specified quantity of the token
     */
    function _ownsTokenAmount(
        address _from,
        uint256 _id,
        uint256 _quantity
    ) internal view returns (bool) {
        return balanceOf(_from, _id) >= _quantity;
    }

    /**
     * Compat for factory interfaces on OpenSea
     * Indicates that this contract can return balances for
     * tokens that haven't been minted yet
     */
    function supportsFactoryInterface() public pure returns (bool) {
        return true;
    }

    function setTemplateURI(string memory _uri) public onlyOwnerOrProxy {
        templateURI = _uri;
    }

    function setURI(uint256 _id, string memory _uri)
        public
        virtual
        onlyOwnerOrProxy
        onlyImpermanentURI(_id)
    {
        _setURI(_id, _uri);
    }

    function setPermanentURI(uint256 _id, string memory _uri)
        public
        virtual
        onlyOwnerOrProxy
        onlyImpermanentURI(_id)
    {
        _setPermanentURI(_id, _uri);
    }

    function isPermanentURI(uint256 _id) public view returns (bool) {
        return _isPermanentURI[_id];
    }

    function uri(uint256 _id) public view override returns (string memory) {
        string memory tokenUri = _tokenURI[_id];
        if (bytes(tokenUri).length != 0) {
            return tokenUri;
        }
        return templateURI;
    }

    function balanceOf(address _owner, uint256 _id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        uint256 balance = super.balanceOf(_owner, _id);
        return
            _isCreatorOrProxy(_id, _owner)
                ? balance + _remainingSupply(_id)
                : balance;
    }

    function safeTransferFrom(
        address _from,
        address _to,
        uint256 _id,
        uint256 _amount,
        bytes memory _data
    ) public override {
        uint256 mintedBalance = super.balanceOf(_from, _id);
        if (mintedBalance < _amount) {
            // Only mint what _from doesn't already have
            mint(_to, _id, _amount - mintedBalance, _data);
            if (mintedBalance > 0) {
                super.safeTransferFrom(_from, _to, _id, mintedBalance, _data);
            }
        } else {
            super.safeTransferFrom(_from, _to, _id, _amount, _data);
        }
    }

    function safeBatchTransferFrom(
        address _from,
        address _to,
        uint256[] memory _ids,
        uint256[] memory _amounts,
        bytes memory _data
    ) public override {
        require(
            _ids.length == _amounts.length,
            "AssetContract#safeBatchTransferFrom: INVALID_ARRAYS_LENGTH"
        );
        for (uint256 i = 0; i < _ids.length; i++) {
            safeTransferFrom(_from, _to, _ids[i], _amounts[i], _data);
        }
    }

    function _beforeMint(uint256 _id, uint256 _quantity)
        internal
        view
        override
    {
        require(
            _quantity <= _remainingSupply(_id),
            "AssetContract#_beforeMint: QUANTITY_EXCEEDS_TOKEN_SUPPLY_CAP"
        );
    }

    // Overrides ERC1155Tradable burn to check for quantity owned
    function burn(
        address _from,
        uint256 _id,
        uint256 _quantity
    ) public override onlyTokenAmountOwned(_from, _id, _quantity) {
        super.burn(_from, _id, _quantity);
    }

    // Overrides ERC1155Tradable batchBurn to check for quantity owned
    function batchBurn(
        address _from,
        uint256[] memory _ids,
        uint256[] memory _quantities
    ) public override {
        for (uint256 i = 0; i < _ids.length; i++) {
            require(
                _ownsTokenAmount(_from, _ids[i], _quantities[i]),
                "AssetContract#batchBurn: ONLY_TOKEN_AMOUNT_OWNED_ALLOWED"
            );
        }
        super.batchBurn(_from, _ids, _quantities);
    }

    function _mint(
        address _to,
        uint256 _id,
        uint256 _quantity,
        bytes memory _data
    ) internal override {
        super._mint(_to, _id, _quantity, _data);
        if (_data.length > 1) {
            _setURI(_id, string(_data));
        }
    }

    function _isCreatorOrProxy(uint256, address _address)
        internal
        view
        virtual
        returns (bool)
    {
        return _isOwnerOrProxy(_address);
    }

    function _remainingSupply(uint256 _id)
        internal
        view
        virtual
        returns (uint256)
    {
        return TOKEN_SUPPLY_CAP - totalSupply(_id);
    }

    // Override ERC1155Tradable for birth events
    function _origin(
        uint256 /* _id */
    ) internal view virtual override returns (address) {
        return owner();
    }

    function _batchMint(
        address _to,
        uint256[] memory _ids,
        uint256[] memory _quantities,
        bytes memory _data
    ) internal virtual override {
        super._batchMint(_to, _ids, _quantities, _data);
        if (_data.length > 1) {
            for (uint256 i = 0; i < _ids.length; i++) {
                _setURI(_ids[i], string(_data));
            }
        }
    }

    function _setURI(uint256 _id, string memory _uri) internal {
        _tokenURI[_id] = _uri;
        emit URI(_uri, _id);
    }

    function _setPermanentURI(uint256 _id, string memory _uri)
        internal
        virtual
    {
        require(
            bytes(_uri).length > 0,
            "AssetContract#setPermanentURI: ONLY_VALID_URI"
        );
        _isPermanentURI[_id] = true;
        _setURI(_id, _uri);
        emit PermanentURI(_uri, _id);
    }
}

// File: @openzeppelin/contracts/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: contracts/TokenIdentifiers.sol



pragma solidity 0.8.4;


/*
  DESIGN NOTES:
  Token ids are a concatenation of:
 * creator: hex address of the creator of the token. 160 bits
 * index: Index for this token (the regular ID), up to 2^56 - 1. 56 bits
 * supply: Supply cap for this token, up to 2^40 - 1 (1 trillion).  40 bits

*/
/**
 * @title TokenIdentifiers
 * support for authentication and metadata for token ids
 */
library TokenIdentifiers {
    uint8 constant ADDRESS_BITS = 160;
    uint8 constant INDEX_BITS = 56;
    uint8 constant SUPPLY_BITS = 40;

    uint256 constant SUPPLY_MASK = (uint256(1) << SUPPLY_BITS) - 1;
    uint256 constant INDEX_MASK =
        ((uint256(1) << INDEX_BITS) - 1) ^ SUPPLY_MASK;

    function tokenMaxSupply(uint256 _id) internal pure returns (uint256) {
        return _id & SUPPLY_MASK;
    }

    function tokenIndex(uint256 _id) internal pure returns (uint256) {
        return _id & INDEX_MASK;
    }

    function tokenCreator(uint256 _id) internal pure returns (address) {
        return address(uint160(_id >> (INDEX_BITS + SUPPLY_BITS)));
    }
}

// File: contracts/AssetContractShared.sol



pragma solidity 0.8.4;




/**
 * @title AssetContractShared
 * OpenSea shared asset contract - A contract for easily creating custom assets on OpenSea
 */
contract AssetContractShared is AssetContract, ReentrancyGuard {
    // Migration contract address
    AssetContractShared public migrationTarget;

    mapping(address => bool) public sharedProxyAddresses;

    struct Ownership {
        uint256 id;
        address owner;
    }

    using TokenIdentifiers for uint256;

    event CreatorChanged(uint256 indexed _id, address indexed _creator);

    mapping(uint256 => address) internal _creatorOverride;

    /**
     * @dev Require msg.sender to be the creator of the token id
     */
    modifier creatorOnly(uint256 _id) {
        require(
            _isCreatorOrProxy(_id, _msgSender()),
            "AssetContractShared#creatorOnly: ONLY_CREATOR_ALLOWED"
        );
        _;
    }

    /**
     * @dev Require the caller to own the full supply of the token
     */
    modifier onlyFullTokenOwner(uint256 _id) {
        require(
            _ownsTokenAmount(_msgSender(), _id, _id.tokenMaxSupply()),
            "AssetContractShared#onlyFullTokenOwner: ONLY_FULL_TOKEN_OWNER_ALLOWED"
        );
        _;
    }

    constructor(
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress,
        string memory _templateURI,
        address _migrationAddress
    ) AssetContract(_name, _symbol, _proxyRegistryAddress, _templateURI) {
        migrationTarget = AssetContractShared(_migrationAddress);
    }

    /**
     * @dev Allows owner to change the proxy registry
     */
    function setProxyRegistryAddress(address _address) public onlyOwnerOrProxy {
        proxyRegistryAddress = _address;
    }

    /**
     * @dev Allows owner to add a shared proxy address
     */
    function addSharedProxyAddress(address _address) public onlyOwnerOrProxy {
        sharedProxyAddresses[_address] = true;
    }

    /**
     * @dev Allows owner to remove a shared proxy address
     */
    function removeSharedProxyAddress(address _address)
        public
        onlyOwnerOrProxy
    {
        delete sharedProxyAddresses[_address];
    }

    /**
     * @dev Allows owner to disable the ability to migrate
     */
    function disableMigrate() public onlyOwnerOrProxy {
        migrationTarget = AssetContractShared(address(0));
    }

    /**
     * @dev Migrate state from previous contract
     */
    function migrate(Ownership[] memory _ownerships) public onlyOwnerOrProxy {
        AssetContractShared _migrationTarget = migrationTarget;
        require(
            _migrationTarget != AssetContractShared(address(0)),
            "AssetContractShared#migrate: MIGRATE_DISABLED"
        );

        string memory _migrationTargetTemplateURI =
            _migrationTarget.templateURI();

        for (uint256 i = 0; i < _ownerships.length; ++i) {
            uint256 id = _ownerships[i].id;
            address owner = _ownerships[i].owner;

            require(
                owner != address(0),
                "AssetContractShared#migrate: ZERO_ADDRESS_NOT_ALLOWED"
            );

            uint256 previousAmount = _migrationTarget.balanceOf(owner, id);

            if (previousAmount == 0) {
                continue;
            }

            _mint(owner, id, previousAmount, "");

            if (
                keccak256(bytes(_migrationTarget.uri(id))) !=
                keccak256(bytes(_migrationTargetTemplateURI))
            ) {
                _setPermanentURI(id, _migrationTarget.uri(id));
            }
        }
    }

    function mint(
        address _to,
        uint256 _id,
        uint256 _quantity,
        bytes memory _data
    ) public override nonReentrant creatorOnly(_id) {
        _mint(_to, _id, _quantity, _data);
    }

    function batchMint(
        address _to,
        uint256[] memory _ids,
        uint256[] memory _quantities,
        bytes memory _data
    ) public override nonReentrant {
        for (uint256 i = 0; i < _ids.length; i++) {
            require(
                _isCreatorOrProxy(_ids[i], _msgSender()),
                "AssetContractShared#_batchMint: ONLY_CREATOR_ALLOWED"
            );
        }
        _batchMint(_to, _ids, _quantities, _data);
    }

    /////////////////////////////////
    // CONVENIENCE CREATOR METHODS //
    /////////////////////////////////

    /**
     * @dev Will update the URI for the token
     * @param _id The token ID to update. msg.sender must be its creator, the uri must be impermanent,
     *            and the creator must own all of the token supply
     * @param _uri New URI for the token.
     */
    function setURI(uint256 _id, string memory _uri)
        public
        override
        creatorOnly(_id)
        onlyImpermanentURI(_id)
        onlyFullTokenOwner(_id)
    {
        _setURI(_id, _uri);
    }

    /**
     * @dev setURI, but permanent
     */
    function setPermanentURI(uint256 _id, string memory _uri)
        public
        override
        creatorOnly(_id)
        onlyImpermanentURI(_id)
        onlyFullTokenOwner(_id)
    {
        _setPermanentURI(_id, _uri);
    }

    /**
     * @dev Change the creator address for given token
     * @param _to   Address of the new creator
     * @param _id  Token IDs to change creator of
     */
    function setCreator(uint256 _id, address _to) public creatorOnly(_id) {
        require(
            _to != address(0),
            "AssetContractShared#setCreator: INVALID_ADDRESS."
        );
        _creatorOverride[_id] = _to;
        emit CreatorChanged(_id, _to);
    }

    /**
     * @dev Get the creator for a token
     * @param _id   The token id to look up
     */
    function creator(uint256 _id) public view returns (address) {
        if (_creatorOverride[_id] != address(0)) {
            return _creatorOverride[_id];
        } else {
            return _id.tokenCreator();
        }
    }

    /**
     * @dev Get the maximum supply for a token
     * @param _id   The token id to look up
     */
    function maxSupply(uint256 _id) public pure returns (uint256) {
        return _id.tokenMaxSupply();
    }

    // Override ERC1155Tradable for birth events
    function _origin(uint256 _id) internal pure override returns (address) {
        return _id.tokenCreator();
    }

    function _requireMintable(address _address, uint256 _id) internal view {
        require(
            _isCreatorOrProxy(_id, _address),
            "AssetContractShared#_requireMintable: ONLY_CREATOR_ALLOWED"
        );
    }

    function _remainingSupply(uint256 _id)
        internal
        view
        override
        returns (uint256)
    {
        return maxSupply(_id) - totalSupply(_id);
    }

    function _isCreatorOrProxy(uint256 _id, address _address)
        internal
        view
        override
        returns (bool)
    {
        address creator_ = creator(_id);
        return creator_ == _address || _isProxyForUser(creator_, _address);
    }

    // Overrides ERC1155Tradable to allow a shared proxy address
    function _isProxyForUser(address _user, address _address)
        internal
        view
        override
        returns (bool)
    {
        if (sharedProxyAddresses[_address]) {
            return true;
        }
        return super._isProxyForUser(_user, _address);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_proxyRegistryAddress","type":"address"},{"internalType":"string","name":"_templateURI","type":"string"},{"internalType":"address","name":"_migrationAddress","type":"address"}],"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":"uint256","name":"_id","type":"uint256"},{"indexed":true,"internalType":"address","name":"_creator","type":"address"}],"name":"CreatorChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_value","type":"string"},{"indexed":true,"internalType":"uint256","name":"_id","type":"uint256"}],"name":"PermanentURI","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addSharedProxyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","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":"address","name":"_from","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_quantities","type":"uint256[]"}],"name":"batchBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_quantities","type":"uint256[]"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"creator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"disableMigrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"isOperator","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"isPermanentURI","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"internalType":"struct AssetContractShared.Ownership[]","name":"_ownerships","type":"tuple[]"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"migrationTarget","outputs":[{"internalType":"contract AssetContractShared","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openSeaVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxyRegistryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeSharedProxyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"setCreator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"}],"name":"setPermanentURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setProxyRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setTemplateURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"sharedProxyAddresses","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"supportsFactoryInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"templateURI","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","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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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000faee4b062449a24a3d0f211d08caac43ee3a1d9b00000000000000000000000000000000000000000000000000000000000000134f70656e53656120436f6c6c656374696f6e730000000000000000000000000000000000000000000000000000000000000000000000000000000000000000094f50454e53544f524500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): OpenSea Collections
Arg [1] : _symbol (string): OPENSTORE
Arg [2] : _proxyRegistryAddress (address): 0x0000000000000000000000000000000000000000
Arg [3] : _templateURI (string):
Arg [4] : _migrationAddress (address): 0xfaee4b062449a24a3d0f211d08caac43ee3a1d9b

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [4] : 000000000000000000000000faee4b062449a24a3d0f211d08caac43ee3a1d9b
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000013
Arg [6] : 4f70656e53656120436f6c6c656374696f6e7300000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [8] : 4f50454e53544f52450000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

75029:7462:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67253:349;;;;;;;;;;-1:-1:-1;67253:349:0;;;;;:::i;:::-;;:::i;:::-;;;19140:25:1;;;19128:2;19113:18;67253:349:0;;;;;;;;23699:310;;;;;;;;;;-1:-1:-1;23699:310:0;;;;;:::i;:::-;;:::i;:::-;;;18967:14:1;;18960:22;18942:41;;18930:2;18915:18;23699:310:0;18897:92:1;47296:18:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;77222:118::-;;;;;;;;;;;;;:::i;:::-;;44365:1179;;;;;;:::i;:::-;;:::i;67002:243::-;;;;;;;;;;-1:-1:-1;67002:243:0;;;;;:::i;:::-;;:::i;41547:43::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;41547:43:0;;;;;66884:110;;;;;;;;;;-1:-1:-1;66884:110:0;;;;;:::i;:::-;66942:4;66966:20;;;:15;:20;;;;;;;;;66884:110;42542:101;;;;;;;;;;-1:-1:-1;42620:15:0;;42542:101;;66371:105;;;;;;;;;;-1:-1:-1;66371:105:0;;;;;:::i;:::-;;:::i;45970:107::-;;;;;;;;;;-1:-1:-1;45970:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;46057:12:0;46023:13;46057:12;;;:6;:12;;;;;;;45970:107;68251:490;;;;;;;;;;-1:-1:-1;68251:490:0;;;;;:::i;:::-;;:::i;77416:1182::-;;;;;;;;;;-1:-1:-1;77416:1182:0;;;;;:::i;:::-;;:::i;42651:161::-;;;;;;;;;;-1:-1:-1;42765:9:0;42651:161;;79989:235;;;;;;;;;;-1:-1:-1;79989:235:0;;;;;:::i;:::-;;:::i;48700:74::-;;;;;;;;;;;;;:::i;65705:95::-;;;;;;;;;;-1:-1:-1;65778:14:0;;;;;;;;;;;;-1:-1:-1;;;65778:14:0;;;;65705:95;;49408:561;;;;;;;;;;-1:-1:-1;49408:561:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;55459:98::-;;;;;;;;;;-1:-1:-1;55459:98:0;;;;;:::i;:::-;55509:4;55533:12;;;:7;:12;;;;;;:16;;;55459:98;80799:232;;;;;;;;;;-1:-1:-1;80799:232:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;15911:32:1;;;15893:51;;15881:2;15866:18;80799:232:0;15848:102:1;75134:42:0;;;;;;;;;;-1:-1:-1;75134:42:0;;;;-1:-1:-1;;;;;75134:42:0;;;39052:86;;;;;;;;;;-1:-1:-1;39123:7:0;;-1:-1:-1;;;39123:7:0;;;;39052:86;;5179:94;;;;;;;;;;;;;:::i;78606:220::-;;;;;;;;;;-1:-1:-1;78606:220:0;;;;;:::i;:::-;;:::i;75185:52::-;;;;;;;;;;-1:-1:-1;75185:52:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;48622:70;;;;;;;;;;;;;:::i;79711:217::-;;;;;;;;;;-1:-1:-1;79711:217:0;;;;;:::i;:::-;;:::i;81150:108::-;;;;;;;;;;-1:-1:-1;81150:108:0;;;;;:::i;:::-;;:::i;4528:87::-;;;;;;;;;;-1:-1:-1;4601:6:0;;-1:-1:-1;;;;;4601:6:0;4528:87;;80405:282;;;;;;;;;;-1:-1:-1;80405:282:0;;;;;:::i;:::-;;:::i;47345:20::-;;;;;;;;;;;;;:::i;76981:155::-;;;;;;;;;;-1:-1:-1;76981:155:0;;;;;:::i;:::-;;:::i;25670:311::-;;;;;;;;;;-1:-1:-1;25670:311:0;;;;;:::i;:::-;;:::i;76767:129::-;;;;;;;;;;-1:-1:-1;76767:129:0;;;;;:::i;:::-;;:::i;78834:470::-;;;;;;;;;;-1:-1:-1;78834:470:0;;;;;:::i;:::-;;:::i;50147:102::-;;;;;;;;;;-1:-1:-1;50147:102:0;;;;;:::i;:::-;50202:7;50229:12;;;:7;:12;;;;;;;50147:102;66270:93;;;;;;;;;;-1:-1:-1;66351:4:0;66270:93;;47232:35;;;;;;;;;;-1:-1:-1;47232:35:0;;;;-1:-1:-1;;;;;47232:35:0;;;76560:125;;;;;;;;;;-1:-1:-1;76560:125:0;;;;;:::i;:::-;;:::i;50381:370::-;;;;;;;;;;-1:-1:-1;50381:370:0;;;;;:::i;:::-;;:::i;67610:633::-;;;;;;;;;;-1:-1:-1;67610:633:0;;;;;:::i;:::-;;:::i;5428:192::-;;;;;;;;;;-1:-1:-1;5428:192:0;;;;;:::i;:::-;;:::i;69095:207::-;;;;;;;;;;-1:-1:-1;69095:207:0;;;;;:::i;:::-;;:::i;69382:442::-;;;;;;;;;;-1:-1:-1;69382:442:0;;;;;:::i;:::-;;:::i;64558:25::-;;;;;;;;;;;;;:::i;67253:349::-;67384:7;67409:15;67427:28;67443:6;67451:3;67427:15;:28::i;:::-;67409:46;;67486:30;67504:3;67509:6;67486:17;:30::i;:::-;:108;;67587:7;67486:108;;;67546:21;67563:3;67546:16;:21::i;:::-;67536:31;;:7;:31;:::i;:::-;67466:128;;;67253:349;;;;;:::o;23699:310::-;23801:4;-1:-1:-1;;;;;;23838:41:0;;-1:-1:-1;;;23838:41:0;;:110;;-1:-1:-1;;;;;;;23896:52:0;;-1:-1:-1;;;23896:52:0;23838:110;:163;;;-1:-1:-1;;;;;;;;;;22629:40:0;;;23965:36;22520:157;47296:18;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;77222:118::-;47997:29;48013:12;:10;:12::i;:::-;47997:15;:29::i;:::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;;;;;;;;;77283:15:::1;:49:::0;;-1:-1:-1;;;;;;77283:49:0::1;::::0;;77222:118::o;44365:1179::-;44638:168;;;44568:12;44638:168;;;;;-1:-1:-1;;;;;44680:19:0;;44593:29;44680:19;;;:6;:19;;;;;;;;;44638:168;;;;;;;;;;;44841:45;44687:11;44638:168;44869:4;44875;44881;44841:6;:45::i;:::-;44819:128;;;;-1:-1:-1;;;44819:128:0;;29815:2:1;44819:128:0;;;29797:21:1;29854:2;29834:18;;;29827:30;29893:34;29873:18;;;29866:62;-1:-1:-1;;;29944:18:1;;;29937:31;29985:19;;44819:128:0;29787:223:1;44819:128:0;-1:-1:-1;;;;;45014:19:0;;;;;;:6;:19;;;;;:24;;45037:1;;45014:19;:24;;45037:1;;45014:24;:::i;:::-;;;;-1:-1:-1;;45056:126:0;;;;;;45094:11;;45128:10;;45154:17;;45056:126;:::i;:::-;;;;;;;;45293:12;45307:23;45355:4;-1:-1:-1;;;;;45347:18:0;45401:17;45420:11;45384:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;45384:48:0;;;;;;;;;;45347:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45292:155;;;;45466:7;45458:48;;;;-1:-1:-1;;;45458:48:0;;23718:2:1;45458:48:0;;;23700:21:1;23757:2;23737:18;;;23730:30;23796;23776:18;;;23769:58;23844:18;;45458:48:0;23690:178:1;45458:48:0;45526:10;44365:1179;-1:-1:-1;;;;;;;;44365:1179:0:o;67002:243::-;67084:22;67109:14;;;:9;:14;;;;;67084:39;;67058:13;;67084:22;67109:14;67084:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67144:8;67138:22;67164:1;67138:27;67134:75;;67189:8;67002:243;-1:-1:-1;;67002:243:0:o;67134:75::-;67226:11;67219:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67002:243;;;:::o;66371:105::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;66450:18;;::::1;::::0;:11:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;66371:105:::0;:::o;68251:490::-;68496:8;:15;68481:4;:11;:30;68459:138;;;;-1:-1:-1;;;68459:138:0;;33176:2:1;68459:138:0;;;33158:21:1;33215:2;33195:18;;;33188:30;33254:34;33234:18;;;33227:62;33325:28;33305:18;;;33298:56;33371:19;;68459:138:0;33148:248:1;68459:138:0;68613:9;68608:126;68632:4;:11;68628:1;:15;68608:126;;;68665:57;68682:5;68689:3;68694:4;68699:1;68694:7;;;;;;-1:-1:-1;;;68694:7:0;;;;;;;;;;;;;;;68703:8;68712:1;68703:11;;;;;;-1:-1:-1;;;68703:11:0;;;;;;;;;;;;;;;68716:5;68665:16;:57::i;:::-;68645:3;;;;:::i;:::-;;;;68608:126;;;;68251:490;;;;;:::o;77416:1182::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;77539:15:::1;::::0;-1:-1:-1;;;;;77539:15:0::1;77587:51:::0;77565:146:::1;;;::::0;-1:-1:-1;;;77565:146:0;;31942:2:1;77565:146:0::1;::::0;::::1;31924:21:1::0;31981:2;31961:18;;;31954:30;32020:34;32000:18;;;31993:62;-1:-1:-1;;;32071:18:1;;;32064:43;32124:19;;77565:146:0::1;31914:235:1::0;77565:146:0::1;77724:41;77781:16;-1:-1:-1::0;;;;;77781:28:0::1;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;77781:30:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;77724:87;;77829:9;77824:767;77848:11;:18;77844:1;:22;77824:767;;;77888:10;77901:11;77913:1;77901:14;;;;;;-1:-1:-1::0;;;77901:14:0::1;;;;;;;;;;;;;;;:17;;;77888:30;;77933:13;77949:11;77961:1;77949:14;;;;;;-1:-1:-1::0;;;77949:14:0::1;;;;;;;;;;;;;;;:20;;;77933:36;;78029:1;-1:-1:-1::0;;;;;78012:19:0::1;:5;-1:-1:-1::0;;;;;78012:19:0::1;;;77986:134;;;::::0;-1:-1:-1;;;77986:134:0;;30693:2:1;77986:134:0::1;::::0;::::1;30675:21:1::0;30732:2;30712:18;;;30705:30;30771:34;30751:18;;;30744:62;-1:-1:-1;;;30822:18:1;;;30815:51;30883:19;;77986:134:0::1;30665:243:1::0;77986:134:0::1;78162:37;::::0;-1:-1:-1;;;78162:37:0;;-1:-1:-1;;;;;17979:32:1;;;78162:37:0::1;::::0;::::1;17961:51:1::0;18028:18;;;18021:34;;;78137:22:0::1;::::0;78162:26;;::::1;::::0;::::1;::::0;17934:18:1;;78162:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78137:62:::0;-1:-1:-1;78220:19:0;78216:68:::1;;78260:8;;;;;78216:68;78300:36;78306:5;78313:2;78317:14;78300:36;;;;;;;;;;;::::0;:5:::1;:36::i;:::-;78438:45:::0;;::::1;::::0;::::1;::::0;78391:24:::1;::::0;-1:-1:-1;;;78391:24:0;;::::1;::::0;::::1;19140:25:1::0;;;-1:-1:-1;;;;;78391:20:0;::::1;::::0;::::1;::::0;19113:18:1;;78391:24:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;78391:24:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;78375:42;;;;;;:108;78353:227;;78539:24;::::0;-1:-1:-1;;;78539:24:0;;::::1;::::0;::::1;19140:25:1::0;;;78518:46:0::1;::::0;78535:2;;-1:-1:-1;;;;;78539:20:0;::::1;::::0;::::1;::::0;19113:18:1;;78539:24:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;78539:24:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;78518:16;:46::i;:::-;77824:767;;;;77868:3;::::0;::::1;:::i;:::-;;;77824:767;;;;48111:1;;77416:1182:::0;:::o;79989:235::-;80102:3;75656:36;75674:3;75679:12;:10;:12::i;:::-;75656:17;:36::i;:::-;75634:139;;;;-1:-1:-1;;;75634:139:0;;;;;;;:::i;:::-;66942:4;66966:20;;;:15;:20;;;;;;80135:3;;66966:20;;65245:19:::1;65223:124;;;;-1:-1:-1::0;;;65223:124:0::1;;;;;;;:::i;:::-;80168:3:::2;75961:57;75978:12;:10;:12::i;:::-;75992:3;75997:20;:3;:18;:20::i;:::-;75961:16;:57::i;:::-;75939:176;;;;-1:-1:-1::0;;;75939:176:0::2;;;;;;;:::i;:::-;80189:27:::3;80206:3;80211:4;80189:16;:27::i;:::-;65358:1:::2;75784::::1;79989:235:::0;;;:::o;48700:74::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;48756:10:::1;:8;:10::i;:::-;48700:74::o:0;49408:561::-;49564:16;49639:3;:10;49620:8;:15;:29;49598:120;;;;-1:-1:-1;;;49598:120:0;;32766:2:1;49598:120:0;;;32748:21:1;32805:2;32785:18;;;32778:30;32844:34;32824:18;;;32817:62;-1:-1:-1;;;32895:18:1;;;32888:39;32944:19;;49598:120:0;32738:231:1;49598:120:0;49731:30;49778:8;:15;-1:-1:-1;;;;;49764:30:0;;;;;-1:-1:-1;;;49764:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49764:30:0;;49731:63;;49812:9;49807:122;49831:8;:15;49827:1;:19;49807:122;;;49887:30;49897:8;49906:1;49897:11;;;;;;-1:-1:-1;;;49897:11:0;;;;;;;;;;;;;;;49910:3;49914:1;49910:6;;;;;;-1:-1:-1;;;49910:6:0;;;;;;;;;;;;;;;49887:9;:30::i;:::-;49868:13;49882:1;49868:16;;;;;;-1:-1:-1;;;49868:16:0;;;;;;;;;;;;;;;;;;:49;49848:3;;;:::i;:::-;;;49807:122;;;-1:-1:-1;49948:13:0;49408:561;-1:-1:-1;;;49408:561:0:o;80799:232::-;80850:7;80874:21;;;:16;:21;;;;;;-1:-1:-1;;;;;80874:21:0;:35;80870:154;;-1:-1:-1;80933:21:0;;;;:16;:21;;;;;;-1:-1:-1;;;;;80933:21:0;;80799:232::o;80870:154::-;80994:18;:3;:16;:18::i;5179:94::-;4759:12;:10;:12::i;:::-;-1:-1:-1;;;;;4748:23:0;:7;4601:6;;-1:-1:-1;;;;;4601:6:0;;4528:87;4748:7;-1:-1:-1;;;;;4748:23:0;;4740:68;;;;-1:-1:-1;;;4740:68:0;;29454:2:1;4740:68:0;;;29436:21:1;;;29473:18;;;29466:30;29532:34;29512:18;;;29505:62;29584:18;;4740:68:0;29426:182:1;4740:68:0;5244:21:::1;5262:1;5244:9;:21::i;78606:220::-:0;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;35200:2:1;2335:63:0;;;35182:21:1;35239:2;35219:18;;;35212:30;35278:33;35258:18;;;35251:61;35329:18;;2335:63:0;35172:181:1;2335:63:0;1747:1;2476:7;:18;78769:3;75656:36:::1;78769:3:::0;75679:12:::1;:10;:12::i;75656:36::-;75634:139;;;;-1:-1:-1::0;;;75634:139:0::1;;;;;;;:::i;:::-;78785:33:::2;78791:3;78796;78801:9;78812:5;78785;:33::i;:::-;-1:-1:-1::0;;1703:1:0;2655:7;:22;-1:-1:-1;;;78606:220:0:o;48622:70::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;48676:8:::1;:6;:8::i;79711:217::-:0;79815:3;75656:36;75674:3;75679:12;:10;:12::i;75656:36::-;75634:139;;;;-1:-1:-1;;;75634:139:0;;;;;;;:::i;:::-;66942:4;66966:20;;;:15;:20;;;;;;79848:3;;66966:20;;65245:19:::1;65223:124;;;;-1:-1:-1::0;;;65223:124:0::1;;;;;;;:::i;:::-;79881:3:::2;75961:57;75978:12;:10;:12::i;75961:57::-;75939:176;;;;-1:-1:-1::0;;;75939:176:0::2;;;;;;;:::i;:::-;79902:18:::3;79910:3;79915:4;79902:7;:18::i;81150:108::-:0;81203:7;81230:20;:3;:18;:20::i;80405:282::-;80470:3;75656:36;75674:3;75679:12;:10;:12::i;75656:36::-;75634:139;;;;-1:-1:-1;;;75634:139:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;80508:17:0;::::1;80486:115;;;::::0;-1:-1:-1;;;80486:115:0;;25321:2:1;80486:115:0::1;::::0;::::1;25303:21:1::0;25360:2;25340:18;;;25333:30;25399:34;25379:18;;;25372:62;-1:-1:-1;;;25450:18:1;;;25443:46;25506:19;;80486:115:0::1;25293:238:1::0;80486:115:0::1;80612:21;::::0;;;:16:::1;:21;::::0;;;;;:27;;-1:-1:-1;;;;;;80612:27:0::1;-1:-1:-1::0;;;;;80612:27:0;::::1;::::0;;::::1;::::0;;;80655:24;;80612:27;;:21;;80655:24:::1;::::0;80612:21;80655:24:::1;80405:282:::0;;;:::o;47345:20::-;;;;;;;:::i;76981:155::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;77098:30:0::1;;::::0;;;:20:::1;:30;::::0;;;;77091:37;;-1:-1:-1;;77091:37:0::1;::::0;;76981:155::o;25670:311::-;25789:8;-1:-1:-1;;;;;25773:24:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;25773:24:0;;;25765:78;;;;-1:-1:-1;;;25765:78:0;;32356:2:1;25765:78:0;;;32338:21:1;32395:2;32375:18;;;32368:30;32434:34;32414:18;;;32407:62;-1:-1:-1;;;32485:18:1;;;32478:39;32534:19;;25765:78:0;32328:231:1;25765:78:0;25901:8;25856:18;:32;25875:12;:10;:12::i;:::-;-1:-1:-1;;;;;25856:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;25856:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;25856:53:0;;;;;;;;;;;25940:12;:10;:12::i;:::-;-1:-1:-1;;;;;25925:48:0;;25964:8;25925:48;;;;18967:14:1;18960:22;18942:41;;18930:2;18915:18;;18897:92;25925:48:0;;;;;;;;25670:311;;:::o;76767:129::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;76851:30:0::1;;::::0;;;:20:::1;:30;::::0;;;;:37;;-1:-1:-1;;76851:37:0::1;76884:4;76851:37;::::0;;76767:129::o;78834:470::-;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;35200:2:1;2335:63:0;;;35182:21:1;35239:2;35219:18;;;35212:30;35278:33;35258:18;;;35251:61;35329:18;;2335:63:0;35172:181:1;2335:63:0;1747:1;2476:7;:18;79027:9:::1;79022:223;79046:4;:11;79042:1;:15;79022:223;;;79105:40;79123:4;79128:1;79123:7;;;;;;-1:-1:-1::0;;;79123:7:0::1;;;;;;;;;;;;;;;79132:12;:10;:12::i;79105:40::-;79079:154;;;::::0;-1:-1:-1;;;79079:154:0;;31115:2:1;79079:154:0::1;::::0;::::1;31097:21:1::0;31154:2;31134:18;;;31127:30;31193:34;31173:18;;;31166:62;-1:-1:-1;;;31244:18:1;;;31237:50;31304:19;;79079:154:0::1;31087:242:1::0;79079:154:0::1;79059:3:::0;::::1;::::0;::::1;:::i;:::-;;;;79022:223;;;;79255:41;79266:3;79271:4;79277:11;79290:5;79255:10;:41::i;:::-;-1:-1:-1::0;;1703:1:0;2655:7;:22;-1:-1:-1;;78834:470:0:o;76560:125::-;47997:29;48013:12;:10;:12::i;47997:29::-;47975:125;;;;-1:-1:-1;;;47975:125:0;;;;;;;:::i;:::-;76646:20:::1;:31:::0;;-1:-1:-1;;;;;;76646:31:0::1;-1:-1:-1::0;;;;;76646:31:0;;;::::1;::::0;;;::::1;::::0;;76560:125::o;50381:370::-;50508:15;50609:34;50625:6;50633:9;50609:15;:34::i;:::-;50605:78;;;-1:-1:-1;50667:4:0;50660:11;;50605:78;-1:-1:-1;;;;;26176:27:0;;;26152:4;26176:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;50702:41;50695:48;50381:370;-1:-1:-1;;;50381:370:0:o;67610:633::-;67793:21;67817:27;67833:5;67840:3;67817:15;:27::i;:::-;67793:51;;67875:7;67859:13;:23;67855:381;;;67957:46;67962:3;67967;67972:23;67982:13;67972:7;:23;:::i;:::-;67997:5;67957:4;:46::i;:::-;68022:17;;68018:119;;68060:61;68083:5;68090:3;68095;68100:13;68115:5;68060:22;:61::i;:::-;67855:381;;;68169:55;68192:5;68199:3;68204;68209:7;68218:5;68169:22;:55::i;5428:192::-;4759:12;:10;:12::i;:::-;-1:-1:-1;;;;;4748:23:0;:7;4601:6;;-1:-1:-1;;;;;4601:6:0;;4528:87;4748:7;-1:-1:-1;;;;;4748:23:0;;4740:68;;;;-1:-1:-1;;;4740:68:0;;29454:2:1;4740:68:0;;;29436:21:1;;;29473:18;;;29466:30;29532:34;29512:18;;;29505:62;29584:18;;4740:68:0;29426:182:1;4740:68:0;-1:-1:-1;;;;;5517:22:0;::::1;5509:73;;;::::0;-1:-1:-1;;;5509:73:0;;23311:2:1;5509:73:0::1;::::0;::::1;23293:21:1::0;23350:2;23330:18;;;23323:30;23389:34;23369:18;;;23362:62;-1:-1:-1;;;23440:18:1;;;23433:36;23486:19;;5509:73:0::1;23283:228:1::0;5509:73:0::1;5593:19;5603:8;5593:9;:19::i;:::-;5428:192:::0;:::o;69095:207::-;69227:5;69234:3;69239:9;64945:39;64962:5;64969:3;64974:9;64945:16;:39::i;:::-;64923:156;;;;-1:-1:-1;;;64923:156:0;;30217:2:1;64923:156:0;;;30199:21:1;30256:2;30236:18;;;30229:30;30295:34;30275:18;;;30268:62;30366:34;30346:18;;;30339:62;-1:-1:-1;;;30417:19:1;;;30410:34;30461:19;;64923:156:0;30189:297:1;64923:156:0;69261:33:::1;69272:5;69279:3;69284:9;69261:10;:33::i;69382:442::-:0;69535:9;69530:235;69554:4;:11;69550:1;:15;69530:235;;;69613:48;69630:5;69637:4;69642:1;69637:7;;;;;;-1:-1:-1;;;69637:7:0;;;;;;;;;;;;;;;69646:11;69658:1;69646:14;;;;;;-1:-1:-1;;;69646:14:0;;;;;;;;;;;;;;;69613:16;:48::i;:::-;69587:166;;;;-1:-1:-1;;;69587:166:0;;35560:2:1;69587:166:0;;;35542:21:1;35599:2;35579:18;;;35572:30;35638:34;35618:18;;;35611:62;35709:26;35689:18;;;35682:54;35753:19;;69587:166:0;35532:246:1;69587:166:0;69567:3;;;;:::i;:::-;;;;69530:235;;;;69775:41;69791:5;69798:4;69804:11;69775:15;:41::i;:::-;69382:442;;;:::o;64558:25::-;;;;;;;:::i;40370:618::-;40414:22;40453:10;40475:4;40453:27;40449:508;;;40497:18;40518:8;;40497:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;40557:8:0;40768:17;40762:24;-1:-1:-1;;;;;40736:134:0;;-1:-1:-1;40596:289:0;;-1:-1:-1;40596:289:0;;-1:-1:-1;40934:10:0;40449:508;40370:618;:::o;60820:376::-;60972:20;;60945:4;;-1:-1:-1;;;;;60972:20:0;14931;60967:79;;-1:-1:-1;61029:5:0;61022:12;;60967:79;61100:20;;61147:28;;-1:-1:-1;;;61147:28:0;;-1:-1:-1;;;;;15911:32:1;;;61147:28:0;;;15893:51:1;61100:20:0;;;;61139:49;;;61100:20;;61147:21;;15866:18:1;;61147:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;61139:49:0;;;60820:376;-1:-1:-1;;;;60820:376:0:o;14608:387::-;14931:20;14979:8;;;14608:387::o;48925:317::-;49056:7;-1:-1:-1;;;;;49103:21:0;;49081:114;;;;-1:-1:-1;;;49081:114:0;;22899:2:1;49081:114:0;;;22881:21:1;22938:2;22918:18;;;22911:30;22977:34;22957:18;;;22950:62;-1:-1:-1;;;23028:18:1;;;23021:41;23079:19;;49081:114:0;22871:233:1;49081:114:0;-1:-1:-1;49213:12:0;;;;:8;:12;;;;;;;;-1:-1:-1;;;;;49213:21:0;;;;;;;;;;;;48925:317::o;81865:264::-;81991:4;82013:16;82032:12;82040:3;82032:7;:12::i;:::-;82013:31;;82074:8;-1:-1:-1;;;;;82062:20:0;:8;-1:-1:-1;;;;;82062:20:0;;:59;;;;82086:35;82102:8;82112;82086:15;:35::i;81677:180::-;81784:7;50229:12;;;:7;:12;;;;;;81816:14;81826:3;81816:9;:14::i;:::-;:33;;;;:::i;64083:120::-;64137:14;64171:24;:22;:24::i;:::-;64164:31;;64083:120;:::o;48459:155::-;48525:4;48560:8;-1:-1:-1;;;;;48549:19:0;:7;4601:6;;-1:-1:-1;;;;;4601:6:0;;4528:87;48549:7;-1:-1:-1;;;;;48549:19:0;;:57;;;;48572:34;48588:7;4601:6;;-1:-1:-1;;;;;4601:6:0;;4528:87;48588:7;48597:8;48572:15;:34::i;46085:486::-;46263:4;-1:-1:-1;;;;;46288:20:0;;46280:70;;;;-1:-1:-1;;;46280:70:0;;27469:2:1;46280:70:0;;;27451:21:1;27508:2;27488:18;;;27481:30;27547:34;27527:18;;;27520:62;-1:-1:-1;;;27598:18:1;;;27591:35;27643:19;;46280:70:0;27441:227:1;46280:70:0;46404:159;46432:47;46451:27;46471:6;46451:19;:27::i;:::-;46432:18;:47::i;:::-;46404:159;;;;;;;;;;;;19825:25:1;;;;19898:4;19886:17;;19866:18;;;19859:45;19920:18;;;19913:34;;;19963:18;;;19956:34;;;19797:19;;46404:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;46381:182:0;:6;-1:-1:-1;;;;;46381:182:0;;46361:202;;46085:486;;;;;;;:::o;69832:285::-;69984:39;69996:3;70001;70006:9;70017:5;69984:11;:39::i;:::-;70053:1;70038:5;:12;:16;70034:76;;;70071:27;70079:3;70091:5;70071:7;:27::i;71249:341::-;71402:1;71387:4;71381:18;:22;71359:117;;;;-1:-1:-1;;;71359:117:0;;27055:2:1;71359:117:0;;;27037:21:1;27094:2;27074:18;;;27067:30;27133:34;27113:18;;;27106:62;-1:-1:-1;;;27184:18:1;;;27177:43;27237:19;;71359:117:0;27027:235:1;71359:117:0;71487:20;;;;:15;:20;;;;;:27;;-1:-1:-1;;71487:27:0;71510:4;71487:27;;;71525:18;71503:3;71538:4;71525:7;:18::i;:::-;71578:3;71559:23;71572:4;71559:23;;;;;;:::i;:::-;;;;;;;;71249:341;;:::o;74428:112::-;74488:7;74296:31;74326:1;74297:25;74296:31;:::i;:::-;74515:17;;;;74428:112;-1:-1:-1;74428:112:0:o;65894:196::-;66024:4;66073:9;66048:21;66058:5;66065:3;66048:9;:21::i;:::-;:34;;;65894:196;-1:-1:-1;;;;65894:196:0:o;40111:120::-;39123:7;;-1:-1:-1;;;39123:7:0;;;;39647:41;;;;-1:-1:-1;;;39647:41:0;;22144:2:1;39647:41:0;;;22126:21:1;22183:2;22163:18;;;22156:30;-1:-1:-1;;;22202:18:1;;;22195:50;22262:18;;39647:41:0;22116:170:1;39647:41:0;40170:7:::1;:15:::0;;-1:-1:-1;;;;40170:15:0::1;::::0;;40201:22:::1;40210:12;:10;:12::i;:::-;40201:22;::::0;-1:-1:-1;;;;;15911:32:1;;;15893:51;;15881:2;15866:18;40201:22:0::1;;;;;;;40111:120::o:0;74663:144::-;74721:7;74772:24;74254:2;74216;74772:24;:::i;:::-;74764:33;;;;;;;74663:144;-1:-1:-1;74663:144:0:o;5628:173::-;5703:6;;;-1:-1:-1;;;;;5720:17:0;;;-1:-1:-1;;;;;;5720:17:0;;;;;;;5753:40;;5703:6;;;5720:17;5703:6;;5753:40;;5684:16;;5753:40;5628:173;;:::o;39852:118::-;39123:7;;-1:-1:-1;;;39123:7:0;;;;39377:9;39369:38;;;;-1:-1:-1;;;39369:38:0;;;;;;;:::i;:::-;39912:7:::1;:14:::0;;-1:-1:-1;;;;39912:14:0::1;-1:-1:-1::0;;;39912:14:0::1;::::0;;39942:20:::1;39949:12;:10;:12::i;71112:129::-:0;71182:14;;;;:9;:14;;;;;;;;:21;;;;;;;;:::i;:::-;;71229:3;71219:14;71223:4;71219:14;;;;;;:::i;70697:407::-;70883:47;70900:3;70905:4;70911:11;70924:5;70883:16;:47::i;:::-;70960:1;70945:5;:12;:16;70941:156;;;70983:9;70978:108;71002:4;:11;70998:1;:15;70978:108;;;71039:31;71047:4;71052:1;71047:7;;;;;;-1:-1:-1;;;71047:7:0;;;;;;;;;;;;;;;71063:5;71039:7;:31::i;:::-;71015:3;;;;:::i;:::-;;;;70978:108;;82203:285;-1:-1:-1;;;;;82355:30:0;;82329:4;82355:30;;;:20;:30;;;;;;;;82351:74;;;-1:-1:-1;82409:4:0;82402:11;;82351:74;82442:38;82464:5;82471:8;82442:21;:38::i;50823:943::-;39123:7;;-1:-1:-1;;;39123:7:0;;;;39377:9;39369:38;;;;-1:-1:-1;;;39369:38:0;;;;;;;:::i;:::-;51025:4:::1;48302:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48293:21:0::1;:5;-1:-1:-1::0;;;;;48293:21:0::1;;:62;;;;48318:37;48335:5;48342:12;:10;:12::i;48318:37::-;48271:160;;;;-1:-1:-1::0;;;48271:160:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;51050:16:0;::::2;51042:66;;;::::0;-1:-1:-1;;;51042:66:0;;28220:2:1;51042:66:0::2;::::0;::::2;28202:21:1::0;28259:2;28239:18;;;28232:30;28298:34;28278:18;;;28271:62;-1:-1:-1;;;28349:18:1;;;28342:35;28394:19;;51042:66:0::2;28192:227:1::0;51042:66:0::2;51121:16;51140:12;:10;:12::i;:::-;51121:31;;51165:183;51200:8;51223:4;51242:2;51259:20;51276:2;51259:16;:20::i;:::-;51294:24;51311:6;51294:16;:24::i;51165:183::-;51361:19;51383:12:::0;;;:8:::2;:12;::::0;;;;;;;-1:-1:-1;;;;;51383:18:0;::::2;::::0;;;;;;;;51434:21;;::::2;;51412:113;;;::::0;-1:-1:-1;;;51412:113:0;;29043:2:1;51412:113:0::2;::::0;::::2;29025:21:1::0;29082:2;29062:18;;;29055:30;29121:34;29101:18;;;29094:62;-1:-1:-1;;;29172:18:1;;;29165:40;29222:19;;51412:113:0::2;29015:232:1::0;51412:113:0::2;51557:20;51571:6:::0;51557:11;:20:::2;:::i;:::-;51536:12;::::0;;;:8:::2;:12;::::0;;;;;;;-1:-1:-1;;;;;51536:18:0;;::::2;::::0;;;;;;;:41;;;;51588:16;::::2;::::0;;;;;:26;;51608:6;;51536:12;51588:26:::2;::::0;51608:6;;51588:26:::2;:::i;:::-;::::0;;;-1:-1:-1;;51632:46:0::2;::::0;;36139:25:1;;;36195:2;36180:18;;36173:34;;;-1:-1:-1;;;;;51632:46:0;;::::2;::::0;;;::::2;::::0;;;::::2;::::0;::::2;::::0;36112:18:1;51632:46:0::2;;;;;;;51691:67;51721:8;51731:4;51737:2;51741;51745:6;51753:4;51691:29;:67::i;:::-;48442:1;;39418::::1;50823:943:::0;;;;;:::o;54621:177::-;54744:5;48302:12;:10;:12::i;:::-;-1:-1:-1;;;;;48293:21:0;:5;-1:-1:-1;;;;;48293:21:0;;:62;;;;48318:37;48335:5;48342:12;:10;:12::i;48318:37::-;48271:160;;;;-1:-1:-1;;;48271:160:0;;;;;;;:::i;:::-;54762:28:::1;54768:5;54775:3;54780:9;54762:5;:28::i;55048:211::-:0;55197:5;48302:12;:10;:12::i;:::-;-1:-1:-1;;;;;48293:21:0;:5;-1:-1:-1;;;;;48293:21:0;;:62;;;;48318:37;48335:5;48342:12;:10;:12::i;48318:37::-;48271:160;;;;-1:-1:-1;;;48271:160:0;;;;;;;:::i;:::-;55215:36:::1;55226:5;55233:4;55239:11;55215:10;:36::i;45552:410::-:0;45662:7;43689:108;;;;;;;;;;;;;;;;;43665:143;;;;;;;45816:12;;45851:11;;;;45895:24;;;;;45885:35;;;;;;45735:204;;;;;19407:25:1;;;19463:2;19448:18;;19441:34;;;;-1:-1:-1;;;;;19511:32:1;19506:2;19491:18;;19484:60;19575:2;19560:18;;19553:34;19394:3;19379:19;;19361:232;45735:204:0;;;;;;;;;;;;;45707:247;;;;;;45687:267;;45552:410;;;:::o;43181:258::-;43280:7;43382:20;42620:15;;;42542:101;43382:20;43353:63;;-1:-1:-1;;;43353:63:0;;;15608:27:1;15651:11;;;15644:27;;;;15687:12;;;15680:28;;;15724:12;;43353:63:0;15598:144:1;55677:982:0;39123:7;;-1:-1:-1;;;39123:7:0;;;;39377:9;39369:38;;;;-1:-1:-1;;;39369:38:0;;;;;;;:::i;:::-;55849:16:::1;55868:12;:10;:12::i;:::-;55849:31;;55893:193;55928:8;55959:1;55976:3;55994:21;56011:3;55994:16;:21::i;:::-;56030:25;56047:7;56030:16;:25::i;55893:193::-;56099:25;56111:3;56116:7;56099:11;:25::i;:::-;56161:13;::::0;;;:8:::1;:13;::::0;;;;;;;-1:-1:-1;;;;;56161:18:0;::::1;::::0;;;;;;;:29;;56183:7;;56161:13;:29:::1;::::0;56183:7;;56161:29:::1;:::i;:::-;::::0;;;-1:-1:-1;;56201:12:0::1;::::0;;;:7:::1;:12;::::0;;;;:23;;56217:7;;56201:12;:23:::1;::::0;56217:7;;56201:23:::1;:::i;:::-;::::0;;;-1:-1:-1;56293:14:0::1;::::0;-1:-1:-1;56310:12:0::1;56318:3:::0;56310:7:::1;:12::i;:::-;56293:29;;56396:3;-1:-1:-1::0;;;;;56363:51:0::1;56388:6;-1:-1:-1::0;;;;;56363:51:0::1;56378:8;-1:-1:-1::0;;;;;56363:51:0::1;;56401:3;56406:7;56363:51;;;;;;36139:25:1::0;;;36195:2;36180:18;;36173:34;36127:2;36112:18;;36094:119;56363:51:0::1;;;;;;;;56489:162;56533:8;56556:6;56577:3;56595;56613:7;56635:5;56489:29;:162::i;56775:1461::-:0;39123:7;;-1:-1:-1;;;39123:7:0;;;;39377:9;39369:38;;;;-1:-1:-1;;;39369:38:0;;;;;;;:::i;:::-;57000:8:::1;:15;56985:4;:11;:30;56963:128;;;::::0;-1:-1:-1;;;56963:128:0;;28626:2:1;56963:128:0::1;::::0;::::1;28608:21:1::0;28665:2;28645:18;;;28638:30;28704:34;28684:18;;;28677:62;-1:-1:-1;;;28755:18:1;;;28748:46;28811:19;;56963:128:0::1;28598:238:1::0;56963:128:0::1;57159:11:::0;;57143:13:::1;57257:16;57159:4:::0;57143:13;57265:7;::::1;;-1:-1:-1::0;;;57265:7:0::1;;;;;;;;;;;;;;;57257;:16::i;:::-;57240:33;;57286:16;57305:12;:10;:12::i;:::-;57286:31;;57452:9;57447:434;57471:5;57467:1;:9;57447:434;;;57537:10;57550:4;57555:1;57550:7;;;;;;-1:-1:-1::0;;;57550:7:0::1;;;;;;;;;;;;;;;57537:20;;57572:14;57589:8;57598:1;57589:11;;;;;;-1:-1:-1::0;;;57589:11:0::1;;;;;;;;;;;;;;;57572:28;;57615:23;57627:2;57631:6;57615:11;:23::i;:::-;57694:6;-1:-1:-1::0;;;;;57679:21:0::1;:11;57687:2;57679:7;:11::i;:::-;-1:-1:-1::0;;;;;57679:21:0::1;;57653:138;;;::::0;-1:-1:-1;;;57653:138:0;;25738:2:1;57653:138:0::1;::::0;::::1;25720:21:1::0;25777:2;25757:18;;;25750:30;25816:34;25796:18;;;25789:62;25887:25;25867:18;;;25860:53;25930:19;;57653:138:0::1;25710:245:1::0;57653:138:0::1;57806:12;::::0;;;:8:::1;:12;::::0;;;;;;;-1:-1:-1;;;;;57806:17:0;::::1;::::0;;;;;;;:27;;57827:6;;57806:12;:27:::1;::::0;57827:6;;57806:27:::1;:::i;:::-;::::0;;;-1:-1:-1;;57848:11:0::1;::::0;;;:7:::1;:11;::::0;;;;:21;;57863:6;;57848:11;:21:::1;::::0;57863:6;;57848:21:::1;:::i;:::-;;;;;;;;57447:434;;57478:3;;;;;:::i;:::-;;;;57447:434;;;;57964:3;-1:-1:-1::0;;;;;57932:52:0::1;57956:6;-1:-1:-1::0;;;;;57932:52:0::1;57946:8;-1:-1:-1::0;;;;;57932:52:0::1;;57969:4;57975:8;57932:52;;;;;;;:::i;:::-;;;;;;;;58059:169;58108:8;58131:6;58152:3;58170:4;58189:8;58212:5;58059:34;:169::i;:::-;39418:1;;;56775:1461:::0;;;;:::o;63710:229::-;63861:16;;;63875:1;63861:16;;;;;;;;;63802;;63836:22;;63861:16;;;;;;;;;;;;-1:-1:-1;63861:16:0;63836:41;;63899:7;63888:5;63894:1;63888:8;;;;;;-1:-1:-1;;;63888:8:0;;;;;;;;;;;;;;;;;;:18;63926:5;63710:229;-1:-1:-1;;63710:229:0:o;61387:941::-;-1:-1:-1;;;;;61601:13:0;;14931:20;14979:8;61597:724;;61654:196;;-1:-1:-1;;;61654:196:0;;-1:-1:-1;;;;;61654:38:0;;;;;:196;;61715:8;;61746:4;;61773:2;;61798:6;;61827:4;;61654:196;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61654:196:0;;;;;;;;-1:-1:-1;;61654:196:0;;;;;;;;;;;;:::i;:::-;;;61633:677;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;62183:6;62176:14;;-1:-1:-1;;;62176:14:0;;;;;;;;:::i;61633:677::-;;;62232:62;;-1:-1:-1;;;62232:62:0;;20885:2:1;62232:62:0;;;20867:21:1;20924:2;20904:18;;;20897:30;20963:34;20943:18;;;20936:62;-1:-1:-1;;;21014:18:1;;;21007:50;21074:19;;62232:62:0;20857:242:1;61633:677:0;-1:-1:-1;;;;;;61935:59:0;;-1:-1:-1;;;61935:59:0;61909:198;;62037:50;;-1:-1:-1;;;62037:50:0;;;;;;;:::i;58495:880::-;39123:7;;-1:-1:-1;;;39123:7:0;;;;39377:9;39369:38;;;;-1:-1:-1;;;39369:38:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;58640:21:0;::::1;58632:71;;;::::0;-1:-1:-1;;;58632:71:0;;22493:2:1;58632:71:0::1;::::0;::::1;22475:21:1::0;22532:2;22512:18;;;22505:30;22571:34;22551:18;;;22544:62;-1:-1:-1;;;22622:18:1;;;22615:35;22667:19;;58632:71:0::1;22465:227:1::0;58632:71:0::1;58731:1;58722:6;:10;58714:58;;;::::0;-1:-1:-1;;;58714:58:0;;33603:2:1;58714:58:0::1;::::0;::::1;33585:21:1::0;33642:2;33622:18;;;33615:30;33681:34;33661:18;;;33654:62;-1:-1:-1;;;33732:18:1;;;33725:33;33775:19;;58714:58:0::1;33575:225:1::0;58714:58:0::1;58785:16;58804:12;:10;:12::i;:::-;58785:31;;58829:192;58864:8;58887:7;58917:1;58934:20;58951:2;58934:16;:20::i;:::-;58969:24;58986:6;58969:16;:24::i;:::-;-1:-1:-1::0;;58829:192:0::1;::::0;;::::1;::::0;::::1;::::0;;;-1:-1:-1;58829:192:0;;-1:-1:-1;;;68251:490:0;58829:192:::1;59034:22;59059:12:::0;;;:8:::1;:12;::::0;;;;;;;-1:-1:-1;;;;;59059:21:0;::::1;::::0;;;;;;;;59113:24;;::::1;;59091:111;;;::::0;-1:-1:-1;;;59091:111:0;;31536:2:1;59091:111:0::1;::::0;::::1;31518:21:1::0;31575:2;31555:18;;;31548:30;31614:34;31594:18;;;31587:62;-1:-1:-1;;;31665:18:1;;;31658:35;31710:19;;59091:111:0::1;31508:227:1::0;59091:111:0::1;59237:23;59254:6:::0;59237:14;:23:::1;:::i;:::-;59213:12;::::0;;;:8:::1;:12;::::0;;;;;;;-1:-1:-1;;;;;59213:21:0;::::1;::::0;;;;;;;:47;;;;59271:11;;;:7:::1;:11:::0;;;;;:21;;59286:6;;59213:12;59271:21:::1;::::0;59286:6;;59271:21:::1;:::i;:::-;::::0;;;-1:-1:-1;;59310:57:0::1;::::0;;36139:25:1;;;36195:2;36180:18;;36173:34;;;59352:1:0::1;::::0;-1:-1:-1;;;;;59310:57:0;;::::1;::::0;;;::::1;::::0;::::1;::::0;36112:18:1;59310:57:0::1;;;;;;;39418:1;;58495:880:::0;;;:::o;59578:1007::-;39123:7;;-1:-1:-1;;;39123:7:0;;;;39377:9;39369:38;;;;-1:-1:-1;;;39369:38:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;59748:21:0;::::1;59740:65;;;::::0;-1:-1:-1;;;59740:65:0;;34007:2:1;59740:65:0::1;::::0;::::1;33989:21:1::0;34046:2;34026:18;;;34019:30;34085:33;34065:18;;;34058:61;34136:18;;59740:65:0::1;33979:181:1::0;59740:65:0::1;59852:7;:14;59838:3;:10;:28;59816:114;;;::::0;-1:-1:-1;;;59816:114:0;;24499:2:1;59816:114:0::1;::::0;::::1;24481:21:1::0;24538:2;24518:18;;;24511:30;24577:34;24557:18;;;24550:62;-1:-1:-1;;;24628:18:1;;;24621:34;24672:19;;59816:114:0::1;24471:226:1::0;59816:114:0::1;59943:16;59962:12;:10;:12::i;:::-;59987:69;::::0;;::::1;::::0;::::1;::::0;;;60035:1:::1;59987:69:::0;;59943:31;-1:-1:-1;60074:9:0::1;60069:433;60093:3;:10;60089:1;:14;60069:433;;;60125:10;60138:3;60142:1;60138:6;;;;;;-1:-1:-1::0;;;60138:6:0::1;;;;;;;;;;;;;;;60125:19;;60159:14;60176:7;60184:1;60176:10;;;;;;-1:-1:-1::0;;;60176:10:0::1;;;;;;;;;;::::0;;::::1;::::0;;;;;;;60203:22:::1;60228:12:::0;;;:8:::1;:12:::0;;;;;;-1:-1:-1;;;;;60228:21:0;::::1;::::0;;;;;;;;;;60176:10;;-1:-1:-1;60290:24:0;;::::1;;60264:128;;;::::0;-1:-1:-1;;;60264:128:0;;34367:2:1;60264:128:0::1;::::0;::::1;34349:21:1::0;34406:2;34386:18;;;34379:30;34445:34;34425:18;;;34418:62;-1:-1:-1;;;34496:18:1;;;34489:40;34546:19;;60264:128:0::1;34339:232:1::0;60264:128:0::1;60431:23;60448:6:::0;60431:14;:23:::1;:::i;:::-;60407:12;::::0;;;:8:::1;:12;::::0;;;;;;;-1:-1:-1;;;;;60407:21:0;::::1;::::0;;;;;;;:47;;;;60469:11;;;:7:::1;:11:::0;;;;;:21;;60484:6;;60407:12;60469:21:::1;::::0;60484:6;;60469:21:::1;:::i;:::-;;;;;;;;60069:433;;;60105:3;;;;;:::i;:::-;;;;60069:433;;;;60560:1;-1:-1:-1::0;;;;;60519:58:0::1;60543:7;-1:-1:-1::0;;;;;60519:58:0::1;60533:8;-1:-1:-1::0;;;;;60519:58:0::1;;60564:3;60569:7;60519:58;;;;;;;:::i;:::-;;;;;;;;39418:1;59578:1007:::0;;;:::o;68749:271::-;68903:21;68920:3;68903:16;:21::i;:::-;68890:9;:34;;68868:144;;;;-1:-1:-1;;;68868:144:0;;21715:2:1;68868:144:0;;;21697:21:1;21754:2;21734:18;;;21727:30;21793:34;21773:18;;;21766:62;21864:30;21844:18;;;21837:58;21912:19;;68868:144:0;21687:250:1;81316:115:0;81378:7;81405:18;:3;:16;:18::i;62519:1000::-;-1:-1:-1;;;;;62759:13:0;;14931:20;14979:8;62755:757;;62812:203;;-1:-1:-1;;;62812:203:0;;-1:-1:-1;;;;;62812:43:0;;;;;:203;;62878:8;;62909:4;;62936:3;;62962:7;;62992:4;;62812:203;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62812:203:0;;;;;;;;-1:-1:-1;;62812:203:0;;;;;;;;;;;;:::i;:::-;;;62791:710;;;;:::i;:::-;-1:-1:-1;;;;;;63100:85:0;;-1:-1:-1;;;63100:85:0;63074:224;;63228:50;;-1:-1:-1;;;63228:50:0;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:755:1;68:5;121:3;114:4;106:6;102:17;98:27;88:2;;143:5;136;129:20;88:2;183:6;170:20;209:4;232:43;272:2;232:43;:::i;:::-;304:2;298:9;316:31;344:2;336:6;316:31;:::i;:::-;382:18;;;416:15;;;;-1:-1:-1;451:15:1;;;501:1;497:10;;;485:23;;481:32;;478:41;-1:-1:-1;475:2:1;;;536:5;529;522:20;475:2;562:5;576:163;590:2;587:1;584:9;576:163;;;647:17;;635:30;;685:12;;;;717;;;;608:1;601:9;576:163;;;-1:-1:-1;757:6:1;;78:691;-1:-1:-1;;;;;;;78:691:1:o;774:528::-;816:5;869:3;862:4;854:6;850:17;846:27;836:2;;891:5;884;877:20;836:2;931:6;918:20;957:31;985:2;957:31;:::i;:::-;1017:2;1011:9;1029:31;1057:2;1049:6;1029:31;:::i;:::-;1084:2;1076:6;1069:18;1130:3;1123:4;1118:2;1110:6;1106:15;1102:26;1099:35;1096:2;;;1151:5;1144;1137:20;1096:2;1219;1212:4;1204:6;1200:17;1193:4;1185:6;1181:17;1168:54;1242:15;;;1259:4;1238:26;1231:41;;;;1246:6;826:476;-1:-1:-1;;;826:476:1:o;1307:257::-;1366:6;1419:2;1407:9;1398:7;1394:23;1390:32;1387:2;;;1440:6;1432;1425:22;1387:2;1484:9;1471:23;1503:31;1528:5;1503:31;:::i;1569:398::-;1637:6;1645;1698:2;1686:9;1677:7;1673:23;1669:32;1666:2;;;1719:6;1711;1704:22;1666:2;1763:9;1750:23;1782:31;1807:5;1782:31;:::i;:::-;1832:5;-1:-1:-1;1889:2:1;1874:18;;1861:32;1902:33;1861:32;1902:33;:::i;:::-;1954:7;1944:17;;;1656:311;;;;;:::o;1972:1111::-;2126:6;2134;2142;2150;2158;2211:3;2199:9;2190:7;2186:23;2182:33;2179:2;;;2233:6;2225;2218:22;2179:2;2277:9;2264:23;2296:31;2321:5;2296:31;:::i;:::-;2346:5;-1:-1:-1;2403:2:1;2388:18;;2375:32;2416:33;2375:32;2416:33;:::i;:::-;2468:7;-1:-1:-1;2526:2:1;2511:18;;2498:32;-1:-1:-1;;;;;2579:14:1;;;2576:2;;;2611:6;2603;2596:22;2576:2;2639:61;2692:7;2683:6;2672:9;2668:22;2639:61;:::i;:::-;2629:71;;2753:2;2742:9;2738:18;2725:32;2709:48;;2782:2;2772:8;2769:16;2766:2;;;2803:6;2795;2788:22;2766:2;2831:63;2886:7;2875:8;2864:9;2860:24;2831:63;:::i;:::-;2821:73;;2947:3;2936:9;2932:19;2919:33;2903:49;;2977:2;2967:8;2964:16;2961:2;;;2998:6;2990;2983:22;2961:2;;3026:51;3069:7;3058:8;3047:9;3043:24;3026:51;:::i;:::-;3016:61;;;2169:914;;;;;;;;:::o;3088:754::-;3192:6;3200;3208;3216;3224;3277:3;3265:9;3256:7;3252:23;3248:33;3245:2;;;3299:6;3291;3284:22;3245:2;3343:9;3330:23;3362:31;3387:5;3362:31;:::i;:::-;3412:5;-1:-1:-1;3469:2:1;3454:18;;3441:32;3482:33;3441:32;3482:33;:::i;:::-;3534:7;-1:-1:-1;3588:2:1;3573:18;;3560:32;;-1:-1:-1;3639:2:1;3624:18;;3611:32;;-1:-1:-1;3694:3:1;3679:19;;3666:33;-1:-1:-1;;;;;3711:30:1;;3708:2;;;3759:6;3751;3744:22;3708:2;3787:49;3828:7;3819:6;3808:9;3804:22;3787:49;:::i;3847:760::-;3974:6;3982;3990;4043:2;4031:9;4022:7;4018:23;4014:32;4011:2;;;4064:6;4056;4049:22;4011:2;4108:9;4095:23;4127:31;4152:5;4127:31;:::i;:::-;4177:5;-1:-1:-1;4233:2:1;4218:18;;4205:32;-1:-1:-1;;;;;4286:14:1;;;4283:2;;;4318:6;4310;4303:22;4283:2;4346:61;4399:7;4390:6;4379:9;4375:22;4346:61;:::i;:::-;4336:71;;4460:2;4449:9;4445:18;4432:32;4416:48;;4489:2;4479:8;4476:16;4473:2;;;4510:6;4502;4495:22;4473:2;;4538:63;4593:7;4582:8;4571:9;4567:24;4538:63;:::i;:::-;4528:73;;;4001:606;;;;;:::o;4612:969::-;4757:6;4765;4773;4781;4834:3;4822:9;4813:7;4809:23;4805:33;4802:2;;;4856:6;4848;4841:22;4802:2;4900:9;4887:23;4919:31;4944:5;4919:31;:::i;:::-;4969:5;-1:-1:-1;5025:2:1;5010:18;;4997:32;-1:-1:-1;;;;;5078:14:1;;;5075:2;;;5110:6;5102;5095:22;5075:2;5138:61;5191:7;5182:6;5171:9;5167:22;5138:61;:::i;:::-;5128:71;;5252:2;5241:9;5237:18;5224:32;5208:48;;5281:2;5271:8;5268:16;5265:2;;;5302:6;5294;5287:22;5265:2;5330:63;5385:7;5374:8;5363:9;5359:24;5330:63;:::i;:::-;5320:73;;5446:2;5435:9;5431:18;5418:32;5402:48;;5475:2;5465:8;5462:16;5459:2;;;5496:6;5488;5481:22;5459:2;;5524:51;5567:7;5556:8;5545:9;5541:24;5524:51;:::i;:::-;5514:61;;;4792:789;;;;;;;:::o;5586:436::-;5651:6;5659;5712:2;5700:9;5691:7;5687:23;5683:32;5680:2;;;5733:6;5725;5718:22;5680:2;5777:9;5764:23;5796:31;5821:5;5796:31;:::i;:::-;5846:5;-1:-1:-1;5903:2:1;5888:18;;5875:32;5945:15;;5938:23;5926:36;;5916:2;;5981:6;5973;5966:22;6027:788;6129:6;6137;6145;6153;6161;6214:3;6202:9;6193:7;6189:23;6185:33;6182:2;;;6236:6;6228;6221:22;6182:2;6280:9;6267:23;6299:31;6324:5;6299:31;:::i;:::-;6349:5;-1:-1:-1;6405:2:1;6390:18;;6377:32;-1:-1:-1;;;;;6421:30:1;;6418:2;;;6469:6;6461;6454:22;6418:2;6497:49;6538:7;6529:6;6518:9;6514:22;6497:49;:::i;:::-;6487:59;;;6593:2;6582:9;6578:18;6565:32;6555:42;;6644:2;6633:9;6629:18;6616:32;6606:42;;6700:3;6689:9;6685:19;6672:33;6749:4;6740:7;6736:18;6727:7;6724:31;6714:2;;6774:6;6766;6759:22;6714:2;6802:7;6792:17;;;6172:643;;;;;;;;:::o;6820:325::-;6888:6;6896;6949:2;6937:9;6928:7;6924:23;6920:32;6917:2;;;6970:6;6962;6955:22;6917:2;7014:9;7001:23;7033:31;7058:5;7033:31;:::i;:::-;7083:5;7135:2;7120:18;;;;7107:32;;-1:-1:-1;;;6907:238:1:o;7150:393::-;7227:6;7235;7243;7296:2;7284:9;7275:7;7271:23;7267:32;7264:2;;;7317:6;7309;7302:22;7264:2;7361:9;7348:23;7380:31;7405:5;7380:31;:::i;:::-;7430:5;7482:2;7467:18;;7454:32;;-1:-1:-1;7533:2:1;7518:18;;;7505:32;;7254:289;-1:-1:-1;;;7254:289:1:o;7548:612::-;7643:6;7651;7659;7667;7720:3;7708:9;7699:7;7695:23;7691:33;7688:2;;;7742:6;7734;7727:22;7688:2;7786:9;7773:23;7805:31;7830:5;7805:31;:::i;:::-;7855:5;-1:-1:-1;7907:2:1;7892:18;;7879:32;;-1:-1:-1;7958:2:1;7943:18;;7930:32;;-1:-1:-1;8013:2:1;7998:18;;7985:32;-1:-1:-1;;;;;8029:30:1;;8026:2;;;8077:6;8069;8062:22;8026:2;8105:49;8146:7;8137:6;8126:9;8122:22;8105:49;:::i;8165:1343::-;8283:6;8291;8344:2;8332:9;8323:7;8319:23;8315:32;8312:2;;;8365:6;8357;8350:22;8312:2;8410:9;8397:23;-1:-1:-1;;;;;8480:2:1;8472:6;8469:14;8466:2;;;8501:6;8493;8486:22;8466:2;8544:6;8533:9;8529:22;8519:32;;8589:7;8582:4;8578:2;8574:13;8570:27;8560:2;;8616:6;8608;8601:22;8560:2;8657;8644:16;8679:4;8702:43;8742:2;8702:43;:::i;:::-;8774:2;8768:9;8786:31;8814:2;8806:6;8786:31;:::i;:::-;8852:18;;;8886:15;;;;-1:-1:-1;8921:11:1;;;8963:1;8959:10;;;8951:19;;8947:28;;8944:41;-1:-1:-1;8941:2:1;;;9003:6;8995;8988:22;8941:2;9030:6;9021:15;;9045:238;9059:2;9056:1;9053:9;9045:238;;;9130:3;9117:17;9147:31;9172:5;9147:31;:::i;:::-;9191:18;;9077:1;9070:9;;;;;9229:12;;;;9261;;9045:238;;;-1:-1:-1;9302:6:1;-1:-1:-1;;9346:18:1;;9333:32;;-1:-1:-1;;9377:16:1;;;9374:2;;;9411:6;9403;9396:22;9374:2;;9439:63;9494:7;9483:8;9472:9;9468:24;9439:63;:::i;:::-;9429:73;;;8302:1206;;;;;:::o;9513:1391::-;9624:6;9655:2;9698;9686:9;9677:7;9673:23;9669:32;9666:2;;;9719:6;9711;9704:22;9666:2;9764:9;9751:23;-1:-1:-1;;;;;9789:6:1;9786:30;9783:2;;;9834:6;9826;9819:22;9783:2;9862:22;;9915:4;9907:13;;9903:27;-1:-1:-1;9893:2:1;;9949:6;9941;9934:22;9893:2;9990;9977:16;10012:43;10052:2;10012:43;:::i;:::-;10074:2;10105;10099:9;10117:31;10145:2;10137:6;10117:31;:::i;:::-;10183:18;;;10217:15;;;;-1:-1:-1;10252:11:1;;;10294:1;10290:10;;;10282:19;;10278:28;;10275:41;-1:-1:-1;10272:2:1;;;10334:6;10326;10319:22;10272:2;10361:6;10352:15;;10376:497;10390:2;10387:1;10384:9;10376:497;;;10461:2;10455:3;10446:7;10442:17;10438:26;10435:2;;;10482:6;10474;10467:22;10435:2;10526;10520:9;10542:34;10567:8;10542:34;:::i;:::-;10619:3;10606:17;10596:8;10589:35;10672:2;10667:3;10663:12;10650:26;10689:31;10714:5;10689:31;:::i;:::-;10740:17;;;10733:32;10778:21;;10408:1;10401:9;;;;;10819:12;;;;10851;;10376:497;;;-1:-1:-1;10892:6:1;9635:1269;-1:-1:-1;;;;;;;;9635:1269:1:o;10909:255::-;10967:6;11020:2;11008:9;10999:7;10995:23;10991:32;10988:2;;;11041:6;11033;11026:22;10988:2;11085:9;11072:23;11104:30;11128:5;11104:30;:::i;11169:259::-;11238:6;11291:2;11279:9;11270:7;11266:23;11262:32;11259:2;;;11312:6;11304;11297:22;11259:2;11349:9;11343:16;11368:30;11392:5;11368:30;:::i;11433:290::-;11532:6;11585:2;11573:9;11564:7;11560:23;11556:32;11553:2;;;11606:6;11598;11591:22;11553:2;11643:9;11637:16;11662:31;11687:5;11662:31;:::i;11728:341::-;11797:6;11850:2;11838:9;11829:7;11825:23;11821:32;11818:2;;;11871:6;11863;11856:22;11818:2;11916:9;11903:23;-1:-1:-1;;;;;11941:6:1;11938:30;11935:2;;;11986:6;11978;11971:22;11935:2;12014:49;12055:7;12046:6;12035:9;12031:22;12014:49;:::i;12074:730::-;12154:6;12207:2;12195:9;12186:7;12182:23;12178:32;12175:2;;;12228:6;12220;12213:22;12175:2;12266:9;12260:16;-1:-1:-1;;;;;12291:6:1;12288:30;12285:2;;;12336:6;12328;12321:22;12285:2;12364:22;;12417:4;12409:13;;12405:27;-1:-1:-1;12395:2:1;;12451:6;12443;12436:22;12395:2;12485;12479:9;12507:31;12535:2;12507:31;:::i;:::-;12567:2;12561:9;12579:31;12607:2;12599:6;12579:31;:::i;:::-;12634:2;12626:6;12619:18;12674:7;12669:2;12664;12660;12656:11;12652:20;12649:33;12646:2;;;12700:6;12692;12685:22;12646:2;12718:55;12770:2;12765;12757:6;12753:15;12748:2;12744;12740:11;12718:55;:::i;:::-;12792:6;12165:639;-1:-1:-1;;;;;;12165:639:1:o;12809:190::-;12868:6;12921:2;12909:9;12900:7;12896:23;12892:32;12889:2;;;12942:6;12934;12927:22;12889:2;-1:-1:-1;12970:23:1;;12879:120;-1:-1:-1;12879:120:1:o;13004:194::-;13074:6;13127:2;13115:9;13106:7;13102:23;13098:32;13095:2;;;13148:6;13140;13133:22;13095:2;-1:-1:-1;13176:16:1;;13085:113;-1:-1:-1;13085:113:1:o;13203:325::-;13271:6;13279;13332:2;13320:9;13311:7;13307:23;13303:32;13300:2;;;13353:6;13345;13338:22;13300:2;13394:9;13381:23;13371:33;;13454:2;13443:9;13439:18;13426:32;13467:31;13492:5;13467:31;:::i;13533:409::-;13611:6;13619;13672:2;13660:9;13651:7;13647:23;13643:32;13640:2;;;13693:6;13685;13678:22;13640:2;13734:9;13721:23;13711:33;;13795:2;13784:9;13780:18;13767:32;-1:-1:-1;;;;;13814:6:1;13811:30;13808:2;;;13859:6;13851;13844:22;13808:2;13887:49;13928:7;13919:6;13908:9;13904:22;13887:49;:::i;13947:437::-;14000:3;14038:5;14032:12;14065:6;14060:3;14053:19;14091:4;14120:2;14115:3;14111:12;14104:19;;14157:2;14150:5;14146:14;14178:3;14190:169;14204:6;14201:1;14198:13;14190:169;;;14265:13;;14253:26;;14299:12;;;;14334:15;;;;14226:1;14219:9;14190:169;;;-1:-1:-1;14375:3:1;;14008:376;-1:-1:-1;;;;;14008:376:1:o;14389:257::-;14430:3;14468:5;14462:12;14495:6;14490:3;14483:19;14511:63;14567:6;14560:4;14555:3;14551:14;14544:4;14537:5;14533:16;14511:63;:::i;:::-;14628:2;14607:15;-1:-1:-1;;14603:29:1;14594:39;;;;14635:4;14590:50;;14438:208;-1:-1:-1;;14438:208:1:o;14651:274::-;14780:3;14818:6;14812:13;14834:53;14880:6;14875:3;14868:4;14860:6;14856:17;14834:53;:::i;:::-;14903:16;;;;;14788:137;-1:-1:-1;;14788:137:1:o;14930:415::-;15087:3;15125:6;15119:13;15141:53;15187:6;15182:3;15175:4;15167:6;15163:17;15141:53;:::i;:::-;15263:2;15259:15;;;;-1:-1:-1;;15255:53:1;15216:16;;;;15241:68;;;15336:2;15325:14;;15095:250;-1:-1:-1;;15095:250:1:o;15955:431::-;-1:-1:-1;;;;;16212:15:1;;;16194:34;;16264:15;;16259:2;16244:18;;16237:43;16316:2;16311;16296:18;;16289:30;;;16137:4;;16336:44;;16361:18;;16353:6;16336:44;:::i;:::-;16328:52;16146:240;-1:-1:-1;;;;;16146:240:1:o;16391:826::-;-1:-1:-1;;;;;16788:15:1;;;16770:34;;16840:15;;16835:2;16820:18;;16813:43;16750:3;16887:2;16872:18;;16865:31;;;16713:4;;16919:57;;16956:19;;16948:6;16919:57;:::i;:::-;17024:9;17016:6;17012:22;17007:2;16996:9;16992:18;16985:50;17058:44;17095:6;17087;17058:44;:::i;:::-;17044:58;;17151:9;17143:6;17139:22;17133:3;17122:9;17118:19;17111:51;17179:32;17204:6;17196;17179:32;:::i;17222:560::-;-1:-1:-1;;;;;17519:15:1;;;17501:34;;17571:15;;17566:2;17551:18;;17544:43;17618:2;17603:18;;17596:34;;;17661:2;17646:18;;17639:34;;;17481:3;17704;17689:19;;17682:32;;;17444:4;;17731:45;;17756:19;;17748:6;17731:45;:::i;:::-;17723:53;17453:329;-1:-1:-1;;;;;;;17453:329:1:o;18066:261::-;18245:2;18234:9;18227:21;18208:4;18265:56;18317:2;18306:9;18302:18;18294:6;18265:56;:::i;18332:465::-;18589:2;18578:9;18571:21;18552:4;18615:56;18667:2;18656:9;18652:18;18644:6;18615:56;:::i;:::-;18719:9;18711:6;18707:22;18702:2;18691:9;18687:18;18680:50;18747:44;18784:6;18776;18747:44;:::i;20001:217::-;20148:2;20137:9;20130:21;20111:4;20168:44;20208:2;20197:9;20193:18;20185:6;20168:44;:::i;21104:404::-;21306:2;21288:21;;;21345:2;21325:18;;;21318:30;21384:34;21379:2;21364:18;;21357:62;-1:-1:-1;;;21450:2:1;21435:18;;21428:38;21498:3;21483:19;;21278:230::o;23873:419::-;24075:2;24057:21;;;24114:2;24094:18;;;24087:30;24153:34;24148:2;24133:18;;24126:62;24224:25;24219:2;24204:18;;24197:53;24282:3;24267:19;;24047:245::o;24702:412::-;24904:2;24886:21;;;24943:2;24923:18;;;24916:30;24982:34;24977:2;24962:18;;24955:62;-1:-1:-1;;;25048:2:1;25033:18;;25026:46;25104:3;25089:19;;24876:238::o;25960:473::-;26162:2;26144:21;;;26201:2;26181:18;;;26174:30;26240:34;26235:2;26220:18;;26213:62;26311:34;26306:2;26291:18;;26284:62;-1:-1:-1;;;26377:3:1;26362:19;;26355:36;26423:3;26408:19;;26134:299::o;26438:410::-;26640:2;26622:21;;;26679:2;26659:18;;;26652:30;26718:34;26713:2;26698:18;;26691:62;-1:-1:-1;;;26784:2:1;26769:18;;26762:44;26838:3;26823:19;;26612:236::o;27673:340::-;27875:2;27857:21;;;27914:2;27894:18;;;27887:30;-1:-1:-1;;;27948:2:1;27933:18;;27926:46;28004:2;27989:18;;27847:166::o;34576:417::-;34778:2;34760:21;;;34817:2;34797:18;;;34790:30;34856:34;34851:2;34836:18;;34829:62;-1:-1:-1;;;34922:2:1;34907:18;;34900:51;34983:3;34968:19;;34750:243::o;36218:183::-;36278:4;-1:-1:-1;;;;;36303:6:1;36300:30;36297:2;;;36333:18;;:::i;:::-;-1:-1:-1;36378:1:1;36374:14;36390:4;36370:25;;36287:114::o;36406:186::-;36454:4;-1:-1:-1;;;;;36479:6:1;36476:30;36473:2;;;36509:18;;:::i;:::-;-1:-1:-1;36575:2:1;36554:15;-1:-1:-1;;36550:29:1;36581:4;36546:40;;36463:129::o;36597:128::-;36637:3;36668:1;36664:6;36661:1;36658:13;36655:2;;;36674:18;;:::i;:::-;-1:-1:-1;36710:9:1;;36645:80::o;36730:204::-;36768:3;36804:4;36801:1;36797:12;36836:4;36833:1;36829:12;36871:3;36865:4;36861:14;36856:3;36853:23;36850:2;;;36879:18;;:::i;:::-;36915:13;;36776:158;-1:-1:-1;;;36776:158:1:o;36939:125::-;36979:4;37007:1;37004;37001:8;36998:2;;;37012:18;;:::i;:::-;-1:-1:-1;37049:9:1;;36988:76::o;37069:258::-;37141:1;37151:113;37165:6;37162:1;37159:13;37151:113;;;37241:11;;;37235:18;37222:11;;;37215:39;37187:2;37180:10;37151:113;;;37282:6;37279:1;37276:13;37273:2;;;-1:-1:-1;;37317:1:1;37299:16;;37292:27;37122:205::o;37332:380::-;37411:1;37407:12;;;;37454;;;37475:2;;37529:4;37521:6;37517:17;37507:27;;37475:2;37582;37574:6;37571:14;37551:18;37548:38;37545:2;;;37628:10;37623:3;37619:20;37616:1;37609:31;37663:4;37660:1;37653:15;37691:4;37688:1;37681:15;37545:2;;37387:325;;;:::o;37717:223::-;37803:2;37795:6;37791:15;37872:6;37860:10;37857:22;-1:-1:-1;;;;;37824:10:1;37821:34;37818:62;37815:2;;;37883:18;;:::i;:::-;37919:2;37912:22;-1:-1:-1;37763:177:1:o;37945:249::-;38055:2;38036:13;;-1:-1:-1;;38032:27:1;38020:40;;-1:-1:-1;;;;;38075:34:1;;38111:22;;;38072:62;38069:2;;;38137:18;;:::i;:::-;38173:2;38166:22;-1:-1:-1;;37992:202:1:o;38199:135::-;38238:3;-1:-1:-1;;38259:17:1;;38256:2;;;38279:18;;:::i;:::-;-1:-1:-1;38326:1:1;38315:13;;38246:88::o;38339:127::-;38400:10;38395:3;38391:20;38388:1;38381:31;38431:4;38428:1;38421:15;38455:4;38452:1;38445:15;38471:127;38532:10;38527:3;38523:20;38520:1;38513:31;38563:4;38560:1;38553:15;38587:4;38584:1;38577:15;38603:185;38638:3;38680:1;38662:16;38659:23;38656:2;;;38730:1;38725:3;38720;38705:27;38761:10;38756:3;38752:20;38646:142;:::o;38793:671::-;38832:3;38874:4;38856:16;38853:26;38850:2;;;38840:624;:::o;38850:2::-;38916;38910:9;-1:-1:-1;;38981:16:1;38977:25;;38974:1;38910:9;38953:50;39032:4;39026:11;39056:16;-1:-1:-1;;;;;39162:2:1;39155:4;39147:6;39143:17;39140:25;39135:2;39127:6;39124:14;39121:45;39118:2;;;39169:5;;;;;38840:624;:::o;39118:2::-;39206:6;39200:4;39196:17;39185:28;;39242:3;39236:10;39269:2;39261:6;39258:14;39255:2;;;39275:5;;;;;;38840:624;:::o;39255:2::-;39359;39340:16;39334:4;39330:27;39326:36;39319:4;39310:6;39305:3;39301:16;39297:27;39294:69;39291:2;;;39366:5;;;;;;38840:624;:::o;39291:2::-;39382:57;39433:4;39424:6;39416;39412:19;39408:30;39402:4;39382:57;:::i;:::-;-1:-1:-1;39455:3:1;;38840:624;-1:-1:-1;;;;;38840:624:1:o;39469:131::-;-1:-1:-1;;;;;39544:31:1;;39534:42;;39524:2;;39590:1;39587;39580:12;39605:131;-1:-1:-1;;;;;;39679:32:1;;39669:43;;39659:2;;39726:1;39723;39716:12

Swarm Source

ipfs://43697419826d061f3b71e960c7e2922b0bbee04fa8997ba2f33f09b6fab5319e
Loading