Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/*
█▀█ ▄▀█ █▄█ █░█ █▀▀ █▀█ ▀█▀ █ █▀ █▀▀
█▀▀ █▀█ ░█░ ▀▄▀ ██▄ █▀▄ ░█░ █ ▄█ ██▄

▀█▀ █░█ █▀▀   █▀▀ █░█ ▀█▀ █░█ █▀█ █▀▀  
░█░ █▀█ ██▄   █▀░ █▄█ ░█░ █▄█ █▀▄ ██▄  

█▀█ █▀▀
█▄█ █▀░

▄▀█ █▀▄ █░█ █▀▀ █▀█ ▀█▀ █ █▀ █ █▄░█ █▀▀
█▀█ █▄▀ ▀▄▀ ██▄ █▀▄ ░█░ █ ▄█ █ █░▀█ █▄█

*Payvertise - Efficient, innovative revenue sharing in digital ads using blockchain.
*Owner cant mint, changetax, or blacklist
*Permanently fixed 1% Community tax
*Manual burning will be done by the team.

##OUR CHANNELS##
twitter: https://twitter.com/payvertise_
telegram chat: https://t.me/payvertisechat
telegram ann: https://t.me/payvertiseann
github: https://github.com/payvertise

##TOKENOMICS###
Total supply: 100,000,000 $PVT
Decimals: 18
Tax: 1%
*/

// SPDX-License-Identifier: MIT

import "./ERC20.sol";
import "./Ownable.sol";
import "./SafeERC20.sol";
import "./EnumerableSet.sol";

// File: PVT.sol
pragma solidity =0.8.19;

contract PAYVERTISE is ERC20, Ownable {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;

	event Trade(address pair, uint256 amount, uint side, uint256 circulatingSupply, uint timestamp);

    bool public feeEnabled = false;

    mapping(address => bool) public isFeeExempt;
    mapping(address => bool) public canAddLiquidityBeforeLaunch;

    uint256 private advertisingFee;
    uint256 private totalFee;
    uint256 public feeDenominator = 10000;

    uint256 public advertisingFeeBuy = 100;
    uint256 public totalFeeBuy = 100;

    uint256 public advertisingFeeSell = 100;
    uint256 public totalFeeSell = 100;
	
    uint256 public launchedAt;
    uint256 public launchedAtTimestamp;
	
    address public constant ZERO_ADDRESS = 0x0000000000000000000000000000000000000000;
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
	address public ADVERTISING_WALLET;

    EnumerableSet.AddressSet private _pairs;

    constructor() ERC20("PAYVERTISE", "PVT") {
        uint256 _totalSupply = 100_000_000 * 1e18;
        canAddLiquidityBeforeLaunch[_msgSender()] = true;
        isFeeExempt[msg.sender] = true;
        isFeeExempt[address(this)] = true;
        _mint(_msgSender(), _totalSupply);
    }



    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        return _pvtTransfer(_msgSender(), to, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(sender, spender, amount);
        return _pvtTransfer(sender, recipient, amount);
    }

    function _pvtTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        
        if (!canAddLiquidityBeforeLaunch[sender]) {
            require(launched(), "Project Not yet started");
        }

        bool shouldTakeAdvertisingFee = (!isFeeExempt[sender] && !isFeeExempt[recipient]) && launched() && feeEnabled;
        uint side = 0;
        address pair_ = recipient;
        // Set Fees
        if (isPair(sender)) {
            buyFees();
            side = 1;
            pair_ = sender;

		} else if (isPair(recipient)) {
            sellFees();
            side = 2;
        } else {
            shouldTakeAdvertisingFee = false; //dont take fee for wallet to wallet token transfers
        }

        uint256 amountReceived = shouldTakeAdvertisingFee ? takeAdvertisingFee(sender, amount) : amount;
        _transfer(sender, recipient, amountReceived);

        if (side > 0) {
            emit Trade(pair_, amount, side, getCirculatingSupply(), block.timestamp);
        }
        return true;
    }

    function launched() internal view returns (bool) {
        return launchedAt != 0;
    }

    function buyFees() internal {
        advertisingFee = advertisingFeeBuy;
        totalFee = totalFeeBuy;
    }

    function sellFees() internal {
        advertisingFee = advertisingFeeSell;
        totalFee = totalFeeSell;
    }

    function takeAdvertisingFee(address sender, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = (amount * totalFee) / feeDenominator;
        _transfer(sender, ADVERTISING_WALLET, feeAmount);
        return amount - feeAmount;
    }

    function getCirculatingSupply() public view returns (uint256) {
        return totalSupply() - balanceOf(BURN_ADDRESS) - balanceOf(ZERO_ADDRESS);
    }
	
	function getMinterLength() public view returns (uint256) {
        return _pairs.length();
    }

    function getPair(uint256 index) public view returns (address) {
        require(index <= _pairs.length() - 1, "index out of bounds");
        return _pairs.at(index);
    }
	
	function isPair(address account) public view returns (bool) {
        return _pairs.contains(account);
    }


    
	/*** ADMIN FUNCTIONS ***/
    function launch() public onlyOwner {
        require(launchedAt == 0, "Already launched");
        launchedAt = block.number;
        launchedAtTimestamp = block.timestamp;
    }

    function rescueToken(address tokenAddress) external onlyOwner {
	    //prevent dev from self-withdraw
		require(tokenAddress != address(this), "Owner Cant withdraw own tokens");
        IERC20(tokenAddress).safeTransfer(msg.sender,IERC20(tokenAddress).balanceOf(address(this)));
    }

    function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
        isFeeExempt[holder] = exempt;
    }    
	
	function setPresaleWallet(address holder, bool exempt) external onlyOwner {
        canAddLiquidityBeforeLaunch[holder] = exempt;
    }

    function setFeeSettings(bool _enabled) external onlyOwner {
        feeEnabled = _enabled;
    }
	
	function setAdvertisingWallet(address _advertisingwallet) external onlyOwner {
        ADVERTISING_WALLET = _advertisingwallet;
    }

    function addPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "pair is the zero address");
        return _pairs.add(pair);
    }

    function delPair(address pair) public onlyOwner returns (bool) {
        require(pair != address(0), "pair is the zero address");
        return _pairs.remove(pair);
    }
	
}

// File: Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

// File: EnumerableSet.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

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

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

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

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

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

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: ERC20.sol
// SPDX-License-Identifier: MIT

import "./Context.sol";
import "./IERC20.sol";
import "./IERC20Metadata.sol";


pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens 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 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: IERC20Metadata.sol
// SPDX-License-Identifier: MIT

import "./IERC20.sol";

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: IERC20Permit.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: Ownable.sol
// SPDX-License-Identifier: MIT

import "./Context.sol";

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// File: SafeERC20.sol
// SPDX-License-Identifier: MIT

import "./Address.sol";
import "./IERC20.sol";
import "./IERC20Permit.sol";

pragma solidity ^0.8.0;

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"side","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"circulatingSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Trade","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"ADVERTISING_WALLET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BURN_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ZERO_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"advertisingFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"advertisingFeeSell","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canAddLiquidityBeforeLaunch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"delPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCirculatingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinterLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isFeeExempt","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"launchedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchedAtTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_advertisingwallet","type":"address"}],"name":"setAdvertisingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setFeeSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setIsFeeExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"bool","name":"exempt","type":"bool"}],"name":"setPresaleWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeBuy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFeeSell","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":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526000600560146101000a81548160ff021916908315150217905550612710600a556064600b556064600c556064600d556064600e553480156200004657600080fd5b506040518060400160405280600a81526020017f50415956455254495345000000000000000000000000000000000000000000008152506040518060400160405280600381526020017f50565400000000000000000000000000000000000000000000000000000000008152508160039081620000c4919062000707565b508060049081620000d6919062000707565b505050620000f9620000ed6200024860201b60201c565b6200025060201b60201c565b60006a52b7d2dcc80cd2e400000090506001600760006200011f6200024860201b60201c565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055506001600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055506001600660003073ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff02191690831515021790555062000241620002346200024860201b60201c565b826200031660201b60201c565b5062000909565b600033905090565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160362000388576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016200037f906200084f565b60405180910390fd5b6200039c600083836200048360201b60201c565b8060026000828254620003b09190620008a0565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051620004639190620008ec565b60405180910390a36200047f600083836200048860201b60201c565b5050565b505050565b505050565b600081519050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600060028204905060018216806200050f57607f821691505b602082108103620005255762000524620004c7565b5b50919050565b60008190508160005260206000209050919050565b60006020601f8301049050919050565b600082821b905092915050565b6000600883026200058f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8262000550565b6200059b868362000550565b95508019841693508086168417925050509392505050565b6000819050919050565b6000819050919050565b6000620005e8620005e2620005dc84620005b3565b620005bd565b620005b3565b9050919050565b6000819050919050565b6200060483620005c7565b6200061c6200061382620005ef565b8484546200055d565b825550505050565b600090565b6200063362000624565b62000640818484620005f9565b505050565b5b8181101562000668576200065c60008262000629565b60018101905062000646565b5050565b601f821115620006b75762000681816200052b565b6200068c8462000540565b810160208510156200069c578190505b620006b4620006ab8562000540565b83018262000645565b50505b505050565b600082821c905092915050565b6000620006dc60001984600802620006bc565b1980831691505092915050565b6000620006f78383620006c9565b9150826002028217905092915050565b62000712826200048d565b67ffffffffffffffff8111156200072e576200072d62000498565b5b6200073a8254620004f6565b620007478282856200066c565b600060209050601f8311600181146200077f57600084156200076a578287015190505b620007768582620006e9565b865550620007e6565b601f1984166200078f866200052b565b60005b82811015620007b95784890151825560018201915060208501945060208101905062000792565b86831015620007d95784890151620007d5601f891682620006c9565b8355505b6001600288020188555050505b505050505050565b600082825260208201905092915050565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b600062000837601f83620007ee565b91506200084482620007ff565b602082019050919050565b600060208201905081810360008301526200086a8162000828565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000620008ad82620005b3565b9150620008ba83620005b3565b9250828201905080821115620008d557620008d462000871565b5b92915050565b620008e681620005b3565b82525050565b6000602082019050620009036000830184620008db565b92915050565b612f5c80620009196000396000f3fe608060405234801561001057600080fd5b506004361061023d5760003560e01c80638072250b1161013b578063bdf391cc116100b8578063dd62ed3e1161007c578063dd62ed3e146106d2578063e5e31b1314610702578063f2fde38b14610732578063fb5f27fb1461074e578063fccc28131461076c5761023d565b8063bdf391cc14610618578063bf56b37114610648578063c2b7bbb614610666578063c3f3105e14610696578063c6d2577d146106b45761023d565b8063a457c2d7116100ff578063a457c2d71461054e578063a5bc50851461057e578063a771ebc7146105ae578063a9059cbb146105cc578063b0a87269146105fc5761023d565b80638072250b146104a65780638da5cb5b146104d65780638f98756e146104f457806395d89b4114610512578063a304210c146105305761023d565b806339509351116101c9578063538ba4f91161018d578063538ba4f914610416578063658d4b7f1461043457806370a0823114610450578063715018a6146104805780637347fb311461048a5761023d565b806339509351146103605780633f4218e0146103905780634460d3cf146103c057806349a24f0d146103dc57806353148416146103f85761023d565b8063180b0d7e11610210578063180b0d7e146102b857806318160ddd146102d657806323b872dd146102f45780632b112e4914610324578063313ce567146103425761023d565b806301339c21146102425780630323aac71461024c57806306fdde031461026a578063095ea7b314610288575b600080fd5b61024a61078a565b005b6102546107e7565b6040516102619190611f96565b60405180910390f35b6102726107f8565b60405161027f9190612041565b60405180910390f35b6102a2600480360381019061029d91906120f2565b61088a565b6040516102af919061214d565b60405180910390f35b6102c06108ad565b6040516102cd9190611f96565b60405180910390f35b6102de6108b3565b6040516102eb9190611f96565b60405180910390f35b61030e60048036038101906103099190612168565b6108bd565b60405161031b919061214d565b60405180910390f35b61032c6108ea565b6040516103399190611f96565b60405180910390f35b61034a610922565b60405161035791906121d7565b60405180910390f35b61037a600480360381019061037591906120f2565b61092b565b604051610387919061214d565b60405180910390f35b6103aa60048036038101906103a591906121f2565b610962565b6040516103b7919061214d565b60405180910390f35b6103da60048036038101906103d591906121f2565b610982565b005b6103f660048036038101906103f1919061224b565b610a9f565b005b610400610ac4565b60405161040d9190611f96565b60405180910390f35b61041e610aca565b60405161042b9190612287565b60405180910390f35b61044e600480360381019061044991906122a2565b610acf565b005b61046a600480360381019061046591906121f2565b610b32565b6040516104779190611f96565b60405180910390f35b610488610b7a565b005b6104a4600480360381019061049f91906122a2565b610b8e565b005b6104c060048036038101906104bb91906121f2565b610bf1565b6040516104cd919061214d565b60405180910390f35b6104de610c11565b6040516104eb9190612287565b60405180910390f35b6104fc610c3b565b6040516105099190611f96565b60405180910390f35b61051a610c41565b6040516105279190612041565b60405180910390f35b610538610cd3565b6040516105459190611f96565b60405180910390f35b610568600480360381019061056391906120f2565b610cd9565b604051610575919061214d565b60405180910390f35b610598600480360381019061059391906121f2565b610d50565b6040516105a5919061214d565b60405180910390f35b6105b6610de4565b6040516105c3919061214d565b60405180910390f35b6105e660048036038101906105e191906120f2565b610df7565b6040516105f3919061214d565b60405180910390f35b610616600480360381019061061191906121f2565b610e13565b005b610632600480360381019061062d91906122e2565b610e5f565b60405161063f9190612287565b60405180910390f35b610650610ed4565b60405161065d9190611f96565b60405180910390f35b610680600480360381019061067b91906121f2565b610eda565b60405161068d919061214d565b60405180910390f35b61069e610f6e565b6040516106ab9190612287565b60405180910390f35b6106bc610f94565b6040516106c99190611f96565b60405180910390f35b6106ec60048036038101906106e7919061230f565b610f9a565b6040516106f99190611f96565b60405180910390f35b61071c600480360381019061071791906121f2565b611021565b604051610729919061214d565b60405180910390f35b61074c600480360381019061074791906121f2565b61103e565b005b6107566110c1565b6040516107639190611f96565b60405180910390f35b6107746110c7565b6040516107819190612287565b60405180910390f35b6107926110cd565b6000600f54146107d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107ce9061239b565b60405180910390fd5b43600f8190555042601081905550565b60006107f3601261114b565b905090565b606060038054610807906123ea565b80601f0160208091040260200160405190810160405280929190818152602001828054610833906123ea565b80156108805780601f1061085557610100808354040283529160200191610880565b820191906000526020600020905b81548152906001019060200180831161086357829003601f168201915b5050505050905090565b600080610895611160565b90506108a2818585611168565b600191505092915050565b600a5481565b6000600254905090565b6000806108c8611160565b90506108d5858285611331565b6108e08585856113bd565b9150509392505050565b60006108f66000610b32565b61090161dead610b32565b6109096108b3565b610913919061244a565b61091d919061244a565b905090565b60006012905090565b600080610936611160565b90506109578185856109488589610f9a565b610952919061247e565b611168565b600191505092915050565b60066020528060005260406000206000915054906101000a900460ff1681565b61098a6110cd565b3073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16036109f8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109ef906124fe565b60405180910390fd5b610a9c338273ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a359190612287565b602060405180830381865afa158015610a52573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a769190612533565b8373ffffffffffffffffffffffffffffffffffffffff166115f99092919063ffffffff16565b50565b610aa76110cd565b80600560146101000a81548160ff02191690831515021790555050565b600e5481565b600081565b610ad76110cd565b80600660008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055505050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b610b826110cd565b610b8c600061167f565b565b610b966110cd565b80600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055505050565b60076020528060005260406000206000915054906101000a900460ff1681565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600d5481565b606060048054610c50906123ea565b80601f0160208091040260200160405190810160405280929190818152602001828054610c7c906123ea565b8015610cc95780601f10610c9e57610100808354040283529160200191610cc9565b820191906000526020600020905b815481529060010190602001808311610cac57829003601f168201915b5050505050905090565b600b5481565b600080610ce4611160565b90506000610cf28286610f9a565b905083811015610d37576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d2e906125d2565b60405180910390fd5b610d448286868403611168565b60019250505092915050565b6000610d5a6110cd565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610dc9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dc09061263e565b60405180910390fd5b610ddd82601261174590919063ffffffff16565b9050919050565b600560149054906101000a900460ff1681565b6000610e0b610e04611160565b84846113bd565b905092915050565b610e1b6110cd565b80601160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60006001610e6d601261114b565b610e77919061244a565b821115610eb9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eb0906126aa565b60405180910390fd5b610ecd82601261177590919063ffffffff16565b9050919050565b600f5481565b6000610ee46110cd565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603610f53576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f4a9061263e565b60405180910390fd5b610f6782601261178f90919063ffffffff16565b9050919050565b601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60105481565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b60006110378260126117bf90919063ffffffff16565b9050919050565b6110466110cd565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16036110b5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110ac9061273c565b60405180910390fd5b6110be8161167f565b50565b600c5481565b61dead81565b6110d5611160565b73ffffffffffffffffffffffffffffffffffffffff166110f3610c11565b73ffffffffffffffffffffffffffffffffffffffff1614611149576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611140906127a8565b60405180910390fd5b565b6000611159826000016117ef565b9050919050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16036111d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111ce9061283a565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611246576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161123d906128cc565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040516113249190611f96565b60405180910390a3505050565b600061133d8484610f9a565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81146113b757818110156113a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113a090612938565b60405180910390fd5b6113b68484848403611168565b5b50505050565b6000600760008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff1661145857611418611800565b611457576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161144e906129a4565b60405180910390fd5b5b6000600660008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff161580156114fe5750600660008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16155b801561150e575061150d611800565b5b80156115265750600560149054906101000a900460ff165b905060008085905061153787611021565b156115505761154461180d565b60019150869050611575565b61155986611021565b1561156f57611566611821565b60029150611574565b600092505b5b600083611582578561158d565b61158c8887611835565b5b905061159a888883611897565b60008311156115ea577fe0b736dda314e2582531850d21df6cf2e51c84c4c27ffeca38bbb029332fba8c8287856115cf6108ea565b426040516115e19594939291906129c4565b60405180910390a15b60019450505050509392505050565b61167a8363a9059cbb60e01b8484604051602401611618929190612a17565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611b0d565b505050565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b600061176d836000018373ffffffffffffffffffffffffffffffffffffffff1660001b611bd4565b905092915050565b60006117848360000183611ce8565b60001c905092915050565b60006117b7836000018373ffffffffffffffffffffffffffffffffffffffff1660001b611d13565b905092915050565b60006117e7836000018373ffffffffffffffffffffffffffffffffffffffff1660001b611d83565b905092915050565b600081600001805490509050919050565b600080600f541415905090565b600b54600881905550600c54600981905550565b600d54600881905550600e54600981905550565b600080600a54600954846118499190612a40565b6118539190612ab1565b905061188284601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1683611897565b808361188e919061244a565b91505092915050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603611906576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118fd90612b54565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603611975576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161196c90612be6565b60405180910390fd5b611980838383611da6565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905081811015611a06576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119fd90612c78565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051611af49190611f96565b60405180910390a3611b07848484611dab565b50505050565b6000611b6f826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16611db09092919063ffffffff16565b9050600081511115611bcf5780806020019051810190611b8f9190612cad565b611bce576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611bc590612d4c565b60405180910390fd5b5b505050565b60008083600101600084815260200190815260200160002054905060008114611cdc576000600182611c06919061244a565b9050600060018660000180549050611c1e919061244a565b9050818114611c8d576000866000018281548110611c3f57611c3e612d6c565b5b9060005260206000200154905080876000018481548110611c6357611c62612d6c565b5b90600052602060002001819055508387600101600083815260200190815260200160002081905550505b85600001805480611ca157611ca0612d9b565b5b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050611ce2565b60009150505b92915050565b6000826000018281548110611d0057611cff612d6c565b5b9060005260206000200154905092915050565b6000611d1f8383611d83565b611d78578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050611d7d565b600090505b92915050565b600080836001016000848152602001908152602001600020541415905092915050565b505050565b505050565b6060611dbf8484600085611dc8565b90509392505050565b606082471015611e0d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e0490612e3c565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051611e369190612ea3565b60006040518083038185875af1925050503d8060008114611e73576040519150601f19603f3d011682016040523d82523d6000602084013e611e78565b606091505b5091509150611e8987838387611e95565b92505050949350505050565b60608315611ef7576000835103611eef57611eaf85611f0a565b611eee576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ee590612f06565b60405180910390fd5b5b829050611f02565b611f018383611f2d565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600082511115611f405781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f749190612041565b60405180910390fd5b6000819050919050565b611f9081611f7d565b82525050565b6000602082019050611fab6000830184611f87565b92915050565b600081519050919050565b600082825260208201905092915050565b60005b83811015611feb578082015181840152602081019050611fd0565b60008484015250505050565b6000601f19601f8301169050919050565b600061201382611fb1565b61201d8185611fbc565b935061202d818560208601611fcd565b61203681611ff7565b840191505092915050565b6000602082019050818103600083015261205b8184612008565b905092915050565b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600061209382612068565b9050919050565b6120a381612088565b81146120ae57600080fd5b50565b6000813590506120c08161209a565b92915050565b6120cf81611f7d565b81146120da57600080fd5b50565b6000813590506120ec816120c6565b92915050565b6000806040838503121561210957612108612063565b5b6000612117858286016120b1565b9250506020612128858286016120dd565b9150509250929050565b60008115159050919050565b61214781612132565b82525050565b6000602082019050612162600083018461213e565b92915050565b60008060006060848603121561218157612180612063565b5b600061218f868287016120b1565b93505060206121a0868287016120b1565b92505060406121b1868287016120dd565b9150509250925092565b600060ff82169050919050565b6121d1816121bb565b82525050565b60006020820190506121ec60008301846121c8565b92915050565b60006020828403121561220857612207612063565b5b6000612216848285016120b1565b91505092915050565b61222881612132565b811461223357600080fd5b50565b6000813590506122458161221f565b92915050565b60006020828403121561226157612260612063565b5b600061226f84828501612236565b91505092915050565b61228181612088565b82525050565b600060208201905061229c6000830184612278565b92915050565b600080604083850312156122b9576122b8612063565b5b60006122c7858286016120b1565b92505060206122d885828601612236565b9150509250929050565b6000602082840312156122f8576122f7612063565b5b6000612306848285016120dd565b91505092915050565b6000806040838503121561232657612325612063565b5b6000612334858286016120b1565b9250506020612345858286016120b1565b9150509250929050565b7f416c7265616479206c61756e6368656400000000000000000000000000000000600082015250565b6000612385601083611fbc565b91506123908261234f565b602082019050919050565b600060208201905081810360008301526123b481612378565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b6000600282049050600182168061240257607f821691505b602082108103612415576124146123bb565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061245582611f7d565b915061246083611f7d565b92508282039050818111156124785761247761241b565b5b92915050565b600061248982611f7d565b915061249483611f7d565b92508282019050808211156124ac576124ab61241b565b5b92915050565b7f4f776e65722043616e74207769746864726177206f776e20746f6b656e730000600082015250565b60006124e8601e83611fbc565b91506124f3826124b2565b602082019050919050565b60006020820190508181036000830152612517816124db565b9050919050565b60008151905061252d816120c6565b92915050565b60006020828403121561254957612548612063565b5b60006125578482850161251e565b91505092915050565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b60006125bc602583611fbc565b91506125c782612560565b604082019050919050565b600060208201905081810360008301526125eb816125af565b9050919050565b7f7061697220697320746865207a65726f20616464726573730000000000000000600082015250565b6000612628601883611fbc565b9150612633826125f2565b602082019050919050565b600060208201905081810360008301526126578161261b565b9050919050565b7f696e646578206f7574206f6620626f756e647300000000000000000000000000600082015250565b6000612694601383611fbc565b915061269f8261265e565b602082019050919050565b600060208201905081810360008301526126c381612687565b9050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b6000612726602683611fbc565b9150612731826126ca565b604082019050919050565b6000602082019050818103600083015261275581612719565b9050919050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b6000612792602083611fbc565b915061279d8261275c565b602082019050919050565b600060208201905081810360008301526127c181612785565b9050919050565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b6000612824602483611fbc565b915061282f826127c8565b604082019050919050565b6000602082019050818103600083015261285381612817565b9050919050565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b60006128b6602283611fbc565b91506128c18261285a565b604082019050919050565b600060208201905081810360008301526128e5816128a9565b9050919050565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b6000612922601d83611fbc565b915061292d826128ec565b602082019050919050565b6000602082019050818103600083015261295181612915565b9050919050565b7f50726f6a656374204e6f74207965742073746172746564000000000000000000600082015250565b600061298e601783611fbc565b915061299982612958565b602082019050919050565b600060208201905081810360008301526129bd81612981565b9050919050565b600060a0820190506129d96000830188612278565b6129e66020830187611f87565b6129f36040830186611f87565b612a006060830185611f87565b612a0d6080830184611f87565b9695505050505050565b6000604082019050612a2c6000830185612278565b612a396020830184611f87565b9392505050565b6000612a4b82611f7d565b9150612a5683611f7d565b9250828202612a6481611f7d565b91508282048414831517612a7b57612a7a61241b565b5b5092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b6000612abc82611f7d565b9150612ac783611f7d565b925082612ad757612ad6612a82565b5b828204905092915050565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b6000612b3e602583611fbc565b9150612b4982612ae2565b604082019050919050565b60006020820190508181036000830152612b6d81612b31565b9050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b6000612bd0602383611fbc565b9150612bdb82612b74565b604082019050919050565b60006020820190508181036000830152612bff81612bc3565b9050919050565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b6000612c62602683611fbc565b9150612c6d82612c06565b604082019050919050565b60006020820190508181036000830152612c9181612c55565b9050919050565b600081519050612ca78161221f565b92915050565b600060208284031215612cc357612cc2612063565b5b6000612cd184828501612c98565b91505092915050565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b6000612d36602a83611fbc565b9150612d4182612cda565b604082019050919050565b60006020820190508181036000830152612d6581612d29565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b6000612e26602683611fbc565b9150612e3182612dca565b604082019050919050565b60006020820190508181036000830152612e5581612e19565b9050919050565b600081519050919050565b600081905092915050565b6000612e7d82612e5c565b612e878185612e67565b9350612e97818560208601611fcd565b80840191505092915050565b6000612eaf8284612e72565b915081905092915050565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b6000612ef0601d83611fbc565b9150612efb82612eba565b602082019050919050565b60006020820190508181036000830152612f1f81612ee3565b905091905056fea2646970667358221220792b8d4c146eb331b907ce8f139d547eca2f64e1c3acd5217ace1d57cfb7798364736f6c63430008130033

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

1411:5515:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5560:182;;;:::i;:::-;;5119:98;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2143:100:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4494:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1872:37:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3263:108:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2991:269:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4960:153;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2733:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5979:238:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1686:43:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5750:288;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6320:98;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2050:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2169:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6046:119;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3434:127:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1836:103:7;;;:::i;:::-;;6175:137:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1736:59;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1188:87:7;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2004:39:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2362:104:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1918:38:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6720:436:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6746:174:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1647:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2834:149;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6424:135;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5225:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2093:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6567:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2342:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2125:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4023:151:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5406:110:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2094:201:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1963:32:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2257:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5560:182;1074:13:7;:11;:13::i;:::-;5628:1:8::1;5614:10;;:15;5606:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;5674:12;5661:10;:25;;;;5719:15;5697:19;:37;;;;5560:182::o:0;5119:98::-;5167:7;5194:15;:6;:13;:15::i;:::-;5187:22;;5119:98;:::o;2143:100:2:-;2197:13;2230:5;2223:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2143:100;:::o;4494:201::-;4577:4;4594:13;4610:12;:10;:12::i;:::-;4594:28;;4633:32;4642:5;4649:7;4658:6;4633:8;:32::i;:::-;4683:4;4676:11;;;4494:201;;;;:::o;1872:37:8:-;;;;:::o;3263:108:2:-;3324:7;3351:12;;3344:19;;3263:108;:::o;2991:269:8:-;3097:4;3114:15;3132:12;:10;:12::i;:::-;3114:30;;3155:40;3171:6;3179:7;3188:6;3155:15;:40::i;:::-;3213:39;3226:6;3234:9;3245:6;3213:12;:39::i;:::-;3206:46;;;2991:269;;;;;:::o;4960:153::-;5013:7;5082:23;2208:42;5082:9;:23::i;:::-;5056;2296:42;5056:9;:23::i;:::-;5040:13;:11;:13::i;:::-;:39;;;;:::i;:::-;:65;;;;:::i;:::-;5033:72;;4960:153;:::o;2733:93::-;2791:5;2816:2;2809:9;;2733:93;:::o;5979:238:2:-;6067:4;6084:13;6100:12;:10;:12::i;:::-;6084:28;;6123:64;6132:5;6139:7;6176:10;6148:25;6158:5;6165:7;6148:9;:25::i;:::-;:38;;;;:::i;:::-;6123:8;:64::i;:::-;6205:4;6198:11;;;5979:238;;;;:::o;1686:43:8:-;;;;;;;;;;;;;;;;;;;;;;:::o;5750:288::-;1074:13:7;:11;:13::i;:::-;5888:4:8::1;5864:29;;:12;:29;;::::0;5856:72:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;5939:91;5973:10;5991:12;5984:30;;;6023:4;5984:45;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5946:12;5939:33;;;;:91;;;;;:::i;:::-;5750:288:::0;:::o;6320:98::-;1074:13:7;:11;:13::i;:::-;6402:8:8::1;6389:10;;:21;;;;;;;;;;;;;;;;;;6320:98:::0;:::o;2050:33::-;;;;:::o;2169:81::-;2208:42;2169:81;:::o;6046:119::-;1074:13:7;:11;:13::i;:::-;6151:6:8::1;6129:11;:19;6141:6;6129:19;;;;;;;;;;;;;;;;:28;;;;;;;;;;;;;;;;;;6046:119:::0;;:::o;3434:127:2:-;3508:7;3535:9;:18;3545:7;3535:18;;;;;;;;;;;;;;;;3528:25;;3434:127;;;:::o;1836:103:7:-;1074:13;:11;:13::i;:::-;1901:30:::1;1928:1;1901:18;:30::i;:::-;1836:103::o:0;6175:137:8:-;1074:13:7;:11;:13::i;:::-;6298:6:8::1;6260:27;:35;6288:6;6260:35;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;6175:137:::0;;:::o;1736:59::-;;;;;;;;;;;;;;;;;;;;;;:::o;1188:87:7:-;1234:7;1261:6;;;;;;;;;;;1254:13;;1188:87;:::o;2004:39:8:-;;;;:::o;2362:104:2:-;2418:13;2451:7;2444:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2362:104;:::o;1918:38:8:-;;;;:::o;6720:436:2:-;6813:4;6830:13;6846:12;:10;:12::i;:::-;6830:28;;6869:24;6896:25;6906:5;6913:7;6896:9;:25::i;:::-;6869:52;;6960:15;6940:16;:35;;6932:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;7053:60;7062:5;7069:7;7097:15;7078:16;:34;7053:8;:60::i;:::-;7144:4;7137:11;;;;6720:436;;;;:::o;6746:174:8:-;6803:4;1074:13:7;:11;:13::i;:::-;6844:1:8::1;6828:18;;:4;:18;;::::0;6820:55:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;6893:19;6907:4;6893:6;:13;;:19;;;;:::i;:::-;6886:26;;6746:174:::0;;;:::o;1647:30::-;;;;;;;;;;;;;:::o;2834:149::-;2913:4;2937:38;2950:12;:10;:12::i;:::-;2964:2;2968:6;2937:12;:38::i;:::-;2930:45;;2834:149;;;;:::o;6424:135::-;1074:13:7;:11;:13::i;:::-;6533:18:8::1;6512;;:39;;;;;;;;;;;;;;;;;;6424:135:::0;:::o;5225:175::-;5278:7;5333:1;5315:15;:6;:13;:15::i;:::-;:19;;;;:::i;:::-;5306:5;:28;;5298:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;5376:16;5386:5;5376:6;:9;;:16;;;;:::i;:::-;5369:23;;5225:175;;;:::o;2093:25::-;;;;:::o;6567:171::-;6624:4;1074:13:7;:11;:13::i;:::-;6665:1:8::1;6649:18;;:4;:18;;::::0;6641:55:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;6714:16;6725:4;6714:6;:10;;:16;;;;:::i;:::-;6707:23;;6567:171:::0;;;:::o;2342:33::-;;;;;;;;;;;;;:::o;2125:34::-;;;;:::o;4023:151:2:-;4112:7;4139:11;:18;4151:5;4139:18;;;;;;;;;;;;;;;:27;4158:7;4139:27;;;;;;;;;;;;;;;;4132:34;;4023:151;;;;:::o;5406:110:8:-;5460:4;5484:24;5500:7;5484:6;:15;;:24;;;;:::i;:::-;5477:31;;5406:110;;;:::o;2094:201:7:-;1074:13;:11;:13::i;:::-;2203:1:::1;2183:22;;:8;:22;;::::0;2175:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;2259:28;2278:8;2259:18;:28::i;:::-;2094:201:::0;:::o;1963:32:8:-;;;;:::o;2257:81::-;2296:42;2257:81;:::o;1353:132:7:-;1428:12;:10;:12::i;:::-;1417:23;;:7;:5;:7::i;:::-;:23;;;1409:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1353:132::o;9218:117:3:-;9281:7;9308:19;9316:3;:10;;9308:7;:19::i;:::-;9301:26;;9218:117;;;:::o;624:98:1:-;677:7;704:10;697:17;;624:98;:::o;10747:380:2:-;10900:1;10883:19;;:5;:19;;;10875:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10981:1;10962:21;;:7;:21;;;10954:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;11065:6;11035:11;:18;11047:5;11035:18;;;;;;;;;;;;;;;:27;11054:7;11035:27;;;;;;;;;;;;;;;:36;;;;11103:7;11087:32;;11096:5;11087:32;;;11112:6;11087:32;;;;;;:::i;:::-;;;;;;;;10747:380;;;:::o;11418:453::-;11553:24;11580:25;11590:5;11597:7;11580:9;:25::i;:::-;11553:52;;11640:17;11620:16;:37;11616:248;;11702:6;11682:16;:26;;11674:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;11786:51;11795:5;11802:7;11830:6;11811:16;:25;11786:8;:51::i;:::-;11616:248;11542:329;11418:453;;;:::o;3268:1074:8:-;3359:4;3391:27;:35;3419:6;3391:35;;;;;;;;;;;;;;;;;;;;;;;;;3386:115;;3451:10;:8;:10::i;:::-;3443:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;3386:115;3513:29;3547:11;:19;3559:6;3547:19;;;;;;;;;;;;;;;;;;;;;;;;;3546:20;:47;;;;;3571:11;:22;3583:9;3571:22;;;;;;;;;;;;;;;;;;;;;;;;;3570:23;3546:47;3545:63;;;;;3598:10;:8;:10::i;:::-;3545:63;:77;;;;;3612:10;;;;;;;;;;;3545:77;3513:109;;3633:9;3657:13;3673:9;3657:25;;3718:14;3725:6;3718;:14::i;:::-;3714:311;;;3749:9;:7;:9::i;:::-;3780:1;3773:8;;3804:6;3796:14;;3714:311;;;3828:17;3835:9;3828:6;:17::i;:::-;3824:201;;;3862:10;:8;:10::i;:::-;3894:1;3887:8;;3824:201;;;3955:5;3928:32;;3824:201;3714:311;4037:22;4062:24;:70;;4126:6;4062:70;;;4089:34;4108:6;4116;4089:18;:34::i;:::-;4062:70;4037:95;;4143:44;4153:6;4161:9;4172:14;4143:9;:44::i;:::-;4211:1;4204:4;:8;4200:113;;;4234:67;4240:5;4247:6;4255:4;4261:22;:20;:22::i;:::-;4285:15;4234:67;;;;;;;;;;:::i;:::-;;;;;;;;4200:113;4330:4;4323:11;;;;;;3268:1074;;;;;:::o;693:211:9:-;810:86;830:5;860:23;;;885:2;889:5;837:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;810:19;:86::i;:::-;693:211;;;:::o;2455:191:7:-;2529:16;2548:6;;;;;;;;;;;2529:25;;2574:8;2565:6;;:17;;;;;;;;;;;;;;;;;;2629:8;2598:40;;2619:8;2598:40;;;;;;;;;;;;2518:128;2455:191;:::o;8721:158:3:-;8794:4;8818:53;8826:3;:10;;8862:5;8846:23;;8838:32;;8818:7;:53::i;:::-;8811:60;;8721:158;;;;:::o;9689:::-;9763:7;9814:22;9818:3;:10;;9830:5;9814:3;:22::i;:::-;9806:31;;9783:56;;9689:158;;;;:::o;8393:152::-;8463:4;8487:50;8492:3;:10;;8528:5;8512:23;;8504:32;;8487:4;:50::i;:::-;8480:57;;8393:152;;;;:::o;8965:167::-;9045:4;9069:55;9079:3;:10;;9115:5;9099:23;;9091:32;;9069:9;:55::i;:::-;9062:62;;8965:167;;;;:::o;4435:109::-;4491:7;4518:3;:11;;:18;;;;4511:25;;4435:109;;;:::o;4350:90:8:-;4393:4;4431:1;4417:10;;:15;;4410:22;;4350:90;:::o;4448:114::-;4504:17;;4487:14;:34;;;;4543:11;;4532:8;:22;;;;4448:114::o;4570:117::-;4627:18;;4610:14;:35;;;;4667:12;;4656:8;:23;;;;4570:117::o;4695:257::-;4773:7;4793:17;4835:14;;4823:8;;4814:6;:17;;;;:::i;:::-;4813:36;;;;:::i;:::-;4793:56;;4860:48;4870:6;4878:18;;;;;;;;;;;4898:9;4860;:48::i;:::-;4935:9;4926:6;:18;;;;:::i;:::-;4919:25;;;4695:257;;;;:::o;7626:840:2:-;7773:1;7757:18;;:4;:18;;;7749:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;7850:1;7836:16;;:2;:16;;;7828:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;7905:38;7926:4;7932:2;7936:6;7905:20;:38::i;:::-;7956:19;7978:9;:15;7988:4;7978:15;;;;;;;;;;;;;;;;7956:37;;8027:6;8012:11;:21;;8004:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;8144:6;8130:11;:20;8112:9;:15;8122:4;8112:15;;;;;;;;;;;;;;;:38;;;;8347:6;8330:9;:13;8340:2;8330:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;8397:2;8382:26;;8391:4;8382:26;;;8401:6;8382:26;;;;;;:::i;:::-;;;;;;;;8421:37;8441:4;8447:2;8451:6;8421:19;:37::i;:::-;7738:728;7626:840;;;:::o;3760:716:9:-;4184:23;4210:69;4238:4;4210:69;;;;;;;;;;;;;;;;;4218:5;4210:27;;;;:69;;;;;:::i;:::-;4184:95;;4314:1;4294:10;:17;:21;4290:179;;;4391:10;4380:30;;;;;;;;;;;;:::i;:::-;4372:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;4290:179;3830:646;3760:716;;:::o;2714:1420:3:-;2780:4;2898:18;2919:3;:12;;:19;2932:5;2919:19;;;;;;;;;;;;2898:40;;2969:1;2955:10;:15;2951:1176;;3330:21;3367:1;3354:10;:14;;;;:::i;:::-;3330:38;;3383:17;3424:1;3403:3;:11;;:18;;;;:22;;;;:::i;:::-;3383:42;;3459:13;3446:9;:26;3442:405;;3493:17;3513:3;:11;;3525:9;3513:22;;;;;;;;:::i;:::-;;;;;;;;;;3493:42;;3667:9;3638:3;:11;;3650:13;3638:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;3778:10;3752:3;:12;;:23;3765:9;3752:23;;;;;;;;;;;:36;;;;3474:373;3442:405;3928:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;4023:3;:12;;:19;4036:5;4023:19;;;;;;;;;;;4016:26;;;4066:4;4059:11;;;;;;;2951:1176;4110:5;4103:12;;;2714:1420;;;;;:::o;4898:120::-;4965:7;4992:3;:11;;5004:5;4992:18;;;;;;;;:::i;:::-;;;;;;;;;;4985:25;;4898:120;;;;:::o;2124:414::-;2187:4;2209:21;2219:3;2224:5;2209:9;:21::i;:::-;2204:327;;2247:3;:11;;2264:5;2247:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2430:3;:11;;:18;;;;2408:3;:12;;:19;2421:5;2408:19;;;;;;;;;;;:40;;;;2470:4;2463:11;;;;2204:327;2514:5;2507:12;;2124:414;;;;;:::o;4220:129::-;4293:4;4340:1;4317:3;:12;;:19;4330:5;4317:19;;;;;;;;;;;;:24;;4310:31;;4220:129;;;;:::o;12471:125:2:-;;;;:::o;13200:124::-;;;;:::o;3920:229:0:-;4057:12;4089:52;4111:6;4119:4;4125:1;4128:12;4089:21;:52::i;:::-;4082:59;;3920:229;;;;;:::o;5040:455::-;5210:12;5268:5;5243:21;:30;;5235:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;5328:12;5342:23;5369:6;:11;;5388:5;5395:4;5369:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5327:73;;;;5418:69;5445:6;5453:7;5462:10;5474:12;5418:26;:69::i;:::-;5411:76;;;;5040:455;;;;;;:::o;7613:644::-;7798:12;7827:7;7823:427;;;7876:1;7855:10;:17;:22;7851:290;;8073:18;8084:6;8073:10;:18::i;:::-;8065:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;7851:290;8162:10;8155:17;;;;7823:427;8205:33;8213:10;8225:12;8205:7;:33::i;:::-;7613:644;;;;;;;:::o;1163:326::-;1223:4;1480:1;1458:7;:19;;;:23;1451:30;;1163:326;;;:::o;8799:552::-;8980:1;8960:10;:17;:21;8956:388;;;9192:10;9186:17;9249:15;9236:10;9232:2;9228:19;9221:44;8956:388;9319:12;9312:20;;;;;;;;;;;:::i;:::-;;;;;;;;7:77:10;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:99::-;494:6;528:5;522:12;512:22;;442:99;;;:::o;547:169::-;631:11;665:6;660:3;653:19;705:4;700:3;696:14;681:29;;547:169;;;;:::o;722:246::-;803:1;813:113;827:6;824:1;821:13;813:113;;;912:1;907:3;903:11;897:18;893:1;888:3;884:11;877:39;849:2;846:1;842:10;837:15;;813:113;;;960:1;951:6;946:3;942:16;935:27;784:184;722:246;;;:::o;974:102::-;1015:6;1066:2;1062:7;1057:2;1050:5;1046:14;1042:28;1032:38;;974:102;;;:::o;1082:377::-;1170:3;1198:39;1231:5;1198:39;:::i;:::-;1253:71;1317:6;1312:3;1253:71;:::i;:::-;1246:78;;1333:65;1391:6;1386:3;1379:4;1372:5;1368:16;1333:65;:::i;:::-;1423:29;1445:6;1423:29;:::i;:::-;1418:3;1414:39;1407:46;;1174:285;1082:377;;;;:::o;1465:313::-;1578:4;1616:2;1605:9;1601:18;1593:26;;1665:9;1659:4;1655:20;1651:1;1640:9;1636:17;1629:47;1693:78;1766:4;1757:6;1693:78;:::i;:::-;1685:86;;1465:313;;;;:::o;1865:117::-;1974:1;1971;1964:12;2111:126;2148:7;2188:42;2181:5;2177:54;2166:65;;2111:126;;;:::o;2243:96::-;2280:7;2309:24;2327:5;2309:24;:::i;:::-;2298:35;;2243:96;;;:::o;2345:122::-;2418:24;2436:5;2418:24;:::i;:::-;2411:5;2408:35;2398:63;;2457:1;2454;2447:12;2398:63;2345:122;:::o;2473:139::-;2519:5;2557:6;2544:20;2535:29;;2573:33;2600:5;2573:33;:::i;:::-;2473:139;;;;:::o;2618:122::-;2691:24;2709:5;2691:24;:::i;:::-;2684:5;2681:35;2671:63;;2730:1;2727;2720:12;2671:63;2618:122;:::o;2746:139::-;2792:5;2830:6;2817:20;2808:29;;2846:33;2873:5;2846:33;:::i;:::-;2746:139;;;;:::o;2891:474::-;2959:6;2967;3016:2;3004:9;2995:7;2991:23;2987:32;2984:119;;;3022:79;;:::i;:::-;2984:119;3142:1;3167:53;3212:7;3203:6;3192:9;3188:22;3167:53;:::i;:::-;3157:63;;3113:117;3269:2;3295:53;3340:7;3331:6;3320:9;3316:22;3295:53;:::i;:::-;3285:63;;3240:118;2891:474;;;;;:::o;3371:90::-;3405:7;3448:5;3441:13;3434:21;3423:32;;3371:90;;;:::o;3467:109::-;3548:21;3563:5;3548:21;:::i;:::-;3543:3;3536:34;3467:109;;:::o;3582:210::-;3669:4;3707:2;3696:9;3692:18;3684:26;;3720:65;3782:1;3771:9;3767:17;3758:6;3720:65;:::i;:::-;3582:210;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:86::-;4458:7;4498:4;4491:5;4487:16;4476:27;;4423:86;;;:::o;4515:112::-;4598:22;4614:5;4598:22;:::i;:::-;4593:3;4586:35;4515:112;;:::o;4633:214::-;4722:4;4760:2;4749:9;4745:18;4737:26;;4773:67;4837:1;4826:9;4822:17;4813:6;4773:67;:::i;:::-;4633:214;;;;:::o;4853:329::-;4912:6;4961:2;4949:9;4940:7;4936:23;4932:32;4929:119;;;4967:79;;:::i;:::-;4929:119;5087:1;5112:53;5157:7;5148:6;5137:9;5133:22;5112:53;:::i;:::-;5102:63;;5058:117;4853:329;;;;:::o;5188:116::-;5258:21;5273:5;5258:21;:::i;:::-;5251:5;5248:32;5238:60;;5294:1;5291;5284:12;5238:60;5188:116;:::o;5310:133::-;5353:5;5391:6;5378:20;5369:29;;5407:30;5431:5;5407:30;:::i;:::-;5310:133;;;;:::o;5449:323::-;5505:6;5554:2;5542:9;5533:7;5529:23;5525:32;5522:119;;;5560:79;;:::i;:::-;5522:119;5680:1;5705:50;5747:7;5738:6;5727:9;5723:22;5705:50;:::i;:::-;5695:60;;5651:114;5449:323;;;;:::o;5778:118::-;5865:24;5883:5;5865:24;:::i;:::-;5860:3;5853:37;5778:118;;:::o;5902:222::-;5995:4;6033:2;6022:9;6018:18;6010:26;;6046:71;6114:1;6103:9;6099:17;6090:6;6046:71;:::i;:::-;5902:222;;;;:::o;6130:468::-;6195:6;6203;6252:2;6240:9;6231:7;6227:23;6223:32;6220:119;;;6258:79;;:::i;:::-;6220:119;6378:1;6403:53;6448:7;6439:6;6428:9;6424:22;6403:53;:::i;:::-;6393:63;;6349:117;6505:2;6531:50;6573:7;6564:6;6553:9;6549:22;6531:50;:::i;:::-;6521:60;;6476:115;6130:468;;;;;:::o;6604:329::-;6663:6;6712:2;6700:9;6691:7;6687:23;6683:32;6680:119;;;6718:79;;:::i;:::-;6680:119;6838:1;6863:53;6908:7;6899:6;6888:9;6884:22;6863:53;:::i;:::-;6853:63;;6809:117;6604:329;;;;:::o;6939:474::-;7007:6;7015;7064:2;7052:9;7043:7;7039:23;7035:32;7032:119;;;7070:79;;:::i;:::-;7032:119;7190:1;7215:53;7260:7;7251:6;7240:9;7236:22;7215:53;:::i;:::-;7205:63;;7161:117;7317:2;7343:53;7388:7;7379:6;7368:9;7364:22;7343:53;:::i;:::-;7333:63;;7288:118;6939:474;;;;;:::o;7419:166::-;7559:18;7555:1;7547:6;7543:14;7536:42;7419:166;:::o;7591:366::-;7733:3;7754:67;7818:2;7813:3;7754:67;:::i;:::-;7747:74;;7830:93;7919:3;7830:93;:::i;:::-;7948:2;7943:3;7939:12;7932:19;;7591:366;;;:::o;7963:419::-;8129:4;8167:2;8156:9;8152:18;8144:26;;8216:9;8210:4;8206:20;8202:1;8191:9;8187:17;8180:47;8244:131;8370:4;8244:131;:::i;:::-;8236:139;;7963:419;;;:::o;8388:180::-;8436:77;8433:1;8426:88;8533:4;8530:1;8523:15;8557:4;8554:1;8547:15;8574:320;8618:6;8655:1;8649:4;8645:12;8635:22;;8702:1;8696:4;8692:12;8723:18;8713:81;;8779:4;8771:6;8767:17;8757:27;;8713:81;8841:2;8833:6;8830:14;8810:18;8807:38;8804:84;;8860:18;;:::i;:::-;8804:84;8625:269;8574:320;;;:::o;8900:180::-;8948:77;8945:1;8938:88;9045:4;9042:1;9035:15;9069:4;9066:1;9059:15;9086:194;9126:4;9146:20;9164:1;9146:20;:::i;:::-;9141:25;;9180:20;9198:1;9180:20;:::i;:::-;9175:25;;9224:1;9221;9217:9;9209:17;;9248:1;9242:4;9239:11;9236:37;;;9253:18;;:::i;:::-;9236:37;9086:194;;;;:::o;9286:191::-;9326:3;9345:20;9363:1;9345:20;:::i;:::-;9340:25;;9379:20;9397:1;9379:20;:::i;:::-;9374:25;;9422:1;9419;9415:9;9408:16;;9443:3;9440:1;9437:10;9434:36;;;9450:18;;:::i;:::-;9434:36;9286:191;;;;:::o;9483:180::-;9623:32;9619:1;9611:6;9607:14;9600:56;9483:180;:::o;9669:366::-;9811:3;9832:67;9896:2;9891:3;9832:67;:::i;:::-;9825:74;;9908:93;9997:3;9908:93;:::i;:::-;10026:2;10021:3;10017:12;10010:19;;9669:366;;;:::o;10041:419::-;10207:4;10245:2;10234:9;10230:18;10222:26;;10294:9;10288:4;10284:20;10280:1;10269:9;10265:17;10258:47;10322:131;10448:4;10322:131;:::i;:::-;10314:139;;10041:419;;;:::o;10466:143::-;10523:5;10554:6;10548:13;10539:22;;10570:33;10597:5;10570:33;:::i;:::-;10466:143;;;;:::o;10615:351::-;10685:6;10734:2;10722:9;10713:7;10709:23;10705:32;10702:119;;;10740:79;;:::i;:::-;10702:119;10860:1;10885:64;10941:7;10932:6;10921:9;10917:22;10885:64;:::i;:::-;10875:74;;10831:128;10615:351;;;;:::o;10972:224::-;11112:34;11108:1;11100:6;11096:14;11089:58;11181:7;11176:2;11168:6;11164:15;11157:32;10972:224;:::o;11202:366::-;11344:3;11365:67;11429:2;11424:3;11365:67;:::i;:::-;11358:74;;11441:93;11530:3;11441:93;:::i;:::-;11559:2;11554:3;11550:12;11543:19;;11202:366;;;:::o;11574:419::-;11740:4;11778:2;11767:9;11763:18;11755:26;;11827:9;11821:4;11817:20;11813:1;11802:9;11798:17;11791:47;11855:131;11981:4;11855:131;:::i;:::-;11847:139;;11574:419;;;:::o;11999:174::-;12139:26;12135:1;12127:6;12123:14;12116:50;11999:174;:::o;12179:366::-;12321:3;12342:67;12406:2;12401:3;12342:67;:::i;:::-;12335:74;;12418:93;12507:3;12418:93;:::i;:::-;12536:2;12531:3;12527:12;12520:19;;12179:366;;;:::o;12551:419::-;12717:4;12755:2;12744:9;12740:18;12732:26;;12804:9;12798:4;12794:20;12790:1;12779:9;12775:17;12768:47;12832:131;12958:4;12832:131;:::i;:::-;12824:139;;12551:419;;;:::o;12976:169::-;13116:21;13112:1;13104:6;13100:14;13093:45;12976:169;:::o;13151:366::-;13293:3;13314:67;13378:2;13373:3;13314:67;:::i;:::-;13307:74;;13390:93;13479:3;13390:93;:::i;:::-;13508:2;13503:3;13499:12;13492:19;;13151:366;;;:::o;13523:419::-;13689:4;13727:2;13716:9;13712:18;13704:26;;13776:9;13770:4;13766:20;13762:1;13751:9;13747:17;13740:47;13804:131;13930:4;13804:131;:::i;:::-;13796:139;;13523:419;;;:::o;13948:225::-;14088:34;14084:1;14076:6;14072:14;14065:58;14157:8;14152:2;14144:6;14140:15;14133:33;13948:225;:::o;14179:366::-;14321:3;14342:67;14406:2;14401:3;14342:67;:::i;:::-;14335:74;;14418:93;14507:3;14418:93;:::i;:::-;14536:2;14531:3;14527:12;14520:19;;14179:366;;;:::o;14551:419::-;14717:4;14755:2;14744:9;14740:18;14732:26;;14804:9;14798:4;14794:20;14790:1;14779:9;14775:17;14768:47;14832:131;14958:4;14832:131;:::i;:::-;14824:139;;14551:419;;;:::o;14976:182::-;15116:34;15112:1;15104:6;15100:14;15093:58;14976:182;:::o;15164:366::-;15306:3;15327:67;15391:2;15386:3;15327:67;:::i;:::-;15320:74;;15403:93;15492:3;15403:93;:::i;:::-;15521:2;15516:3;15512:12;15505:19;;15164:366;;;:::o;15536:419::-;15702:4;15740:2;15729:9;15725:18;15717:26;;15789:9;15783:4;15779:20;15775:1;15764:9;15760:17;15753:47;15817:131;15943:4;15817:131;:::i;:::-;15809:139;;15536:419;;;:::o;15961:223::-;16101:34;16097:1;16089:6;16085:14;16078:58;16170:6;16165:2;16157:6;16153:15;16146:31;15961:223;:::o;16190:366::-;16332:3;16353:67;16417:2;16412:3;16353:67;:::i;:::-;16346:74;;16429:93;16518:3;16429:93;:::i;:::-;16547:2;16542:3;16538:12;16531:19;;16190:366;;;:::o;16562:419::-;16728:4;16766:2;16755:9;16751:18;16743:26;;16815:9;16809:4;16805:20;16801:1;16790:9;16786:17;16779:47;16843:131;16969:4;16843:131;:::i;:::-;16835:139;;16562:419;;;:::o;16987:221::-;17127:34;17123:1;17115:6;17111:14;17104:58;17196:4;17191:2;17183:6;17179:15;17172:29;16987:221;:::o;17214:366::-;17356:3;17377:67;17441:2;17436:3;17377:67;:::i;:::-;17370:74;;17453:93;17542:3;17453:93;:::i;:::-;17571:2;17566:3;17562:12;17555:19;;17214:366;;;:::o;17586:419::-;17752:4;17790:2;17779:9;17775:18;17767:26;;17839:9;17833:4;17829:20;17825:1;17814:9;17810:17;17803:47;17867:131;17993:4;17867:131;:::i;:::-;17859:139;;17586:419;;;:::o;18011:179::-;18151:31;18147:1;18139:6;18135:14;18128:55;18011:179;:::o;18196:366::-;18338:3;18359:67;18423:2;18418:3;18359:67;:::i;:::-;18352:74;;18435:93;18524:3;18435:93;:::i;:::-;18553:2;18548:3;18544:12;18537:19;;18196:366;;;:::o;18568:419::-;18734:4;18772:2;18761:9;18757:18;18749:26;;18821:9;18815:4;18811:20;18807:1;18796:9;18792:17;18785:47;18849:131;18975:4;18849:131;:::i;:::-;18841:139;;18568:419;;;:::o;18993:173::-;19133:25;19129:1;19121:6;19117:14;19110:49;18993:173;:::o;19172:366::-;19314:3;19335:67;19399:2;19394:3;19335:67;:::i;:::-;19328:74;;19411:93;19500:3;19411:93;:::i;:::-;19529:2;19524:3;19520:12;19513:19;;19172:366;;;:::o;19544:419::-;19710:4;19748:2;19737:9;19733:18;19725:26;;19797:9;19791:4;19787:20;19783:1;19772:9;19768:17;19761:47;19825:131;19951:4;19825:131;:::i;:::-;19817:139;;19544:419;;;:::o;19969:664::-;20174:4;20212:3;20201:9;20197:19;20189:27;;20226:71;20294:1;20283:9;20279:17;20270:6;20226:71;:::i;:::-;20307:72;20375:2;20364:9;20360:18;20351:6;20307:72;:::i;:::-;20389;20457:2;20446:9;20442:18;20433:6;20389:72;:::i;:::-;20471;20539:2;20528:9;20524:18;20515:6;20471:72;:::i;:::-;20553:73;20621:3;20610:9;20606:19;20597:6;20553:73;:::i;:::-;19969:664;;;;;;;;:::o;20639:332::-;20760:4;20798:2;20787:9;20783:18;20775:26;;20811:71;20879:1;20868:9;20864:17;20855:6;20811:71;:::i;:::-;20892:72;20960:2;20949:9;20945:18;20936:6;20892:72;:::i;:::-;20639:332;;;;;:::o;20977:410::-;21017:7;21040:20;21058:1;21040:20;:::i;:::-;21035:25;;21074:20;21092:1;21074:20;:::i;:::-;21069:25;;21129:1;21126;21122:9;21151:30;21169:11;21151:30;:::i;:::-;21140:41;;21330:1;21321:7;21317:15;21314:1;21311:22;21291:1;21284:9;21264:83;21241:139;;21360:18;;:::i;:::-;21241:139;21025:362;20977:410;;;;:::o;21393:180::-;21441:77;21438:1;21431:88;21538:4;21535:1;21528:15;21562:4;21559:1;21552:15;21579:185;21619:1;21636:20;21654:1;21636:20;:::i;:::-;21631:25;;21670:20;21688:1;21670:20;:::i;:::-;21665:25;;21709:1;21699:35;;21714:18;;:::i;:::-;21699:35;21756:1;21753;21749:9;21744:14;;21579:185;;;;:::o;21770:224::-;21910:34;21906:1;21898:6;21894:14;21887:58;21979:7;21974:2;21966:6;21962:15;21955:32;21770:224;:::o;22000:366::-;22142:3;22163:67;22227:2;22222:3;22163:67;:::i;:::-;22156:74;;22239:93;22328:3;22239:93;:::i;:::-;22357:2;22352:3;22348:12;22341:19;;22000:366;;;:::o;22372:419::-;22538:4;22576:2;22565:9;22561:18;22553:26;;22625:9;22619:4;22615:20;22611:1;22600:9;22596:17;22589:47;22653:131;22779:4;22653:131;:::i;:::-;22645:139;;22372:419;;;:::o;22797:222::-;22937:34;22933:1;22925:6;22921:14;22914:58;23006:5;23001:2;22993:6;22989:15;22982:30;22797:222;:::o;23025:366::-;23167:3;23188:67;23252:2;23247:3;23188:67;:::i;:::-;23181:74;;23264:93;23353:3;23264:93;:::i;:::-;23382:2;23377:3;23373:12;23366:19;;23025:366;;;:::o;23397:419::-;23563:4;23601:2;23590:9;23586:18;23578:26;;23650:9;23644:4;23640:20;23636:1;23625:9;23621:17;23614:47;23678:131;23804:4;23678:131;:::i;:::-;23670:139;;23397:419;;;:::o;23822:225::-;23962:34;23958:1;23950:6;23946:14;23939:58;24031:8;24026:2;24018:6;24014:15;24007:33;23822:225;:::o;24053:366::-;24195:3;24216:67;24280:2;24275:3;24216:67;:::i;:::-;24209:74;;24292:93;24381:3;24292:93;:::i;:::-;24410:2;24405:3;24401:12;24394:19;;24053:366;;;:::o;24425:419::-;24591:4;24629:2;24618:9;24614:18;24606:26;;24678:9;24672:4;24668:20;24664:1;24653:9;24649:17;24642:47;24706:131;24832:4;24706:131;:::i;:::-;24698:139;;24425:419;;;:::o;24850:137::-;24904:5;24935:6;24929:13;24920:22;;24951:30;24975:5;24951:30;:::i;:::-;24850:137;;;;:::o;24993:345::-;25060:6;25109:2;25097:9;25088:7;25084:23;25080:32;25077:119;;;25115:79;;:::i;:::-;25077:119;25235:1;25260:61;25313:7;25304:6;25293:9;25289:22;25260:61;:::i;:::-;25250:71;;25206:125;24993:345;;;;:::o;25344:229::-;25484:34;25480:1;25472:6;25468:14;25461:58;25553:12;25548:2;25540:6;25536:15;25529:37;25344:229;:::o;25579:366::-;25721:3;25742:67;25806:2;25801:3;25742:67;:::i;:::-;25735:74;;25818:93;25907:3;25818:93;:::i;:::-;25936:2;25931:3;25927:12;25920:19;;25579:366;;;:::o;25951:419::-;26117:4;26155:2;26144:9;26140:18;26132:26;;26204:9;26198:4;26194:20;26190:1;26179:9;26175:17;26168:47;26232:131;26358:4;26232:131;:::i;:::-;26224:139;;25951:419;;;:::o;26376:180::-;26424:77;26421:1;26414:88;26521:4;26518:1;26511:15;26545:4;26542:1;26535:15;26562:180;26610:77;26607:1;26600:88;26707:4;26704:1;26697:15;26731:4;26728:1;26721:15;26748:225;26888:34;26884:1;26876:6;26872:14;26865:58;26957:8;26952:2;26944:6;26940:15;26933:33;26748:225;:::o;26979:366::-;27121:3;27142:67;27206:2;27201:3;27142:67;:::i;:::-;27135:74;;27218:93;27307:3;27218:93;:::i;:::-;27336:2;27331:3;27327:12;27320:19;;26979:366;;;:::o;27351:419::-;27517:4;27555:2;27544:9;27540:18;27532:26;;27604:9;27598:4;27594:20;27590:1;27579:9;27575:17;27568:47;27632:131;27758:4;27632:131;:::i;:::-;27624:139;;27351:419;;;:::o;27776:98::-;27827:6;27861:5;27855:12;27845:22;;27776:98;;;:::o;27880:147::-;27981:11;28018:3;28003:18;;27880:147;;;;:::o;28033:386::-;28137:3;28165:38;28197:5;28165:38;:::i;:::-;28219:88;28300:6;28295:3;28219:88;:::i;:::-;28212:95;;28316:65;28374:6;28369:3;28362:4;28355:5;28351:16;28316:65;:::i;:::-;28406:6;28401:3;28397:16;28390:23;;28141:278;28033:386;;;;:::o;28425:271::-;28555:3;28577:93;28666:3;28657:6;28577:93;:::i;:::-;28570:100;;28687:3;28680:10;;28425:271;;;;:::o;28702:179::-;28842:31;28838:1;28830:6;28826:14;28819:55;28702:179;:::o;28887:366::-;29029:3;29050:67;29114:2;29109:3;29050:67;:::i;:::-;29043:74;;29126:93;29215:3;29126:93;:::i;:::-;29244:2;29239:3;29235:12;29228:19;;28887:366;;;:::o;29259:419::-;29425:4;29463:2;29452:9;29448:18;29440:26;;29512:9;29506:4;29502:20;29498:1;29487:9;29483:17;29476:47;29540:131;29666:4;29540:131;:::i;:::-;29532:139;;29259:419;;;:::o

ipfs://792b8d4c146eb331b907ce8f139d547eca2f64e1c3acd5217ace1d57cfb77983