Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Receiver
•    - function onERC721Received(address ope ...
• interface IStaking
•    - function updateStaking()
•    - function supportsInterface(bytes4 int ...
•    - function _registerInterface(bytes4 in ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
• library EnumerableMap
•    - function _set(Map storage map, bytes3 ...
•    - function _remove(Map storage map, byt ...
•    - function _contains(Map storage map, b ...
•    - function _length(Map storage map)
•    - function _at(Map storage map, uint256 ...
•    - function _tryGet(Map storage map, byt ...
•    - function _get(Map storage map, bytes3 ...
•    - function _get(Map storage map, bytes3 ...
•    - function set(UintToAddressMap storage ...
•    - function remove(UintToAddressMap stor ...
•    - function contains(UintToAddressMap st ...
•    - function length(UintToAddressMap stor ...
•    - function at(UintToAddressMap storage ...
•    - function tryGet(UintToAddressMap stor ...
•    - function get(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
• library Strings
•    - function toString(uint256 value)
•  contract ERC721 is Context, ERC165 ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function baseURI()
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _safeTransfer(address from, ...
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(address from, addr ...
•    - function _setTokenURI(uint256 tokenId ...
•    - function _setBaseURI(string memory ba ...
•    - function _checkOnERC721Received(addre ...
•    - function _approve(address to, uint256 ...
•    - function _beforeTokenTransfer(address ...
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•  contract BlaurWhales is ERC721, Ow ... *
•    - function withdraw()
•    - function reserveWhales(uint numberOfT ...
•    - function setRevealTimestamp(uint256 r ...
•    - function setStakingMaster(address sta ...
•    - function _beforeTokenTransfer(address ...
•    - function setProvenanceHash(string mem ...
•    - function setBaseURI(string memory bas ...
•    - function flipSaleState()
•    - function mintWhales(uint numberOfToke ...
•    - function setStartingIndex()
•    - function emergencySetStartingIndexBlo ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-06-04
*/

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

pragma solidity >=0.6.0 <0.8.0;
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);
}

pragma solidity >=0.6.2 <0.8.0;
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.2 <0.8.0;
interface IERC721Metadata is IERC721 {

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

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

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

pragma solidity >=0.6.2 <0.8.0;
interface IERC721Enumerable is IERC721 {

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

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

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

pragma solidity >=0.6.0 <0.8.0;
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

pragma solidity >=0.6.0 <0.8.0;
interface IStaking {
    function updateStaking() external;
}

pragma solidity >=0.6.0 <0.8.0;
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

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

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

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

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

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

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

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

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

            MapEntry storage lastEntry = map._entries[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

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

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

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

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Base URI
    string private _baseURI;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;
abstract contract Ownable is Context {
    address private _owner;

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

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

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

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

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

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

pragma solidity ^0.7.0;
contract BlaurWhales is ERC721, Ownable {
    using SafeMath for uint256;

    string public PROVENANCE = "";

    uint256 public startingIndexBlock;

    uint256 public startingIndex;

    uint256 public constant price = 40000000000000000; //0.04 ETH

    uint256 public MAX_WHALES;

    bool public saleIsActive = false;

    uint256 public REVEAL_TIMESTAMP;

    uint256 constant maxWhalePurchase = 20;

    address public stakingMaster;

    constructor(string memory name, string memory symbol, uint256 maxNftSupply, uint256 saleStart) ERC721(name, symbol) {
        MAX_WHALES = maxNftSupply;
        REVEAL_TIMESTAMP = saleStart + (86400 * 31);
    }

    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    /**
     * Set some Whales aside
     */
    function reserveWhales(uint numberOfTokens) public onlyOwner {        
        uint supply = totalSupply();
        uint i;
        for (i = 0; i < numberOfTokens; i++) {
            _safeMint(msg.sender, supply + i);
        }
    }

    /**
     * Set time of the reveal
     */
    function setRevealTimestamp(uint256 revealTimeStamp) public onlyOwner {
        REVEAL_TIMESTAMP = revealTimeStamp;
    }

    /**
     * Set the staking master contract for Blaurr Whales staking
     */
    function setStakingMaster(address stakingAddr) public onlyOwner {        
        stakingMaster = stakingAddr;
    }

    /**
     * Updates the staking information for Blaurr Whales
    */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override {
        if(stakingMaster != address(0x0)) {
            IStaking(stakingMaster).updateStaking();
        }
    }

    /*     
    * Set provenance once it's calculated
    */
    function setProvenanceHash(string memory provenanceHash) public onlyOwner {
        PROVENANCE = provenanceHash;
    }

    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }

    /*
    * Pause sale if active, make active if paused
    */
    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }

    /**
    * Mints Blaurr Whales
    */
    function mintWhales(uint numberOfTokens) public payable {
        require(saleIsActive, "Sale must be active to mint Whales");
        require(numberOfTokens <= maxWhalePurchase, "Can only mint 20 tokens at a time");
        require(totalSupply().add(numberOfTokens) <= MAX_WHALES, "Purchase would exceed max supply of Whales");
        require(price.mul(numberOfTokens) <= msg.value, "Ether value sent is not correct");
        
        for(uint i = 0; i < numberOfTokens; i++) {
            uint mintIndex = totalSupply();
            if (totalSupply() < MAX_WHALES) {
                _safeMint(msg.sender, mintIndex);
            }
        }

        // If we haven't set the starting index and this is either 1) the last saleable token or 2) the first token to be sold after
        // the end of pre-sale, set the starting index block
        if (startingIndexBlock == 0 && (totalSupply() == MAX_WHALES || block.timestamp >= REVEAL_TIMESTAMP)) {
            startingIndexBlock = block.number;
        } 
    }

    /**
     * Set the starting index for the collection
     */
    function setStartingIndex() public {
        require(startingIndex == 0, "Starting index is already set");
        require(startingIndexBlock != 0, "Starting index block must be set");
        
        startingIndex = uint(blockhash(startingIndexBlock)) % MAX_WHALES;
        // Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes)
        if (block.number.sub(startingIndexBlock) > 255) {
            startingIndex = uint(blockhash(block.number - 1)) % MAX_WHALES;
        }
        // Prevent default sequence
        if (startingIndex == 0) {
            startingIndex = startingIndex.add(1);
        }
    }

    /**
     * Set the starting index block for the collection, essentially unblocking
     * setting starting index
     */
    function emergencySetStartingIndexBlock() public onlyOwner {
        require(startingIndex == 0, "Starting index is already set");
        
        startingIndexBlock = block.number;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"maxNftSupply","type":"uint256"},{"internalType":"uint256","name":"saleStart","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_WHALES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REVEAL_TIMESTAMP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencySetStartingIndexBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintWhales","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"reserveWhales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"provenanceHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"revealTimeStamp","type":"uint256"}],"name":"setRevealTimestamp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"stakingAddr","type":"address"}],"name":"setStakingMaster","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setStartingIndex","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingMaster","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startingIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startingIndexBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000003e800000000000000000000000000000000000000000000000000000000665f7ef7000000000000000000000000000000000000000000000000000000000000000c426c61757272205768616c65000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034257580000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Blaurr Whale
Arg [1] : symbol (string): BWX
Arg [2] : maxNftSupply (uint256): 1000
Arg [3] : saleStart (uint256): 1717534455

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [3] : 00000000000000000000000000000000000000000000000000000000665f7ef7
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [5] : 426c61757272205768616c650000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 4257580000000000000000000000000000000000000000000000000000000000

61727:4432:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62899:123;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;8357:150;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;47005:100;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49791:221;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;49321:404;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;63596:120;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48799:211;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;62070:31;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50681:305;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48561:162;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;63898:89;;;;;;;;;;;;;:::i;:::-;;62416:131;;;;;;;;;;;;;:::i;:::-;;51057:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;49087:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;63724:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46761:177;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;61809:29;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64039:1032;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48380:97;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46478:221;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;61148:148;;;;;;;;;;;;;:::i;:::-;;65964:192;;;;;;;;;;;;;:::i;:::-;;61995:25;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;60497:87;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;47174:104;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61926:49;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50084:295;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;62603:239;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;51279:285;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47349:792;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61889:28;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;62157;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;63114:118;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;61847:33;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50450:164;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;65147:680;;;;;;;;;;;;;:::i;:::-;;62029:32;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;61451:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;62899:123;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62999:15:::1;62980:16;:34;;;;62899:123:::0;:::o;8357:150::-;8442:4;8466:20;:33;8487:11;8466:33;;;;;;;;;;;;;;;;;;;;;;;;;;;8459:40;;8357:150;;;:::o;47005:100::-;47059:13;47092:5;47085:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47005:100;:::o;49791:221::-;49867:7;49895:16;49903:7;49895;:16::i;:::-;49887:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49980:15;:24;49996:7;49980:24;;;;;;;;;;;;;;;;;;;;;49973:31;;49791:221;;;:::o;49321:404::-;49402:13;49418:23;49433:7;49418:14;:23::i;:::-;49402:39;;49466:5;49460:11;;:2;:11;;;;49452:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49546:5;49530:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;49555:44;49579:5;49586:12;:10;:12::i;:::-;49555:23;:44::i;:::-;49530:69;49522:161;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49696:21;49705:2;49709:7;49696:8;:21::i;:::-;49321:404;;;:::o;63596:120::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63694:14:::1;63681:10;:27;;;;;;;;;;;;:::i;:::-;;63596:120:::0;:::o;48799:211::-;48860:7;48981:21;:12;:19;:21::i;:::-;48974:28;;48799:211;:::o;62070:31::-;;;;:::o;50681:305::-;50842:41;50861:12;:10;:12::i;:::-;50875:7;50842:18;:41::i;:::-;50834:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50950:28;50960:4;50966:2;50970:7;50950:9;:28::i;:::-;50681:305;;;:::o;48561:162::-;48658:7;48685:30;48709:5;48685:13;:20;48699:5;48685:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;48678:37;;48561:162;;;;:::o;63898:89::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63967:12:::1;;;;;;;;;;;63966:13;63951:12;;:28;;;;;;;;;;;;;;;;;;63898:89::o:0;62416:131::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62464:12:::1;62479:21;62464:36;;62511:10;:19;;:28;62531:7;62511:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;60788:1;62416:131::o:0;51057:151::-;51161:39;51178:4;51184:2;51188:7;51161:39;;;;;;;;;;;;:16;:39::i;:::-;51057:151;;;:::o;49087:172::-;49162:7;49183:15;49204:22;49220:5;49204:12;:15;;:22;;;;:::i;:::-;49182:44;;;49244:7;49237:14;;;49087:172;;;:::o;63724:99::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63795:20:::1;63807:7;63795:11;:20::i;:::-;63724:99:::0;:::o;46761:177::-;46833:7;46860:70;46877:7;46860:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;46853:77;;46761:177;;;:::o;61809:29::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;64039:1032::-;64114:12;;;;;;;;;;;64106:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62146:2;64184:14;:34;;64176:80;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64312:10;;64275:33;64293:14;64275:13;:11;:13::i;:::-;:17;;:33;;;;:::i;:::-;:47;;64267:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64417:9;64388:25;64398:14;61958:17;64388:9;;:25;;;;:::i;:::-;:38;;64380:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64487:6;64483:211;64503:14;64499:1;:18;64483:211;;;64539:14;64556:13;:11;:13::i;:::-;64539:30;;64604:10;;64588:13;:11;:13::i;:::-;:26;64584:99;;;64635:32;64645:10;64657:9;64635;:32::i;:::-;64584:99;64483:211;64519:3;;;;;;;64483:211;;;;64928:1;64906:18;;:23;:95;;;;;64951:10;;64934:13;:11;:13::i;:::-;:27;:66;;;;64984:16;;64965:15;:35;;64934:66;64906:95;64902:161;;;65039:12;65018:18;:33;;;;64902:161;64039:1032;:::o;48380:97::-;48428:13;48461:8;48454:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48380:97;:::o;46478:221::-;46550:7;46595:1;46578:19;;:5;:19;;;;46570:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46662:29;:13;:20;46676:5;46662:20;;;;;;;;;;;;;;;:27;:29::i;:::-;46655:36;;46478:221;;;:::o;61148:148::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61255:1:::1;61218:40;;61239:6;;;;;;;;;;;61218:40;;;;;;;;;;;;61286:1;61269:6;;:19;;;;;;;;;;;;;;;;;;61148:148::o:0;65964:192::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66059:1:::1;66042:13;;:18;66034:60;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;66136:12;66115:18;:33;;;;65964:192::o:0;61995:25::-;;;;:::o;60497:87::-;60543:7;60570:6;;;;;;;;;;;60563:13;;60497:87;:::o;47174:104::-;47230:13;47263:7;47256:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47174:104;:::o;61926:49::-;61958:17;61926:49;:::o;50084:295::-;50199:12;:10;:12::i;:::-;50187:24;;:8;:24;;;;50179:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50299:8;50254:18;:32;50273:12;:10;:12::i;:::-;50254:32;;;;;;;;;;;;;;;:42;50287:8;50254:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;50352:8;50323:48;;50338:12;:10;:12::i;:::-;50323:48;;;50362:8;50323:48;;;;;;;;;;;;;;;;;;;;50084:295;;:::o;62603:239::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62683:11:::1;62697:13;:11;:13::i;:::-;62683:27;;62721:6;62738:97;62754:14;62750:1;:18;62738:97;;;62790:33;62800:10;62821:1;62812:6;:10;62790:9;:33::i;:::-;62770:3;;;;;;;62738:97;;;60788:1;;62603:239:::0;:::o;51279:285::-;51411:41;51430:12;:10;:12::i;:::-;51444:7;51411:18;:41::i;:::-;51403:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51517:39;51531:4;51537:2;51541:7;51550:5;51517:13;:39::i;:::-;51279:285;;;;:::o;47349:792::-;47422:13;47456:16;47464:7;47456;:16::i;:::-;47448:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47537:23;47563:10;:19;47574:7;47563:19;;;;;;;;;;;47537:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47593:18;47614:9;:7;:9::i;:::-;47593:30;;47721:1;47705:4;47699:18;:23;47695:72;;;47746:9;47739:16;;;;;;47695:72;47897:1;47877:9;47871:23;:27;47867:108;;;47946:4;47952:9;47929:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47915:48;;;;;;47867:108;48107:4;48113:18;:7;:16;:18::i;:::-;48090:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48076:57;;;;47349:792;;;;:::o;61889:28::-;;;;:::o;62157:::-;;;;;;;;;;;;;:::o;63114:118::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63213:11:::1;63197:13;;:27;;;;;;;;;;;;;;;;;;63114:118:::0;:::o;61847:33::-;;;;:::o;50450:164::-;50547:4;50571:18;:25;50590:5;50571:25;;;;;;;;;;;;;;;:35;50597:8;50571:35;;;;;;;;;;;;;;;;;;;;;;;;;50564:42;;50450:164;;;;:::o;65147:680::-;65218:1;65201:13;;:18;65193:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65294:1;65272:18;;:23;;65264:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65407:10;;65384:18;;65374:29;65369:35;;:48;;;;;;65353:13;:64;;;;65592:3;65553:36;65570:18;;65553:12;:16;;:36;;;;:::i;:::-;:42;65549:137;;;65664:10;;65658:1;65643:12;:16;65633:27;65628:33;;:46;;;;;;65612:13;:62;;;;65549:137;65754:1;65737:13;;:18;65733:87;;;65788:20;65806:1;65788:13;;:17;;:20;;;;:::i;:::-;65772:13;:36;;;;65733:87;65147:680::o;62029:32::-;;;;;;;;;;;;;:::o;61451:244::-;60728:12;:10;:12::i;:::-;60717:23;;:7;:5;:7::i;:::-;:23;;;60709:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61560:1:::1;61540:22;;:8;:22;;;;61532:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61650:8;61621:38;;61642:6;;;;;;;;;;;61621:38;;;;;;;;;;;;61679:8;61670:6;;:17;;;;;;;;;;;;;;;;;;61451:244:::0;:::o;101:106::-;154:15;189:10;182:17;;101:106;:::o;53031:127::-;53096:4;53120:30;53142:7;53120:12;:21;;:30;;;;:::i;:::-;53113:37;;53031:127;;;:::o;59049:192::-;59151:2;59124:15;:24;59140:7;59124:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;59207:7;59203:2;59169:46;;59178:23;59193:7;59178:14;:23::i;:::-;59169:46;;;;;;;;;;;;59049:192;;:::o;40059:123::-;40128:7;40155:19;40163:3;:10;;40155:7;:19::i;:::-;40148:26;;40059:123;;;:::o;53325:355::-;53418:4;53443:16;53451:7;53443;:16::i;:::-;53435:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53519:13;53535:23;53550:7;53535:14;:23::i;:::-;53519:39;;53588:5;53577:16;;:7;:16;;;:51;;;;53621:7;53597:31;;:20;53609:7;53597:11;:20::i;:::-;:31;;;53577:51;:94;;;;53632:39;53656:5;53663:7;53632:23;:39::i;:::-;53577:94;53569:103;;;53325:355;;;;:::o;56461:599::-;56586:4;56559:31;;:23;56574:7;56559:14;:23::i;:::-;:31;;;56551:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56687:1;56673:16;;:2;:16;;;;56665:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56743:39;56764:4;56770:2;56774:7;56743:20;:39::i;:::-;56847:29;56864:1;56868:7;56847:8;:29::i;:::-;56889:35;56916:7;56889:13;:19;56903:4;56889:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;56935:30;56957:7;56935:13;:17;56949:2;56935:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;56978:29;56995:7;57004:2;56978:12;:16;;:29;;;;;:::i;:::-;;57044:7;57040:2;57025:27;;57034:4;57025:27;;;;;;;;;;;;56461:599;;;:::o;32646:137::-;32717:7;32752:22;32756:3;:10;;32768:5;32752:3;:22::i;:::-;32744:31;;32737:38;;32646:137;;;;:::o;40521:236::-;40601:7;40610;40631:11;40644:13;40661:22;40665:3;:10;;40677:5;40661:3;:22::i;:::-;40630:53;;;;40710:3;40702:12;;40740:5;40732:14;;40694:55;;;;;;40521:236;;;;;:::o;57661:100::-;57745:8;57734;:19;;;;;;;;;;;;:::i;:::-;;57661:100;:::o;41807:213::-;41914:7;41965:44;41970:3;:10;;41990:3;41982:12;;41996;41965:4;:44::i;:::-;41957:53;;41934:78;;41807:213;;;;;:::o;11282:179::-;11340:7;11360:9;11376:1;11372;:5;11360:17;;11401:1;11396;:6;;11388:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11452:1;11445:8;;;11282:179;;;;:::o;12161:220::-;12219:7;12248:1;12243;:6;12239:20;;;12258:1;12251:8;;;;12239:20;12270:9;12286:1;12282;:5;12270:17;;12315:1;12310;12306;:5;;;;;;:10;12298:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12372:1;12365:8;;;12161:220;;;;;:::o;54023:110::-;54099:26;54109:2;54113:7;54099:26;;;;;;;;;;;;:9;:26::i;:::-;54023:110;;:::o;32188:114::-;32248:7;32275:19;32283:3;:10;;32275:7;:19::i;:::-;32268:26;;32188:114;;;:::o;52446:272::-;52560:28;52570:4;52576:2;52580:7;52560:9;:28::i;:::-;52607:48;52630:4;52636:2;52640:7;52649:5;52607:22;:48::i;:::-;52599:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52446:272;;;;:::o;42173:746::-;42229:13;42459:1;42450:5;:10;42446:53;;;42477:10;;;;;;;;;;;;;;;;;;;;;42446:53;42509:12;42524:5;42509:20;;42540:14;42565:78;42580:1;42572:4;:9;42565:78;;42598:8;;;;;;;42629:2;42621:10;;;;;;;;;42565:78;;;42653:19;42685:6;42675:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42653:39;;42703:13;42728:1;42719:6;:10;42703:26;;42747:5;42740:12;;42763:117;42778:1;42770:4;:9;42763:117;;42839:2;42832:4;:9;;;;;;42827:2;:14;42814:29;;42796:6;42803:7;;;;;;;42796:15;;;;;;;;;;;:47;;;;;;;;;;;42866:2;42858:10;;;;;;;;;42763:117;;;42904:6;42890:21;;;;;;42173:746;;;;:::o;11744:158::-;11802:7;11835:1;11830;:6;;11822:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11893:1;11889;:5;11882:12;;11744:158;;;;:::o;39820:151::-;39904:4;39928:35;39938:3;:10;;39958:3;39950:12;;39928:9;:35::i;:::-;39921:42;;39820:151;;;;:::o;36638:110::-;36694:7;36721:3;:12;;:19;;;;36714:26;;36638:110;;;:::o;63315:209::-;63445:3;63420:29;;:13;;;;;;;;;;;:29;;;63417:100;;63475:13;;;;;;;;;;;63466:37;;;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63417:100;63315:209;;;:::o;31733:137::-;31803:4;31827:35;31835:3;:10;;31855:5;31847:14;;31827:7;:35::i;:::-;31820:42;;31733:137;;;;:::o;31426:131::-;31493:4;31517:32;31522:3;:10;;31542:5;31534:14;;31517:4;:32::i;:::-;31510:39;;31426:131;;;;:::o;39243:185::-;39332:4;39356:64;39361:3;:10;;39381:3;39373:12;;39411:5;39395:23;;39387:32;;39356:4;:64::i;:::-;39349:71;;39243:185;;;;;:::o;27684:204::-;27751:7;27800:5;27779:3;:11;;:18;;;;:26;27771:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27862:3;:11;;27874:5;27862:18;;;;;;;;;;;;;;;;27855:25;;27684:204;;;;:::o;37103:279::-;37170:7;37179;37229:5;37207:3;:12;;:19;;;;:27;37199:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37286:22;37311:3;:12;;37324:5;37311:19;;;;;;;;;;;;;;;;;;37286:44;;37349:5;:10;;;37361:5;:12;;;37341:33;;;;;37103:279;;;;;:::o;38600:319::-;38694:7;38714:16;38733:3;:12;;:17;38746:3;38733:17;;;;;;;;;;;;38714:36;;38781:1;38769:8;:13;;38784:12;38761:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38851:3;:12;;38875:1;38864:8;:12;38851:26;;;;;;;;;;;;;;;;;;:33;;;38844:40;;;38600:319;;;;;:::o;54360:250::-;54456:18;54462:2;54466:7;54456:5;:18::i;:::-;54493:54;54524:1;54528:2;54532:7;54541:5;54493:22;:54::i;:::-;54485:117;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54360:250;;;:::o;27231:109::-;27287:7;27314:3;:11;;:18;;;;27307:25;;27231:109;;;:::o;58326:604::-;58447:4;58474:15;:2;:13;;;:15::i;:::-;58469:60;;58513:4;58506:11;;;;58469:60;58539:23;58565:252;58618:45;;;58678:12;:10;:12::i;:::-;58705:4;58724:7;58746:5;58581:181;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58565:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;58539:278;;58828:13;58855:10;58844:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58828:48;;43475:10;58905:16;;58895:26;;;:6;:26;;;;58887:35;;;;58326:604;;;;;;;:::o;36418:125::-;36489:4;36534:1;36513:3;:12;;:17;36526:3;36513:17;;;;;;;;;;;;:22;;36506:29;;36418:125;;;;:::o;25386:1544::-;25452:4;25570:18;25591:3;:12;;:19;25604:5;25591:19;;;;;;;;;;;;25570:40;;25641:1;25627:10;:15;25623:1300;;25989:21;26026:1;26013:10;:14;25989:38;;26042:17;26083:1;26062:3;:11;;:18;;;;:22;26042:42;;26329:17;26349:3;:11;;26361:9;26349:22;;;;;;;;;;;;;;;;26329:42;;26495:9;26466:3;:11;;26478:13;26466:26;;;;;;;;;;;;;;;:38;;;;26614:1;26598:13;:17;26572:3;:12;;:23;26585:9;26572:23;;;;;;;;;;;:43;;;;26724:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;26819:3;:12;;:19;26832:5;26819:19;;;;;;;;;;;26812:26;;;26862:4;26855:11;;;;;;;;25623:1300;26906:5;26899:12;;;25386:1544;;;;;:::o;24796:414::-;24859:4;24881:21;24891:3;24896:5;24881:9;:21::i;:::-;24876:327;;24919:3;:11;;24936:5;24919:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25102:3;:11;;:18;;;;25080:3;:12;;:19;25093:5;25080:19;;;;;;;;;;;:40;;;;25142:4;25135:11;;;;24876:327;25186:5;25179:12;;24796:414;;;;;:::o;33918:692::-;33994:4;34110:16;34129:3;:12;;:17;34142:3;34129:17;;;;;;;;;;;;34110:36;;34175:1;34163:8;:13;34159:444;;;34230:3;:12;;34248:38;;;;;;;;34265:3;34248:38;;;;34278:5;34248:38;;;34230:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34445:3;:12;;:19;;;;34425:3;:12;;:17;34438:3;34425:17;;;;;;;;;;;:39;;;;34486:4;34479:11;;;;;34159:444;34559:5;34523:3;:12;;34547:1;34536:8;:12;34523:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;34586:5;34579:12;;;33918:692;;;;;;:::o;54946:404::-;55040:1;55026:16;;:2;:16;;;;55018:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55099:16;55107:7;55099;:16::i;:::-;55098:17;55090:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55161:45;55190:1;55194:2;55198:7;55161:20;:45::i;:::-;55219:30;55241:7;55219:13;:17;55233:2;55219:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;55262:29;55279:7;55288:2;55262:12;:16;;:29;;;;;:::i;:::-;;55334:7;55330:2;55309:33;;55326:1;55309:33;;;;;;;;;;;;54946:404;;:::o;16592:422::-;16652:4;16860:12;16971:7;16959:20;16951:28;;17005:1;16998:4;:8;16991:15;;;16592:422;;;:::o;19510:195::-;19613:12;19645:52;19667:6;19675:4;19681:1;19684:12;19645:21;:52::i;:::-;19638:59;;19510:195;;;;;:::o;27016:129::-;27089:4;27136:1;27113:3;:12;;:19;27126:5;27113:19;;;;;;;;;;;;:24;;27106:31;;27016:129;;;;:::o;20562:530::-;20689:12;20747:5;20722:21;:30;;20714:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20814:18;20825:6;20814:10;:18::i;:::-;20806:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20940:12;20954:23;20981:6;:11;;21001:5;21009:4;20981:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20939:75;;;;21032:52;21050:7;21059:10;21071:12;21032:17;:52::i;:::-;21025:59;;;;20562:530;;;;;;:::o;23102:742::-;23217:12;23246:7;23242:595;;;23277:10;23270:17;;;;23242:595;23411:1;23391:10;:17;:21;23387:439;;;23654:10;23648:17;23715:15;23702:10;23698:2;23694:19;23687:44;23602:148;23797:12;23790:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23102:742;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://c56d9569e396e3b51cc9d791ce2916e85999fb9a23ff5b0f35954580a16ee7e2