Token

Pepito Platoon (PEPI)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

71 PEPI

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xaadc80d6a6c14f96d9301b543e5c30cb1f9d4576

Filtered by Token Holder

0x5593B2315208559b92898e851C2C25a0c15EF2e4

Balance

1 PEPI

0x5593B2315208559b92898e851C2C25a0c15EF2e4

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PepitoPlatoon

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 69 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-03-07
*/

//SPDX-License-Identifier: UNLICENSED

// https://mint.lilpepito.app/

pragma solidity >=0.7.0 <0.9.0;

library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

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

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

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

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

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)
    {
        unchecked {
            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)
    {
        unchecked {
            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)
    {
        unchecked {
            // 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)
    {
        unchecked {
            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)
    {
        unchecked {
            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) {
        return a + b;
    }

    /**
     * @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) {
        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) {
        return a * b;
    }

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

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

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

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

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

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

abstract contract Ownable is Context {
    address private _owner;

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override
        returns (bool)
    {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

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

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

contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

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

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

    /**
     * @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 _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        address owner = _owners[tokenId];
        require(
            owner != address(0),
            "ERC721: owner query for nonexistent token"
        );
        return owner;
    }

    /**
     * @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 baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @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 || 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 _owners[tokenId] != address(0);
    }

    /**
     * @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 ||
            isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `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);

        _balances[to] += 1;
        _owners[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);

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

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

        _balances[owner] -= 1;
        delete _owners[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"
        );
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

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

    /**
     * @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()) {
            try
                IERC721Receiver(to).onERC721Received(
                    _msgSender(),
                    from,
                    tokenId,
                    _data
                )
            returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert(
                        "ERC721: transfer to non ERC721Receiver implementer"
                    );
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @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` and `to` are never both zero.
     *
     * 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 {}
}

abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            index < ERC721.balanceOf(owner),
            "ERC721Enumerable: owner index out of bounds"
        );
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            index < ERC721Enumerable.totalSupply(),
            "ERC721Enumerable: global index out of bounds"
        );
        return _allTokens[index];
    }

    /**
     * @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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
        private
    {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

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

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

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

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

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

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

contract PepitoPlatoon is ERC721Enumerable, Ownable {
    using Strings for uint256;
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    // Constants
    string public baseExtension = ".json";
    uint256 public cost = 0.1 ether;

    // Supply
    uint256 public mintReward = 10; 
    uint256 private creatorReward = 10;
    uint256 private devReward = 20;
    uint256 public maxSupply = 500;
    uint256 public lastSupply = maxSupply;
    uint256 public maxMintAmount = 10;

    // Reflection
    uint256 public reflectionBalance;
    uint256 public totalDividend;

    // Lists
    uint256[500] public remainingIds;
    mapping(uint256 => uint256) public lastDividendAt;
    mapping(uint256 => address) public minters;
    

    // Params
    bool public paused = true;
    bool private paysInTokens = false;
    string private _baseTokenURI;
    address private _wallet;

    // Addresses
    address public DexRouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    address public RewardToken = 0xb2cb83e8e1B326373B7F1068d10C50eBfa04F070;
    address private TeamReceiver = 0x42AAD010b66b8dE6185F6d0b6373783cf7569f72; 
    address private CreatorReceiver = 0x42AAD010b66b8dE6185F6d0b6373783cf7569f72; 
    address private DevReceiver = msg.sender; 

    

    //Contracts
    IUniswapV2Router02 public router;
    IERC20 public token;

    // Constructor
    constructor(
        string memory name,
        string memory symbol,
        string memory baseTokenURI
    ) ERC721(name, symbol) {
        // Save URI
        _baseTokenURI = baseTokenURI;
        // Save dev wallet
        _wallet = msg.sender;
        // Set router
        router = IUniswapV2Router02(DexRouter);
        // Set token
        token = IERC20(RewardToken);
    }

    // URI Handling
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }

    // Setters
    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    function setCost(uint256 _newCost) public onlyOwner {
        cost = _newCost;
    }

     function setPaysInTokens(bool _state) public onlyOwner {
        paysInTokens = _state;
    }

    function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
        maxMintAmount = _newmaxMintAmount;
    }

       function setBaseExtension(string memory _newBaseExtension)
        public
        onlyOwner
    {
        baseExtension = _newBaseExtension;
    }

    function pause(bool _state) public onlyOwner {
        paused = _state;
    }

    function setRewardToken(address _newRewardToken) public onlyOwner {
        RewardToken = _newRewardToken;
        token = IERC20(RewardToken);
    }

    function setDexRouter(address _newDexRouter) public onlyOwner {
        DexRouter = _newDexRouter;
        router = IUniswapV2Router02(DexRouter);
    }

    function setTeamReceiver(address _newTeamReceiver) public onlyOwner {
        TeamReceiver = _newTeamReceiver;
    }

    
    function setFees(uint256 _newcreatorReward, uint256 _newdevReward, uint256 _newmintReward) public onlyOwner {
        devReward = _newdevReward;
        creatorReward = _newcreatorReward;
        mintReward = _newmintReward;
        require(_newcreatorReward <= 20);
        require(_newdevReward <= 20);
    }

    // Minting
    function mint(uint256 _mintAmount) public payable {
        // Checks
        require(!paused, "Minting has not started yet");
        require(_mintAmount > 0, "You have to mint at least one");
        require(
            _mintAmount <= maxMintAmount,
            "You can only mint 10 at a time"
        );
        require(
            lastSupply >= _mintAmount,
            "Sold Out!"
        );
        if (msg.sender != owner()) {
            require(
                msg.value >= cost * _mintAmount,
                "Cost Doesnt Match"
            );
        }
       
        for (uint256 i = 1; i <= _mintAmount; i++) {
           
            _randomMint(msg.sender);            
            handleMintReward(msg.value / _mintAmount);
        }
    }

    // Give a random NFT to a contest winner
    function randomGiveaway(address _winner, uint256 _amount)
        external
        onlyOwner
    {
        // Checks
        require(_winner != address(0), "Cannot be zero address");
        require(_amount > 0, "You have to mint at least one");
        require(lastSupply != 0, "Collection is sold out");
        // Mint random NFTs for a winner
        for (uint256 i = 1; i <= _amount; i++) {
            _randomMint(_winner);
        }
    }

    // Random mint
    function _randomMint(address _target) internal returns (uint256) {
        // Get Random id to mint
        uint256 _index = _getRandom() % lastSupply;
        uint256 _realIndex = getValue(_index) + 1;
        // Reduce supply
        lastSupply--;
        // Replace used id by last
        remainingIds[_index] = getValue(lastSupply);
        // Mint
        _safeMint(_target, _realIndex);
        // Save Original minters
        minters[_realIndex] = msg.sender;
        // Save dividend
        lastDividendAt[_realIndex] = totalDividend;
        return _realIndex;
    }

    // Mint for reserved spots
    function _regularMint() internal returns (uint256) {
        // Get Actual id to mint
        uint256 _index = totalSupply();
        uint256 _realIndex = getValue(_index) + 1;
        // Reduce supply
        lastSupply--;
        // Replace used id by last
        remainingIds[_index] = getValue(lastSupply);
        // Mint
        _safeMint(msg.sender, _realIndex);
        // Save Original minters
        minters[_realIndex] = msg.sender;
        // Save dividend
        lastDividendAt[_realIndex] = totalDividend;
        return _realIndex;
    }

    // Get Token List
    function getTokenIds(address _owner)
        public
        view
        returns (uint256[] memory)
    {
        // Count owned Token
        uint256 ownerTokenCount = balanceOf(_owner);
        uint256[] memory tokenIds = new uint256[](ownerTokenCount);
        // Get ids of owned Token
        for (uint256 i; i < ownerTokenCount; i++) {
            tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokenIds;
    }

    // Return compiled Token URI
    function tokenURI(uint256 _id)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(_id), "URI query for nonexistent token");
        string memory currentBaseURI = _baseURI();
        return
            bytes(currentBaseURI).length > 0
                ? string(
                    abi.encodePacked(
                        currentBaseURI,
                        _id.toString(),
                        baseExtension
                    )
                )
                : "";
    }

    // Payments & Reflections
    
  function withdraw() public payable onlyOwner {
    (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
    require(success);
  }
  

    // Reflections
    function handleMintReward(uint256 _amount) private {
        // Split payment
        uint256 mintShare = _amount.div(mintReward);
        uint256 creatorShare = _amount.div(creatorReward);
        uint256 devShare = _amount.div(devReward);
        uint256 teamShare = _amount.sub(mintShare).sub(creatorShare).sub(devShare);
        
        // Save dividend for community
        reflectDividend(mintShare);
        // Send owner share
        payable(TeamReceiver).transfer(teamShare);
        payable(CreatorReceiver).transfer(creatorShare);
        payable(DevReceiver).transfer(devShare);
    }

    // Add dividend
    function reflectDividend(uint256 _amount) private {
        reflectionBalance = reflectionBalance.add(_amount);
        totalDividend = totalDividend.add((_amount.div(totalSupply())));
    }

    function reflectToOwners() public payable {
        reflectDividend(msg.value);
    }

    function getReflectionBalances(address _owner)
        public
        view
        returns (uint256)
    {
        uint256 count = balanceOf(_owner);
        uint256 total = 0;
        for (uint256 i = 0; i < count; i++) {
            uint256 tokenId = tokenOfOwnerByIndex(_owner, i);
            total = total.add(getReflectionBalance(tokenId));
        }
        return total;
    }

    function getReflectionBalance(uint256 tokenId)
        public
        view
        returns (uint256)
    {
        return totalDividend.sub(lastDividendAt[tokenId]);
    }

    function claimRewards() public {
        require(!paysInTokens, "Rewards are paid in tokens");
        uint256 count = balanceOf(msg.sender);
        uint256 balance = 0;
        for (uint256 i = 0; i < count; i++) {
            uint256 tokenId = tokenOfOwnerByIndex(msg.sender, i);
            balance = balance.add(getReflectionBalance(tokenId));
            lastDividendAt[tokenId] = totalDividend;
        }
        payable(msg.sender).transfer(balance);
    }

    function claimRewardsTokens() public {
        uint256 count = balanceOf(msg.sender);
        uint256 initialBalanceOf = token.balanceOf(address(this));
        uint256 balance = 0;
        for (uint256 i = 0; i < count; i++) {
            uint256 tokenId = tokenOfOwnerByIndex(msg.sender, i);
            balance = balance.add(getReflectionBalance(tokenId));
            lastDividendAt[tokenId] = totalDividend;
        }
        // Covert Balance to Tokens
        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = RewardToken;

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{value : balance}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 finalBalanceOf = token.balanceOf(address(this));
        uint256 tokens = finalBalanceOf.sub(initialBalanceOf);
        token.transfer(msg.sender, tokens);
    }
    // Utils

    // Get value from a remaining id node
    function getValue(uint256 _index) internal view returns (uint256) {
        if (remainingIds[_index] != 0) return remainingIds[_index];
        else return _index;
    }

    // Create a random id for minting
    function _getRandom() internal view returns (uint256) {
        return
            uint256(
                keccak256(
                    abi.encodePacked(
                        block.difficulty,
                        block.timestamp,
                        lastSupply
                    )
                )
            );
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseTokenURI","type":"string"}],"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":"DexRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimRewardsTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getReflectionBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getReflectionBalances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lastDividendAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"minters","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_winner","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"randomGiveaway","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reflectToOwners","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"reflectionBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"remainingIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newDexRouter","type":"address"}],"name":"setDexRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newcreatorReward","type":"uint256"},{"internalType":"uint256","name":"_newdevReward","type":"uint256"},{"internalType":"uint256","name":"_newmintReward","type":"uint256"}],"name":"setFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaysInTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newRewardToken","type":"address"}],"name":"setRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newTeamReceiver","type":"address"}],"name":"setTeamReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setmaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"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":"_id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividend","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000e50657069746f20506c61746f6f6e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000450455049000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043697066733a2f2f626166796265696836363666656a79356864773633703363707172323269346d6364757677373235703364686271796e356c36707264666a6562612f0000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Pepito Platoon
Arg [1] : symbol (string): PEPI
Arg [2] : baseTokenURI (string): ipfs://bafybeih666fejy5hdw63p3cpqr22i4mcduvw725p3dhbqyn5l6prdfjeba/

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [4] : 50657069746f20506c61746f6f6e000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [6] : 5045504900000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [8] : 697066733a2f2f626166796265696836363666656a7935686477363370336370
Arg [9] : 7172323269346d6364757677373235703364686271796e356c36707264666a65
Arg [10] : 62612f0000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

56280:10945:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64966:177;;;;;;;;;;-1:-1:-1;64966:177:0;;;;;:::i;:::-;;:::i;:::-;;;345:25:1;;;333:2;318:18;64966:177:0;;;;;;;;42366:300;;;;;;;;;;-1:-1:-1;42366:300:0;;;;;:::i;:::-;;:::i;:::-;;;932:14:1;;925:22;907:41;;895:2;880:18;42366:300:0;767:187:1;58883:79:0;;;;;;;;;;-1:-1:-1;58883:79:0;;;;;:::i;:::-;;:::i;:::-;;64467:87;;;:::i;29843:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;31536:308::-;;;;;;;;;;-1:-1:-1;31536:308:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;31059:411::-;;;;;;;;;;-1:-1:-1;31059:411:0;;;;;:::i;:::-;;:::i;56510:31::-;;;;;;;;;;;;;;;;56565:30;;;;;;;;;;;;;;;;43169:113;;;;;;;;;;-1:-1:-1;43257:10:0;:17;43169:113;;56762:33;;;;;;;;;;;;;;;;32595:376;;;;;;;;;;-1:-1:-1;32595:376:0;;;;;:::i;:::-;;:::i;42750:343::-;;;;;;;;;;-1:-1:-1;42750:343:0;;;;;:::i;:::-;;:::i;65151:474::-;;;;;;;;;;;;;:::i;63435:158::-;;;:::i;56823:32::-;;;;;;;;;;;;;;;;33042:185;;;;;;;;;;-1:-1:-1;33042:185:0;;;;;:::i;:::-;;:::i;58393:86::-;;;;;;;;;;-1:-1:-1;58393:86:0;;;;;:::i;:::-;;:::i;56862:28::-;;;;;;;;;;;;;;;;43359:320;;;;;;;;;;-1:-1:-1;43359:320:0;;;;;:::i;:::-;;:::i;65633:959::-;;;;;;;;;;;;;:::i;58281:104::-;;;;;;;;;;-1:-1:-1;58281:104:0;;;;;:::i;:::-;;:::i;57080:25::-;;;;;;;;;;-1:-1:-1;57080:25:0;;;;;;;;29450:326;;;;;;;;;;-1:-1:-1;29450:326:0;;;;;:::i;:::-;;:::i;29093:295::-;;;;;;;;;;-1:-1:-1;29093:295:0;;;;;:::i;:::-;;:::i;11103:94::-;;;;;;;;;;;;;:::i;57237:69::-;;;;;;;;;;-1:-1:-1;57237:69:0;;;;-1:-1:-1;;;;;57237:69:0;;;58591:122;;;;;;;;;;-1:-1:-1;58591:122:0;;;;;:::i;:::-;;:::i;57008:42::-;;;;;;;;;;-1:-1:-1;57008:42:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;57008:42:0;;;58970:152;;;;;;;;;;-1:-1:-1;58970:152:0;;;;;:::i;:::-;;:::i;10444:87::-;;;;;;;;;;;;;:::i;30012:104::-;;;;;;;;;;;;;:::i;59293:118::-;;;;;;;;;;-1:-1:-1;59293:118:0;;;;;:::i;:::-;;:::i;59765:784::-;;;;;;:::i;:::-;;:::i;31916:327::-;;;;;;;;;;-1:-1:-1;31916:327:0;;;;;:::i;:::-;;:::i;64562:396::-;;;;;;;;;;-1:-1:-1;64562:396:0;;;;;:::i;:::-;;:::i;60603:457::-;;;;;;;;;;-1:-1:-1;60603:457:0;;;;;:::i;:::-;;:::i;33298:365::-;;;;;;;;;;-1:-1:-1;33298:365:0;;;;;:::i;:::-;;:::i;56466:37::-;;;;;;;;;;;;;:::i;62817:575::-;;;;;;;;;;-1:-1:-1;62817:575:0;;;;;:::i;:::-;;:::i;59425:316::-;;;;;;;;;;-1:-1:-1;59425:316:0;;;;;:::i;:::-;;:::i;62322:453::-;;;;;;;;;;-1:-1:-1;62322:453:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;56952:49::-;;;;;;;;;;-1:-1:-1;56952:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;56681:30;;;;;;;;;;;;;;;;58724:151;;;;;;;;;;-1:-1:-1;58724:151:0;;;;;:::i;:::-;;:::i;32314:214::-;;;;;;;;;;-1:-1:-1;32314:214:0;;;;;:::i;:::-;;:::i;56913:32::-;;;;;;;;;;-1:-1:-1;56913:32:0;;;;;:::i;:::-;;:::i;57313:71::-;;;;;;;;;;-1:-1:-1;57313:71:0;;;;-1:-1:-1;;;;;57313:71:0;;;11352:229;;;;;;;;;;-1:-1:-1;11352:229:0;;;;;:::i;:::-;;:::i;59130:155::-;;;;;;;;;;-1:-1:-1;59130:155:0;;;;;:::i;:::-;;:::i;56718:37::-;;;;;;;;;;;;;;;;57631:32;;;;;;;;;;-1:-1:-1;57631:32:0;;;;-1:-1:-1;;;;;57631:32:0;;;57670:19;;;;;;;;;;-1:-1:-1;57670:19:0;;;;-1:-1:-1;;;;;57670:19:0;;;58488:95;;;;;;;;;;-1:-1:-1;58488:95:0;;;;;:::i;:::-;;:::i;64966:177::-;65061:7;65111:23;;;:14;:23;;;;;;65093:13;;:42;;:17;:42::i;:::-;65086:49;64966:177;-1:-1:-1;;64966:177:0:o;42366:300::-;42513:4;-1:-1:-1;;;;;;42555:50:0;;-1:-1:-1;;;42555:50:0;;:103;;;42622:36;42646:11;42622:23;:36::i;58883:79::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;;;;;;;;;58939:6:::1;:15:::0;;-1:-1:-1;;58939:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;58883:79::o;64467:87::-;64520:26;64536:9;64520:15;:26::i;:::-;64467:87::o;29843:100::-;29897:13;29930:5;29923:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29843:100;:::o;31536:308::-;31657:7;31704:16;31712:7;31704;:16::i;:::-;31682:110;;;;-1:-1:-1;;;31682:110:0;;8630:2:1;31682:110:0;;;8612:21:1;8669:2;8649:18;;;8642:30;8708:34;8688:18;;;8681:62;-1:-1:-1;;;8759:18:1;;;8752:42;8811:19;;31682:110:0;8428:408:1;31682:110:0;-1:-1:-1;31812:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;31812:24:0;;31536:308::o;31059:411::-;31140:13;31156:23;31171:7;31156:14;:23::i;:::-;31140:39;;31204:5;-1:-1:-1;;;;;31198:11:0;:2;-1:-1:-1;;;;;31198:11:0;;31190:57;;;;-1:-1:-1;;;31190:57:0;;9043:2:1;31190:57:0;;;9025:21:1;9082:2;9062:18;;;9055:30;9121:34;9101:18;;;9094:62;-1:-1:-1;;;9172:18:1;;;9165:31;9213:19;;31190:57:0;8841:397:1;31190:57:0;9882:10;-1:-1:-1;;;;;31282:21:0;;;;:62;;-1:-1:-1;31307:37:0;31324:5;9882:10;32314:214;:::i;31307:37::-;31260:168;;;;-1:-1:-1;;;31260:168:0;;9445:2:1;31260:168:0;;;9427:21:1;9484:2;9464:18;;;9457:30;9523:34;9503:18;;;9496:62;-1:-1:-1;;;9574:18:1;;;9567:54;9638:19;;31260:168:0;9243:420:1;31260:168:0;31441:21;31450:2;31454:7;31441:8;:21::i;:::-;31129:341;31059:411;;:::o;32595:376::-;32804:41;9882:10;32837:7;32804:18;:41::i;:::-;32782:140;;;;-1:-1:-1;;;32782:140:0;;;;;;;:::i;:::-;32935:28;32945:4;32951:2;32955:7;32935:9;:28::i;42750:343::-;42892:7;42947:23;42964:5;42947:16;:23::i;:::-;42939:5;:31;42917:124;;;;-1:-1:-1;;;42917:124:0;;10288:2:1;42917:124:0;;;10270:21:1;10327:2;10307:18;;;10300:30;10366:34;10346:18;;;10339:62;-1:-1:-1;;;10417:18:1;;;10410:41;10468:19;;42917:124:0;10086:407:1;42917:124:0;-1:-1:-1;;;;;;43059:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;42750:343::o;65151:474::-;65202:12;;;;;;;65201:13;65193:52;;;;-1:-1:-1;;;65193:52:0;;10700:2:1;65193:52:0;;;10682:21:1;10739:2;10719:18;;;10712:30;-1:-1:-1;;;10758:18:1;;;10751:56;10824:18;;65193:52:0;10498:350:1;65193:52:0;65256:13;65272:21;65282:10;65272:9;:21::i;:::-;65256:37;;65304:15;65339:9;65334:236;65358:5;65354:1;:9;65334:236;;;65385:15;65403:34;65423:10;65435:1;65403:19;:34::i;:::-;65385:52;;65462:42;65474:29;65495:7;65474:20;:29::i;:::-;65462:7;;:11;:42::i;:::-;65545:13;;65519:23;;;;:14;:23;;;;;;:39;;;;65452:52;-1:-1:-1;65365:3:0;;;;:::i;:::-;;;;65334:236;;;-1:-1:-1;65580:37:0;;65588:10;;65580:37;;;;;65609:7;;65580:37;;;;65609:7;65588:10;65580:37;;;;;;;;;;;;;;;;;;;63435:158;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;63506:58:::1;::::0;63488:12:::1;::::0;63514:10:::1;::::0;63538:21:::1;::::0;63488:12;63506:58;63488:12;63506:58;63538:21;63514:10;63506:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63487:77;;;63579:7;63571:16;;;::::0;::::1;;63480:113;63435:158::o:0;33042:185::-;33180:39;33197:4;33203:2;33207:7;33180:39;;;;;;;;;;;;:16;:39::i;58393:86::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;58456:4:::1;:15:::0;58393:86::o;43359:320::-;43479:7;43534:30;43257:10;:17;;43169:113;43534:30;43526:5;:38;43504:132;;;;-1:-1:-1;;;43504:132:0;;11537:2:1;43504:132:0;;;11519:21:1;11576:2;11556:18;;;11549:30;11615:34;11595:18;;;11588:62;-1:-1:-1;;;11666:18:1;;;11659:42;11718:19;;43504:132:0;11335:408:1;43504:132:0;43654:10;43665:5;43654:17;;;;;;;;:::i;:::-;;;;;;;;;43647:24;;43359:320;;;:::o;65633:959::-;65681:13;65697:21;65707:10;65697:9;:21::i;:::-;65756:5;;:30;;-1:-1:-1;;;65756:30:0;;65681:37;;-1:-1:-1;65729:24:0;;-1:-1:-1;;;;;65756:5:0;;;;:15;;:30;;65780:4;;65756:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65729:57;;65797:15;65832:9;65827:236;65851:5;65847:1;:9;65827:236;;;65878:15;65896:34;65916:10;65928:1;65896:19;:34::i;:::-;65878:52;;65955:42;65967:29;65988:7;65967:20;:29::i;65955:42::-;66038:13;;66012:23;;;;:14;:23;;;;;;:39;;;;65945:52;-1:-1:-1;65858:3:0;;;;:::i;:::-;;;;65827:236;;;-1:-1:-1;66134:16:0;;;66148:1;66134:16;;;;;;;;66110:21;;66134:16;;;;;;;;-1:-1:-1;;66171:6:0;;:13;;;-1:-1:-1;;;66171:13:0;;;;66110:40;;-1:-1:-1;;;;;;66171:6:0;;;;:11;;-1:-1:-1;66171:13:0;;;;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66161:4;66166:1;66161:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;66161:23:0;;;:7;;;;;;;;;:23;66205:11;;66195:7;;66205:11;;;66195:4;;66205:11;;66195:7;;;;;;:::i;:::-;-1:-1:-1;;;;;66195:21:0;;;:7;;;;;;;;;:21;66229:6;;:178;;-1:-1:-1;;;66229:178:0;;:6;;;:57;;66295:7;;66229:178;;:6;;66334:4;;66361;;66381:15;;66229:178;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;66445:5:0;;:30;;-1:-1:-1;;;66445:30:0;;66420:22;;-1:-1:-1;;;;;;66445:5:0;;;;-1:-1:-1;66445:15:0;;-1:-1:-1;66445:30:0;;66469:4;;66445:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66420:55;-1:-1:-1;66486:14:0;66503:36;66420:55;66522:16;66503:18;:36::i;:::-;66550:5;;:34;;-1:-1:-1;;;66550:34:0;;66565:10;66550:34;;;13412:51:1;13479:18;;;13472:34;;;66486:53:0;;-1:-1:-1;;;;;;66550:5:0;;:14;;13385:18:1;;66550:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;65670:922;;;;;;65633:959::o;58281:104::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;58354:13:::1;:23;58370:7:::0;58354:13;:23:::1;:::i;:::-;;58281:104:::0;:::o;29450:326::-;29567:7;29608:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29608:16:0;;29635:110;;;;-1:-1:-1;;;29635:110:0;;16173:2:1;29635:110:0;;;16155:21:1;16212:2;16192:18;;;16185:30;16251:34;16231:18;;;16224:62;-1:-1:-1;;;16302:18:1;;;16295:39;16351:19;;29635:110:0;15971:405:1;29093:295:0;29210:7;-1:-1:-1;;;;;29257:19:0;;29235:111;;;;-1:-1:-1;;;29235:111:0;;16583:2:1;29235:111:0;;;16565:21:1;16622:2;16602:18;;;16595:30;16661:34;16641:18;;;16634:62;-1:-1:-1;;;16712:18:1;;;16705:40;16762:19;;29235:111:0;16381:406:1;29235:111:0;-1:-1:-1;;;;;;29364:16:0;;;;;:9;:16;;;;;;;29093:295::o;11103:94::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;11168:21:::1;11186:1;11168:9;:21::i;58591:122::-:0;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;58672:13:::1;:33:::0;58591:122::o;58970:152::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;59047:11:::1;:29:::0;;-1:-1:-1;;;;;59047:29:0;;::::1;-1:-1:-1::0;;;;;;59047:29:0;;::::1;::::0;::::1;::::0;;;59087:5:::1;:27:::0;;;;::::1;;::::0;;58970:152::o;10444:87::-;10517:6;;-1:-1:-1;;;;;10517:6:0;;10444:87::o;30012:104::-;30068:13;30101:7;30094:14;;;;;:::i;59293:118::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;59372:12:::1;:31:::0;;-1:-1:-1;;;;;;59372:31:0::1;-1:-1:-1::0;;;;;59372:31:0;;;::::1;::::0;;;::::1;::::0;;59293:118::o;59765:784::-;59854:6;;;;59853:7;59845:47;;;;-1:-1:-1;;;59845:47:0;;16994:2:1;59845:47:0;;;16976:21:1;17033:2;17013:18;;;17006:30;17072:29;17052:18;;;17045:57;17119:18;;59845:47:0;16792:351:1;59845:47:0;59925:1;59911:11;:15;59903:57;;;;-1:-1:-1;;;59903:57:0;;;;;;;:::i;:::-;60008:13;;59993:11;:28;;59971:108;;;;-1:-1:-1;;;59971:108:0;;17708:2:1;59971:108:0;;;17690:21:1;17747:2;17727:18;;;17720:30;17786:32;17766:18;;;17759:60;17836:18;;59971:108:0;17506:354:1;59971:108:0;60126:11;60112:10;;:25;;60090:84;;;;-1:-1:-1;;;60090:84:0;;18067:2:1;60090:84:0;;;18049:21:1;18106:1;18086:18;;;18079:29;-1:-1:-1;;;18124:18:1;;;18117:39;18173:18;;60090:84:0;17865:332:1;60090:84:0;60203:7;:5;:7::i;:::-;-1:-1:-1;;;;;60189:21:0;:10;-1:-1:-1;;;;;60189:21:0;;60185:164;;60273:11;60266:4;;:18;;;;:::i;:::-;60253:9;:31;;60227:110;;;;-1:-1:-1;;;60227:110:0;;18577:2:1;60227:110:0;;;18559:21:1;18616:2;18596:18;;;18589:30;-1:-1:-1;;;18635:18:1;;;18628:47;18692:18;;60227:110:0;18375:341:1;60227:110:0;60385:1;60368:174;60393:11;60388:1;:16;60368:174;;60439:23;60451:10;60439:11;:23::i;:::-;-1:-1:-1;60489:41:0;60506:23;60518:11;60506:9;:23;:::i;:::-;60489:16;:41::i;:::-;60406:3;;;;:::i;:::-;;;;60368:174;;31916:327;9882:10;-1:-1:-1;;;;;32051:24:0;;;32043:62;;;;-1:-1:-1;;;32043:62:0;;19180:2:1;32043:62:0;;;19162:21:1;19219:2;19199:18;;;19192:30;-1:-1:-1;;;19238:18:1;;;19231:55;19303:18;;32043:62:0;18978:349:1;32043:62:0;9882:10;32118:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;32118:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;32118:53:0;;;;;;;;;;32187:48;;907:41:1;;;32118:42:0;;9882:10;32187:48;;880:18:1;32187:48:0;;;;;;;31916:327;;:::o;64562:396::-;64657:7;64682:13;64698:17;64708:6;64698:9;:17::i;:::-;64682:33;;64726:13;64759:9;64754:174;64778:5;64774:1;:9;64754:174;;;64805:15;64823:30;64843:6;64851:1;64823:19;:30::i;:::-;64805:48;;64876:40;64886:29;64907:7;64886:20;:29::i;64876:40::-;64868:48;;64790:138;64785:3;;;;;:::i;:::-;;;;64754:174;;;-1:-1:-1;64945:5:0;64562:396;-1:-1:-1;;;64562:396:0:o;60603:457::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;60741:21:0;::::1;60733:56;;;::::0;-1:-1:-1;;;60733:56:0;;19534:2:1;60733:56:0::1;::::0;::::1;19516:21:1::0;19573:2;19553:18;;;19546:30;-1:-1:-1;;;19592:18:1;;;19585:52;19654:18;;60733:56:0::1;19332:346:1::0;60733:56:0::1;60818:1;60808:7;:11;60800:53;;;;-1:-1:-1::0;;;60800:53:0::1;;;;;;;:::i;:::-;60872:10;;60886:1;60872:15:::0;60864:50:::1;;;::::0;-1:-1:-1;;;60864:50:0;;19885:2:1;60864:50:0::1;::::0;::::1;19867:21:1::0;19924:2;19904:18;;;19897:30;-1:-1:-1;;;19943:18:1;;;19936:52;20005:18;;60864:50:0::1;19683:346:1::0;60864:50:0::1;60984:1;60967:86;60992:7;60987:1;:12;60967:86;;61021:20;61033:7;61021:11;:20::i;:::-;-1:-1:-1::0;61001:3:0;::::1;::::0;::::1;:::i;:::-;;;;60967:86;;33298:365:::0;33487:41;9882:10;33520:7;33487:18;:41::i;:::-;33465:140;;;;-1:-1:-1;;;33465:140:0;;;;;;;:::i;:::-;33616:39;33630:4;33636:2;33640:7;33649:5;33616:13;:39::i;:::-;33298:365;;;;:::o;56466:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;62817:575::-;62931:13;62970:12;62978:3;62970:7;:12::i;:::-;62962:56;;;;-1:-1:-1;;;62962:56:0;;20236:2:1;62962:56:0;;;20218:21:1;20275:2;20255:18;;;20248:30;20314:33;20294:18;;;20287:61;20365:18;;62962:56:0;20034:355:1;62962:56:0;63029:28;63060:10;:8;:10::i;:::-;63029:41;;63132:1;63107:14;63101:28;:32;:283;;;;;;;;;;;;;;;;;63225:14;63266;:3;:12;:14::i;:::-;63307:13;63182:161;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63101:283;63081:303;62817:575;-1:-1:-1;;;62817:575:0:o;59425:316::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;59544:9:::1;:25:::0;;;59580:13:::1;:33:::0;;;59624:10:::1;:27:::0;;;59691:2:::1;59670:23:::0;::::1;;59662:32;;;::::0;::::1;;59730:2;59713:13;:19;;59705:28;;;::::0;::::1;62322:453:::0;62407:16;62471:23;62497:17;62507:6;62497:9;:17::i;:::-;62471:43;;62525:25;62567:15;-1:-1:-1;;;;;62553:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62553:30:0;;62525:58;;62634:9;62629:113;62649:15;62645:1;:19;62629:113;;;62700:30;62720:6;62728:1;62700:19;:30::i;:::-;62686:8;62695:1;62686:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;62666:3;;;;:::i;:::-;;;;62629:113;;58724:151;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;58834:13:::1;:33;58850:17:::0;58834:13;:33:::1;:::i;32314:214::-:0;-1:-1:-1;;;;;32485:25:0;;;32456:4;32485:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;32314:214::o;56913:32::-;;;;;;;;;;;;;;;-1:-1:-1;56913:32:0;:::o;11352:229::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;11455:22:0;::::1;11433:110;;;::::0;-1:-1:-1;;;11433:110:0;;21857:2:1;11433:110:0::1;::::0;::::1;21839:21:1::0;21896:2;21876:18;;;21869:30;21935:34;21915:18;;;21908:62;-1:-1:-1;;;21986:18:1;;;21979:36;22032:19;;11433:110:0::1;21655:402:1::0;11433:110:0::1;11554:19;11564:8;11554:9;:19::i;59130:155::-:0;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;59203:9:::1;:25:::0;;-1:-1:-1;;;;;59203:25:0;;::::1;-1:-1:-1::0;;;;;;59203:25:0;;::::1;::::0;::::1;::::0;;;59239:6:::1;:38:::0;;;;::::1;;::::0;;59130:155::o;58488:95::-;9882:10;10664:7;:5;:7::i;:::-;-1:-1:-1;;;;;10664:23:0;;10656:68;;;;-1:-1:-1;;;10656:68:0;;;;;;;:::i;:::-;58554:12:::1;:21:::0;;;::::1;;;;-1:-1:-1::0;;58554:21:0;;::::1;::::0;;;::::1;::::0;;58488:95::o;4006:98::-;4064:7;4091:5;4095:1;4091;:5;:::i;28674:355::-;28821:4;-1:-1:-1;;;;;;28863:40:0;;-1:-1:-1;;;28863:40:0;;:105;;-1:-1:-1;;;;;;;28920:48:0;;-1:-1:-1;;;28920:48:0;28863:105;:158;;;-1:-1:-1;;;;;;;;;;21608:40:0;;;28985:36;21449:207;64266:193;64347:17;;:30;;64369:7;64347:21;:30::i;:::-;64327:17;:50;64404:47;64423:26;64435:13;43257:10;:17;;43169:113;64435:13;64423:7;;:11;:26::i;:::-;64404:13;;;:17;:47::i;:::-;64388:13;:63;-1:-1:-1;64266:193:0:o;35210:127::-;35275:4;35299:16;;;:7;:16;;;;;;-1:-1:-1;;;;;35299:16:0;:30;;;35210:127::o;39333:174::-;39408:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;39408:29:0;-1:-1:-1;;;;;39408:29:0;;;;;;;;:24;;39462:23;39408:24;39462:14;:23::i;:::-;-1:-1:-1;;;;;39453:46:0;;;;;;;;;;;39333:174;;:::o;35504:452::-;35633:4;35677:16;35685:7;35677;:16::i;:::-;35655:110;;;;-1:-1:-1;;;35655:110:0;;22397:2:1;35655:110:0;;;22379:21:1;22436:2;22416:18;;;22409:30;22475:34;22455:18;;;22448:62;-1:-1:-1;;;22526:18:1;;;22519:42;22578:19;;35655:110:0;22195:408:1;35655:110:0;35776:13;35792:23;35807:7;35792:14;:23::i;:::-;35776:39;;35845:5;-1:-1:-1;;;;;35834:16:0;:7;-1:-1:-1;;;;;35834:16:0;;:64;;;;35891:7;-1:-1:-1;;;;;35867:31:0;:20;35879:7;35867:11;:20::i;:::-;-1:-1:-1;;;;;35867:31:0;;35834:64;:113;;;;35915:32;35932:5;35939:7;35915:16;:32::i;:::-;35826:122;35504:452;-1:-1:-1;;;;35504:452:0:o;38600:615::-;38773:4;-1:-1:-1;;;;;38746:31:0;:23;38761:7;38746:14;:23::i;:::-;-1:-1:-1;;;;;38746:31:0;;38724:122;;;;-1:-1:-1;;;38724:122:0;;22810:2:1;38724:122:0;;;22792:21:1;22849:2;22829:18;;;22822:30;22888:34;22868:18;;;22861:62;-1:-1:-1;;;22939:18:1;;;22932:39;22988:19;;38724:122:0;22608:405:1;38724:122:0;-1:-1:-1;;;;;38865:16:0;;38857:65;;;;-1:-1:-1;;;38857:65:0;;23220:2:1;38857:65:0;;;23202:21:1;23259:2;23239:18;;;23232:30;23298:34;23278:18;;;23271:62;-1:-1:-1;;;23349:18:1;;;23342:34;23393:19;;38857:65:0;23018:400:1;38857:65:0;38935:39;38956:4;38962:2;38966:7;38935:20;:39::i;:::-;39039:29;39056:1;39060:7;39039:8;:29::i;:::-;-1:-1:-1;;;;;39081:15:0;;;;;;:9;:15;;;;;:20;;39100:1;;39081:15;:20;;39100:1;;39081:20;:::i;:::-;;;;-1:-1:-1;;;;;;;39112:13:0;;;;;;:9;:13;;;;;:18;;39129:1;;39112:13;:18;;39129:1;;39112:18;:::i;:::-;;;;-1:-1:-1;;39141:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;39141:21:0;-1:-1:-1;;;;;39141:21:0;;;;;;;;;39180:27;;39141:16;;39180:27;;;;;;;38600:615;;;:::o;3625:98::-;3683:7;3710:5;3714:1;3710;:5;:::i;11589:173::-;11664:6;;;-1:-1:-1;;;;;11681:17:0;;;-1:-1:-1;;;;;;11681:17:0;;;;;;;11714:40;;11664:6;;;11681:17;11664:6;;11714:40;;11645:16;;11714:40;11634:128;11589:173;:::o;61088:593::-;61230:10;;67019:161;;;67062:16;67019:161;;;;24415:19:1;;;;67105:15:0;24450:12:1;;;24443:28;24487:12;;;;24480:28;;;67019:161:0;;;;;;;;;;24524:12:1;;;;67019:161:0;;;66987:212;;;;;61144:7;;;;61215:25;;;;:::i;:::-;61198:42;;61251:18;61272:16;61281:6;61272:8;:16::i;:::-;:20;;61291:1;61272:20;:::i;:::-;61329:10;:12;;61251:41;;-1:-1:-1;61329:10:0;:12;;;:::i;:::-;;;;;;61411:20;61420:10;;61411:8;:20::i;:::-;61388:12;61401:6;61388:20;;;;;;;:::i;:::-;;:43;61459:30;61469:7;61478:10;61459:9;:30::i;:::-;61534:19;;;;:7;:19;;;;;;;;:32;;-1:-1:-1;;;;;;61534:32:0;61556:10;61534:32;;;61632:13;;61603:14;:26;;;;;;:42;61542:10;61088:593;-1:-1:-1;;;61088:593:0:o;63625:612::-;63713:17;63733:23;63745:10;;63733:7;:11;;:23;;;;:::i;:::-;63713:43;;63767:20;63790:26;63802:13;;63790:7;:11;;:26;;;;:::i;:::-;63767:49;;63827:16;63846:22;63858:9;;63846:7;:11;;:22;;;;:::i;:::-;63827:41;-1:-1:-1;63879:17:0;63899:54;63827:41;63899:40;63926:12;63899:40;:7;63911:9;63899:11;:22::i;:::-;:26;;:40::i;:54::-;63879:74;;64014:26;64030:9;64014:15;:26::i;:::-;64088:12;;64080:41;;-1:-1:-1;;;;;64088:12:0;;;;64080:41;;;;;64111:9;;64088:12;64080:41;64088:12;64080:41;64111:9;64088:12;64080:41;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64140:15:0;;64132:47;;-1:-1:-1;;;;;64140:15:0;;;;64132:47;;;;;64166:12;;64140:15;64132:47;64140:15;64132:47;64166:12;64140:15;64132:47;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64198:11:0;;64190:39;;-1:-1:-1;;;;;64198:11:0;;;;64190:39;;;;;64220:8;;64198:11;64190:39;64198:11;64190:39;64220:8;64198:11;64190:39;;;;;;;;;;;;;;;;;;;;;63676:561;;;;63625:612;:::o;34545:352::-;34702:28;34712:4;34718:2;34722:7;34702:9;:28::i;:::-;34763:48;34786:4;34792:2;34796:7;34805:5;34763:22;:48::i;:::-;34741:148;;;;-1:-1:-1;;;34741:148:0;;;;;;;:::i;58143:114::-;58203:13;58236;58229:20;;;;;:::i;7978:723::-;8034:13;8255:5;8264:1;8255:10;8251:53;;-1:-1:-1;;8282:10:0;;;;;;;;;;;;-1:-1:-1;;;8282:10:0;;;;;7978:723::o;8251:53::-;8329:5;8314:12;8370:78;8377:9;;8370:78;;8403:8;;;;:::i;:::-;;-1:-1:-1;8426:10:0;;-1:-1:-1;8434:2:0;8426:10;;:::i;:::-;;;8370:78;;;8458:19;8490:6;-1:-1:-1;;;;;8480:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8480:17:0;;8458:39;;8508:154;8515:10;;8508:154;;8542:11;8552:1;8542:11;;:::i;:::-;;-1:-1:-1;8611:10:0;8619:2;8611:5;:10;:::i;:::-;8598:24;;:2;:24;:::i;:::-;8585:39;;8568:6;8575;8568:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;8568:56:0;;;;;;;;-1:-1:-1;8639:11:0;8648:2;8639:11;;:::i;:::-;;;8508:154;;4762:98;4820:7;4847:5;4851:1;4847;:5;:::i;44292:589::-;-1:-1:-1;;;;;44498:18:0;;44494:187;;44533:40;44565:7;45708:10;:17;;45681:24;;;;:15;:24;;;;;:44;;;45736:24;;;;;;;;;;;;45604:164;44533:40;44494:187;;;44603:2;-1:-1:-1;;;;;44595:10:0;:4;-1:-1:-1;;;;;44595:10:0;;44591:90;;44622:47;44655:4;44661:7;44622:32;:47::i;:::-;-1:-1:-1;;;;;44695:16:0;;44691:183;;44728:45;44765:7;44728:36;:45::i;44691:183::-;44801:4;-1:-1:-1;;;;;44795:10:0;:2;-1:-1:-1;;;;;44795:10:0;;44791:83;;44822:40;44850:2;44854:7;44822:27;:40::i;66657:172::-;66714:7;66738:12;66751:6;66738:20;;;;;;;:::i;:::-;;;:25;66734:87;;66772:12;66785:6;66772:20;;;;;;;:::i;:::-;;;;66657:172;-1:-1:-1;;66657:172:0:o;66734:87::-;-1:-1:-1;66815:6:0;66657:172::o;36298:110::-;36374:26;36384:2;36388:7;36374:26;;;;;;;;;;;;:9;:26::i;40072:980::-;40227:4;-1:-1:-1;;;;;40248:13:0;;12702:20;12750:8;40244:801;;40301:175;;-1:-1:-1;;;40301:175:0;;-1:-1:-1;;;;;40301:36:0;;;;;:175;;9882:10;;40395:4;;40422:7;;40452:5;;40301:175;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40301:175:0;;;;;;;;-1:-1:-1;;40301:175:0;;;;;;;;;;;;:::i;:::-;;;40280:710;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40659:6;:13;40676:1;40659:18;40655:320;;40702:108;;-1:-1:-1;;;40702:108:0;;;;;;;:::i;40655:320::-;40925:6;40919:13;40910:6;40906:2;40902:15;40895:38;40280:710;-1:-1:-1;;;;;;40540:51:0;-1:-1:-1;;;40540:51:0;;-1:-1:-1;40533:58:0;;40244:801;-1:-1:-1;41029:4:0;40072:980;;;;;;:::o;46395:1002::-;46675:22;46725:1;46700:22;46717:4;46700:16;:22::i;:::-;:26;;;;:::i;:::-;46737:18;46758:26;;;:17;:26;;;;;;46675:51;;-1:-1:-1;46891:28:0;;;46887:328;;-1:-1:-1;;;;;46958:18:0;;46936:19;46958:18;;;:12;:18;;;;;;;;:34;;;;;;;;;47009:30;;;;;;:44;;;47126:30;;:17;:30;;;;;:43;;;46887:328;-1:-1:-1;47311:26:0;;;;:17;:26;;;;;;;;47304:33;;;-1:-1:-1;;;;;47355:18:0;;;;;:12;:18;;;;;:34;;;;;;;47348:41;46395:1002::o;47692:1079::-;47970:10;:17;47945:22;;47970:21;;47990:1;;47970:21;:::i;:::-;48002:18;48023:24;;;:15;:24;;;;;;48396:10;:26;;47945:46;;-1:-1:-1;48023:24:0;;47945:46;;48396:26;;;;;;:::i;:::-;;;;;;;;;48374:48;;48460:11;48435:10;48446;48435:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;48540:28;;;:15;:28;;;;;;;:41;;;48712:24;;;;;48705:31;48747:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;47763:1008;;;47692:1079;:::o;45182:221::-;45267:14;45284:20;45301:2;45284:16;:20::i;:::-;-1:-1:-1;;;;;45315:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;45360:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;45182:221:0:o;36635:321::-;36765:18;36771:2;36775:7;36765:5;:18::i;:::-;36816:54;36847:1;36851:2;36855:7;36864:5;36816:22;:54::i;:::-;36794:154;;;;-1:-1:-1;;;36794:154:0;;;;;;;:::i;37292:382::-;-1:-1:-1;;;;;37372:16:0;;37364:61;;;;-1:-1:-1;;;37364:61:0;;25629:2:1;37364:61:0;;;25611:21:1;;;25648:18;;;25641:30;25707:34;25687:18;;;25680:62;25759:18;;37364:61:0;25427:356:1;37364:61:0;37445:16;37453:7;37445;:16::i;:::-;37444:17;37436:58;;;;-1:-1:-1;;;37436:58:0;;25990:2:1;37436:58:0;;;25972:21:1;26029:2;26009:18;;;26002:30;26068;26048:18;;;26041:58;26116:18;;37436:58:0;25788:352:1;37436:58:0;37507:45;37536:1;37540:2;37544:7;37507:20;:45::i;:::-;-1:-1:-1;;;;;37565:13:0;;;;;;:9;:13;;;;;:18;;37582:1;;37565:13;:18;;37582:1;;37565:18;:::i;:::-;;;;-1:-1:-1;;37594:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;37594:21:0;-1:-1:-1;;;;;37594:21:0;;;;;;;;37633:33;;37594:16;;;37633:33;;37594:16;;37633:33;37292:382;;:::o;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;381:131::-;-1:-1:-1;;;;;;455:32:1;;445:43;;435:71;;502:1;499;492:12;517:245;575:6;628:2;616:9;607:7;603:23;599:32;596:52;;;644:1;641;634:12;596:52;683:9;670:23;702:30;726:5;702:30;:::i;959:118::-;1045:5;1038:13;1031:21;1024:5;1021:32;1011:60;;1067:1;1064;1057:12;1082:241;1138:6;1191:2;1179:9;1170:7;1166:23;1162:32;1159:52;;;1207:1;1204;1197:12;1159:52;1246:9;1233:23;1265:28;1287:5;1265:28;:::i;1328:250::-;1413:1;1423:113;1437:6;1434:1;1431:13;1423:113;;;1513:11;;;1507:18;1494:11;;;1487:39;1459:2;1452:10;1423:113;;;-1:-1:-1;;1570:1:1;1552:16;;1545:27;1328:250::o;1583:271::-;1625:3;1663:5;1657:12;1690:6;1685:3;1678:19;1706:76;1775:6;1768:4;1763:3;1759:14;1752:4;1745:5;1741:16;1706:76;:::i;:::-;1836:2;1815:15;-1:-1:-1;;1811:29:1;1802:39;;;;1843:4;1798:50;;1583:271;-1:-1:-1;;1583:271:1:o;1859:220::-;2008:2;1997:9;1990:21;1971:4;2028:45;2069:2;2058:9;2054:18;2046:6;2028:45;:::i;2084:203::-;-1:-1:-1;;;;;2248:32:1;;;;2230:51;;2218:2;2203:18;;2084:203::o;2292:131::-;-1:-1:-1;;;;;2367:31:1;;2357:42;;2347:70;;2413:1;2410;2403:12;2428:315;2496:6;2504;2557:2;2545:9;2536:7;2532:23;2528:32;2525:52;;;2573:1;2570;2563:12;2525:52;2612:9;2599:23;2631:31;2656:5;2631:31;:::i;:::-;2681:5;2733:2;2718:18;;;;2705:32;;-1:-1:-1;;;2428:315:1:o;2748:456::-;2825:6;2833;2841;2894:2;2882:9;2873:7;2869:23;2865:32;2862:52;;;2910:1;2907;2900:12;2862:52;2949:9;2936:23;2968:31;2993:5;2968:31;:::i;:::-;3018:5;-1:-1:-1;3075:2:1;3060:18;;3047:32;3088:33;3047:32;3088:33;:::i;:::-;2748:456;;3140:7;;-1:-1:-1;;;3194:2:1;3179:18;;;;3166:32;;2748:456::o;3209:127::-;3270:10;3265:3;3261:20;3258:1;3251:31;3301:4;3298:1;3291:15;3325:4;3322:1;3315:15;3341:632;3406:5;-1:-1:-1;;;;;3477:2:1;3469:6;3466:14;3463:40;;;3483:18;;:::i;:::-;3558:2;3552:9;3526:2;3612:15;;-1:-1:-1;;3608:24:1;;;3634:2;3604:33;3600:42;3588:55;;;3658:18;;;3678:22;;;3655:46;3652:72;;;3704:18;;:::i;:::-;3744:10;3740:2;3733:22;3773:6;3764:15;;3803:6;3795;3788:22;3843:3;3834:6;3829:3;3825:16;3822:25;3819:45;;;3860:1;3857;3850:12;3819:45;3910:6;3905:3;3898:4;3890:6;3886:17;3873:44;3965:1;3958:4;3949:6;3941;3937:19;3933:30;3926:41;;;;3341:632;;;;;:::o;3978:451::-;4047:6;4100:2;4088:9;4079:7;4075:23;4071:32;4068:52;;;4116:1;4113;4106:12;4068:52;4156:9;4143:23;-1:-1:-1;;;;;4181:6:1;4178:30;4175:50;;;4221:1;4218;4211:12;4175:50;4244:22;;4297:4;4289:13;;4285:27;-1:-1:-1;4275:55:1;;4326:1;4323;4316:12;4275:55;4349:74;4415:7;4410:2;4397:16;4392:2;4388;4384:11;4349:74;:::i;4434:247::-;4493:6;4546:2;4534:9;4525:7;4521:23;4517:32;4514:52;;;4562:1;4559;4552:12;4514:52;4601:9;4588:23;4620:31;4645:5;4620:31;:::i;4686:382::-;4751:6;4759;4812:2;4800:9;4791:7;4787:23;4783:32;4780:52;;;4828:1;4825;4818:12;4780:52;4867:9;4854:23;4886:31;4911:5;4886:31;:::i;:::-;4936:5;-1:-1:-1;4993:2:1;4978:18;;4965:32;5006:30;4965:32;5006:30;:::i;:::-;5055:7;5045:17;;;4686:382;;;;;:::o;5073:795::-;5168:6;5176;5184;5192;5245:3;5233:9;5224:7;5220:23;5216:33;5213:53;;;5262:1;5259;5252:12;5213:53;5301:9;5288:23;5320:31;5345:5;5320:31;:::i;:::-;5370:5;-1:-1:-1;5427:2:1;5412:18;;5399:32;5440:33;5399:32;5440:33;:::i;:::-;5492:7;-1:-1:-1;5546:2:1;5531:18;;5518:32;;-1:-1:-1;5601:2:1;5586:18;;5573:32;-1:-1:-1;;;;;5617:30:1;;5614:50;;;5660:1;5657;5650:12;5614:50;5683:22;;5736:4;5728:13;;5724:27;-1:-1:-1;5714:55:1;;5765:1;5762;5755:12;5714:55;5788:74;5854:7;5849:2;5836:16;5831:2;5827;5823:11;5788:74;:::i;:::-;5778:84;;;5073:795;;;;;;;:::o;5873:316::-;5950:6;5958;5966;6019:2;6007:9;5998:7;5994:23;5990:32;5987:52;;;6035:1;6032;6025:12;5987:52;-1:-1:-1;;6058:23:1;;;6128:2;6113:18;;6100:32;;-1:-1:-1;6179:2:1;6164:18;;;6151:32;;5873:316;-1:-1:-1;5873:316:1:o;6194:632::-;6365:2;6417:21;;;6487:13;;6390:18;;;6509:22;;;6336:4;;6365:2;6588:15;;;;6562:2;6547:18;;;6336:4;6631:169;6645:6;6642:1;6639:13;6631:169;;;6706:13;;6694:26;;6775:15;;;;6740:12;;;;6667:1;6660:9;6631:169;;;-1:-1:-1;6817:3:1;;6194:632;-1:-1:-1;;;;;;6194:632:1:o;6831:388::-;6899:6;6907;6960:2;6948:9;6939:7;6935:23;6931:32;6928:52;;;6976:1;6973;6966:12;6928:52;7015:9;7002:23;7034:31;7059:5;7034:31;:::i;:::-;7084:5;-1:-1:-1;7141:2:1;7126:18;;7113:32;7154:33;7113:32;7154:33;:::i;7682:356::-;7884:2;7866:21;;;7903:18;;;7896:30;7962:34;7957:2;7942:18;;7935:62;8029:2;8014:18;;7682:356::o;8043:380::-;8122:1;8118:12;;;;8165;;;8186:61;;8240:4;8232:6;8228:17;8218:27;;8186:61;8293:2;8285:6;8282:14;8262:18;8259:38;8256:161;;8339:10;8334:3;8330:20;8327:1;8320:31;8374:4;8371:1;8364:15;8402:4;8399:1;8392:15;8256:161;;8043:380;;;:::o;9668:413::-;9870:2;9852:21;;;9909:2;9889:18;;;9882:30;9948:34;9943:2;9928:18;;9921:62;-1:-1:-1;;;10014:2:1;9999:18;;9992:47;10071:3;10056:19;;9668:413::o;10853:127::-;10914:10;10909:3;10905:20;10902:1;10895:31;10945:4;10942:1;10935:15;10969:4;10966:1;10959:15;10985:135;11024:3;11045:17;;;11042:43;;11065:18;;:::i;:::-;-1:-1:-1;11112:1:1;11101:13;;10985:135::o;11748:127::-;11809:10;11804:3;11800:20;11797:1;11790:31;11840:4;11837:1;11830:15;11864:4;11861:1;11854:15;11880:184;11950:6;12003:2;11991:9;11982:7;11978:23;11974:32;11971:52;;;12019:1;12016;12009:12;11971:52;-1:-1:-1;12042:16:1;;11880:184;-1:-1:-1;11880:184:1:o;12069:251::-;12139:6;12192:2;12180:9;12171:7;12167:23;12163:32;12160:52;;;12208:1;12205;12198:12;12160:52;12240:9;12234:16;12259:31;12284:5;12259:31;:::i;12325:908::-;12559:4;12607:3;12596:9;12592:19;12638:6;12627:9;12620:25;12664:2;12702:3;12697:2;12686:9;12682:18;12675:31;12726:6;12761;12755:13;12792:6;12784;12777:22;12830:3;12819:9;12815:19;12808:26;;12869:2;12861:6;12857:15;12843:29;;12890:1;12900:195;12914:6;12911:1;12908:13;12900:195;;;12979:13;;-1:-1:-1;;;;;12975:39:1;12963:52;;13070:15;;;;13035:12;;;;13011:1;12929:9;12900:195;;;-1:-1:-1;;;;;;;13151:32:1;;;;13146:2;13131:18;;13124:60;-1:-1:-1;;;13215:2:1;13200:18;13193:34;13112:3;12325:908;-1:-1:-1;;12325:908:1:o;13517:245::-;13584:6;13637:2;13625:9;13616:7;13612:23;13608:32;13605:52;;;13653:1;13650;13643:12;13605:52;13685:9;13679:16;13704:28;13726:5;13704:28;:::i;13893:545::-;13995:2;13990:3;13987:11;13984:448;;;14031:1;14056:5;14052:2;14045:17;14101:4;14097:2;14087:19;14171:2;14159:10;14155:19;14152:1;14148:27;14142:4;14138:38;14207:4;14195:10;14192:20;14189:47;;;-1:-1:-1;14230:4:1;14189:47;14285:2;14280:3;14276:12;14273:1;14269:20;14263:4;14259:31;14249:41;;14340:82;14358:2;14351:5;14348:13;14340:82;;;14403:17;;;14384:1;14373:13;14340:82;;14614:1352;14740:3;14734:10;-1:-1:-1;;;;;14759:6:1;14756:30;14753:56;;;14789:18;;:::i;:::-;14818:97;14908:6;14868:38;14900:4;14894:11;14868:38;:::i;:::-;14862:4;14818:97;:::i;:::-;14970:4;;15034:2;15023:14;;15051:1;15046:663;;;;15753:1;15770:6;15767:89;;;-1:-1:-1;15822:19:1;;;15816:26;15767:89;-1:-1:-1;;14571:1:1;14567:11;;;14563:24;14559:29;14549:40;14595:1;14591:11;;;14546:57;15869:81;;15016:944;;15046:663;13840:1;13833:14;;;13877:4;13864:18;;-1:-1:-1;;15082:20:1;;;15200:236;15214:7;15211:1;15208:14;15200:236;;;15303:19;;;15297:26;15282:42;;15395:27;;;;15363:1;15351:14;;;;15230:19;;15200:236;;;15204:3;15464:6;15455:7;15452:19;15449:201;;;15525:19;;;15519:26;-1:-1:-1;;15608:1:1;15604:14;;;15620:3;15600:24;15596:37;15592:42;15577:58;15562:74;;15449:201;-1:-1:-1;;;;;15696:1:1;15680:14;;;15676:22;15663:36;;-1:-1:-1;14614:1352:1:o;17148:353::-;17350:2;17332:21;;;17389:2;17369:18;;;17362:30;17428:31;17423:2;17408:18;;17401:59;17492:2;17477:18;;17148:353::o;18202:168::-;18275:9;;;18306;;18323:15;;;18317:22;;18303:37;18293:71;;18344:18;;:::i;18721:127::-;18782:10;18777:3;18773:20;18770:1;18763:31;18813:4;18810:1;18803:15;18837:4;18834:1;18827:15;18853:120;18893:1;18919;18909:35;;18924:18;;:::i;:::-;-1:-1:-1;18958:9:1;;18853:120::o;20394:1256::-;20618:3;20656:6;20650:13;20682:4;20695:64;20752:6;20747:3;20742:2;20734:6;20730:15;20695:64;:::i;:::-;20822:13;;20781:16;;;;20844:68;20822:13;20781:16;20879:15;;;20844:68;:::i;:::-;21001:13;;20934:20;;;20974:1;;21039:36;21001:13;21039:36;:::i;:::-;21094:1;21111:18;;;21138:141;;;;21293:1;21288:337;;;;21104:521;;21138:141;-1:-1:-1;;21173:24:1;;21159:39;;21250:16;;21243:24;21229:39;;21218:51;;;-1:-1:-1;21138:141:1;;21288:337;21319:6;21316:1;21309:17;21367:2;21364:1;21354:16;21392:1;21406:169;21420:8;21417:1;21414:15;21406:169;;;21502:14;;21487:13;;;21480:37;21545:16;;;;21437:10;;21406:169;;;21410:3;;21606:8;21599:5;21595:20;21588:27;;21104:521;-1:-1:-1;21641:3:1;;20394:1256;-1:-1:-1;;;;;;;;;;20394:1256:1:o;22062:128::-;22129:9;;;22150:11;;;22147:37;;;22164:18;;:::i;23423:125::-;23488:9;;;23509:10;;;23506:36;;;23522:18;;:::i;23553:112::-;23585:1;23611;23601:35;;23616:18;;:::i;:::-;-1:-1:-1;23650:9:1;;23553:112::o;23670:136::-;23709:3;23737:5;23727:39;;23746:18;;:::i;:::-;-1:-1:-1;;;23782:18:1;;23670:136::o;23811:414::-;24013:2;23995:21;;;24052:2;24032:18;;;24025:30;24091:34;24086:2;24071:18;;24064:62;-1:-1:-1;;;24157:2:1;24142:18;;24135:48;24215:3;24200:19;;23811:414::o;24547:489::-;-1:-1:-1;;;;;24816:15:1;;;24798:34;;24868:15;;24863:2;24848:18;;24841:43;24915:2;24900:18;;24893:34;;;24963:3;24958:2;24943:18;;24936:31;;;24741:4;;24984:46;;25010:19;;25002:6;24984:46;:::i;:::-;24976:54;24547:489;-1:-1:-1;;;;;;24547:489:1:o;25041:249::-;25110:6;25163:2;25151:9;25142:7;25138:23;25134:32;25131:52;;;25179:1;25176;25169:12;25131:52;25211:9;25205:16;25230:30;25254:5;25230:30;:::i;25295:127::-;25356:10;25351:3;25347:20;25344:1;25337:31;25387:4;25384:1;25377:15;25411:4;25408:1;25401:15

Swarm Source

ipfs://fde52f6c3b0a6a791b88b0fdb2a3e69b85324bc4ee716be30b0c2f6be17edaf5

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services