Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

//     ___                         __ 
//    /   |  _____________  ____  / /_
//   / /| | / ___/ ___/ _ \/ __ \/ __/
//  / ___ |(__  |__  )  __/ / / / /_  
// /_/  |_/____/____/\___/_/ /_/\__/  
// 
// 2022 - Assent Protocol

pragma solidity 0.8.11;

import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./SafeERC20.sol";
import "./sASNTToken.sol";

interface IMasterchef {
    function deposit(uint256 _pid, uint256 _amount, address _referrer) external;

    function withdraw(uint256 _pid, uint256 _amount) external;
    
    function pendingTokens(uint256 _pid, address _user) external view returns (
            address[] memory addresses,
            string[] memory symbols,
            uint256[] memory decimals,
            uint256[] memory amounts
        );

    function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256, uint256, uint256, uint256);

    function emergencyWithdraw(uint256 _pid) external;
}

contract AssentAutocompound is Ownable, Pausable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    struct UserInfo {
        uint256 lastDepositedTime;
        uint256 tokenAtLastUserAction;
        uint256 lastUserActionTime;
    }

	// ASNT token
    sASNTToken immutable public sASNT;
    IERC20 public immutable token;
    IMasterchef public immutable masterchef;
    uint256 public immutable stakingPid;

    mapping(address => UserInfo) public userInfo;
    mapping(address => bool) public whitelistedProxies;

    uint256 public lastHarvestedTime;
    address public treasury;

    uint256 internal constant MAX_PERFORMANCE_FEE = 500;
    uint256 internal constant MAX_CALL_FEE = 100;
    uint256 internal constant MAX_WITHDRAW_FEE = 200;
    uint256 internal constant MAX_WITHDRAW_FEE_PERIOD = 72 hours;
    address internal referrer = 0x000000000000000000000000000000000000dEaD;

    uint256 public performanceFee = 400;
    uint256 public callFee = 5;
    uint256 public withdrawFee = 0;
    uint256 public withdrawFeePeriod = 72 hours;
    
    bool public hadEmergencyWithdrawn = false;

    event Deposit(address indexed sender, uint256 amount, uint256 mintSupply, uint256 lastDepositedTime);
    event Withdraw(address indexed sender, uint256 currentAmount, uint256 amount);
    event Harvest(address indexed sender, uint256 performanceFee, uint256 callFee);
    event WhitelistedProxy(address indexed proxy);
    event DewhitelistedProxy(address indexed proxy);
    event SetTreasury(address indexed treasury);
    event SetPerformanceFee(uint256 performanceFee);
    event SetCallFee(uint256 callFee);
    event SetWithdrawFee(uint256 withdrawFee);
    event SetWithdrawFeePeriod(uint256 withdrawFeePeriod);
    event EmergencyWithdraw();

    constructor(
        sASNTToken _sASNT,
        IERC20 _token,
        IMasterchef _masterchef,
        uint256 _stakingPid,
        address _treasury
    ) {
        sASNT = _sASNT;
        token = _token;
        masterchef = _masterchef;
        stakingPid = _stakingPid;
        treasury = _treasury;

        IERC20(_token).approve(address(_masterchef), type(uint256).max);
    }
    
    function whitelistProxy(address _proxy) external onlyOwner {
        require(_proxy != address(0), 'zero address');
        require(!whitelistedProxies[_proxy], 'proxy already whitelisted');
        whitelistedProxies[_proxy] = true;
        emit WhitelistedProxy(_proxy);
    }
    
    function dewhitelistProxy(address _proxy) external onlyOwner {
        require(_proxy != address(0), 'zero address');
        require(whitelistedProxies[_proxy], 'proxy not whitelisted');
        whitelistedProxies[_proxy] = false;
        emit DewhitelistedProxy(_proxy);
    }

    function deposit(address _user, uint256 _amount) external whenNotPaused nonReentrant {
        require(_amount > 0, "Nothing to deposit");
        require(_user == msg.sender || whitelistedProxies[msg.sender], 'msg.sender is not allowed proxy');

        uint256 pool = tokenBalanceOf();
        token.safeTransferFrom(msg.sender, address(this), _amount);
        uint256 mintSupply = 0;
        if (sASNT.totalSupply() != 0) {
            mintSupply = _amount * sASNT.totalSupply() / pool;
        } else {
            mintSupply = _amount;
        }
        UserInfo storage user = userInfo[_user];

        sASNT.mint(_user, mintSupply);
        user.lastDepositedTime = block.timestamp;

        user.tokenAtLastUserAction = sASNT.balanceOf(_user) * tokenBalanceOf() / sASNT.totalSupply();
        user.lastUserActionTime = block.timestamp;

        _earn();

        emit Deposit(_user, _amount, mintSupply, block.timestamp);
    }

    function withdrawAll() external {
        withdraw(sASNT.balanceOf(msg.sender));
    }

    function harvest() external whenNotPaused nonReentrant {
        IMasterchef(masterchef).deposit(stakingPid, 0, referrer);

        uint256 bal = available();
        uint256 currentPerformanceFee = bal * performanceFee / 10000;
        token.safeTransfer(treasury, currentPerformanceFee);

        uint256 currentCallFee = bal * callFee / 10000;
        token.safeTransfer(msg.sender, currentCallFee);

        _earn();

        lastHarvestedTime = block.timestamp;

        emit Harvest(msg.sender, currentPerformanceFee, currentCallFee);
    }

    function setTreasury(address _treasury) external onlyOwner {
        require(_treasury != address(0), "Cannot be zero address");
        treasury = _treasury;
        emit SetTreasury(_treasury);
    }

    function setPerformanceFee(uint256 _performanceFee) external onlyOwner {
        require(_performanceFee <= MAX_PERFORMANCE_FEE, "performanceFee cannot be more than MAX_PERFORMANCE_FEE");
        performanceFee = _performanceFee;
        emit SetPerformanceFee(_performanceFee);
    }

    function setCallFee(uint256 _callFee) external onlyOwner {
        require(_callFee <= MAX_CALL_FEE, "callFee cannot be more than MAX_CALL_FEE");
        callFee = _callFee;
        emit SetCallFee(_callFee);
    }

    function setWithdrawFee(uint256 _withdrawFee) external onlyOwner {
        require(_withdrawFee <= MAX_WITHDRAW_FEE, "withdrawFee cannot be more than MAX_WITHDRAW_FEE");
        withdrawFee = _withdrawFee;
        emit SetWithdrawFee(_withdrawFee);
    }

    function setWithdrawFeePeriod(uint256 _withdrawFeePeriod) external onlyOwner {
        require(
            _withdrawFeePeriod <= MAX_WITHDRAW_FEE_PERIOD,
            "withdrawFeePeriod cannot be more than MAX_WITHDRAW_FEE_PERIOD"
        );
        withdrawFeePeriod = _withdrawFeePeriod;
        emit SetWithdrawFeePeriod(_withdrawFeePeriod);
    }

    function emergencyWithdraw() external onlyOwner {
        IMasterchef(masterchef).emergencyWithdraw(stakingPid);
        hadEmergencyWithdrawn = true;
        _pause();
        emit EmergencyWithdraw();
    }

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

    function unpause() external onlyOwner {
        require(!hadEmergencyWithdrawn, 'cannot unpause after emergency withdraw');
        _unpause();
    }

    function calculateHarvestTokenRewards() external view returns (uint256) {
        uint256 currentCallFee = calculateTotalPendingTokenRewards() * callFee / 10000;
        return currentCallFee;
    }

    function calculateTotalPendingTokenRewards() public view returns (uint256) {
        uint256[] memory amount;
        ( , , , amount) = IMasterchef(masterchef).pendingTokens(stakingPid, address(this));
        amount[0] = amount[0] + available();

        return amount[0];
    }

    function getPricePerFullShare() external view returns (uint256) {
        return sASNT.totalSupply() == 0 ? 1e18 : tokenBalanceOf() * 1e18 / sASNT.totalSupply();
    }

    function withdraw(uint256 _amount) public nonReentrant {

        UserInfo storage user = userInfo[msg.sender];
        require(_amount > 0, "Nothing to withdraw");
        require(_amount <= sASNT.balanceOf(msg.sender), "Withdraw amount exceeds balance");

        uint256 currentAmount = tokenBalanceOf() * _amount / sASNT.totalSupply();
        sASNT.burnFrom(msg.sender, _amount);

        uint256 bal = available();
        if (bal < currentAmount) {
            uint256 balWithdraw = currentAmount - bal;
            IMasterchef(masterchef).withdraw(stakingPid, balWithdraw);
            uint256 balAfter = available();
            uint256 diff = balAfter - bal;
            if (diff < balWithdraw) {
                currentAmount = balAfter;
            }
        }

        if (block.timestamp < user.lastDepositedTime + withdrawFeePeriod) {
            uint256 currentWithdrawFee = currentAmount * withdrawFee / 10000;
            token.safeTransfer(treasury, currentWithdrawFee);
            currentAmount = currentAmount - currentWithdrawFee;
        }

        if (sASNT.balanceOf(msg.sender) > 0) {
            user.tokenAtLastUserAction = sASNT.balanceOf(msg.sender) * tokenBalanceOf() / sASNT.totalSupply();
        } else {
            user.tokenAtLastUserAction = 0;
        }

        user.lastUserActionTime = block.timestamp;

        token.safeTransfer(msg.sender, currentAmount);

        emit Withdraw(msg.sender, currentAmount, _amount);
    }

    function available() public view returns (uint256) {
        return token.balanceOf(address(this));
    }

    function tokenBalanceOf() public view returns (uint256) {
        (uint256 amount, , , ,) = IMasterchef(masterchef).userInfo(stakingPid, address(this));
        return token.balanceOf(address(this)) + amount;
    }

    function _earn() internal {
        uint256 bal = available();
        if (bal > 0) {
            IMasterchef(masterchef).deposit(stakingPid, bal, referrer);
        }
    }

    function inCaseTokensGetStuck(address _token) external onlyOwner {
        require(_token != address(token), "Token cannot be same as deposit token");

        uint256 amount = IERC20(_token).balanceOf(address(this));
        IERC20(_token).safeTransfer(msg.sender, amount);
    }

    function pendingPerUser(address _user) public view returns (uint256 pending,uint256 userShare,uint256 inUserWallet,uint256 userASNTValue,uint256 userEarnSinceLastAction) {

        UserInfo storage user = userInfo[_user];

        if (sASNT.totalSupply() > 0){
            // ratio of user sASNT holdings
            userShare = sASNT.balanceOf(_user) * 1e18 / sASNT.totalSupply();
            
            //User ASNT available value to withdrawal
            userASNTValue = sASNT.balanceOf(_user) * tokenBalanceOf() / sASNT.totalSupply();
            
            //Live pending per user in the masterchef / Only for debug
            pending = calculateTotalPendingTokenRewards() * userShare / 1e18;

            //Reward accumulated since last user action (deposit/withdrawal)
            userEarnSinceLastAction = userASNTValue - user.tokenAtLastUserAction;            
        }

        //balance in user wallet
        inUserWallet = sASNT.balanceOf(_user);     

        return (pending,userShare,inUserWallet,userASNTValue,userEarnSinceLastAction);
    }


}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "./ERC165.sol";
import "./Context.sol";
import "./Strings.sol";

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

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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

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

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

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

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

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

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

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

        _revokeRole(role, account);
    }

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ├╖ 2 + 1, and for v in (302): v Γêê {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT

import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Context.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.zeppelin.solutions/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(IERC20,IERC20Metadata) 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(IERC20,IERC20Metadata) 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(IERC20,IERC20Metadata) 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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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;
        _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;
        }
        _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 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 {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";

pragma solidity ^0.8.0;

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20Permit.sol";
import "./ERC20.sol";
import "./EIP712.sol";
import "./Counters.sol";

/**
 * @dev Implementation 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.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/draft-IERC20Permit.sol)

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./Context.sol";

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

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

    bool private _paused;

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

// SPDX-License-Identifier: MIT

//     ___                         __ 
//    /   |  _____________  ____  / /_
//   / /| | / ___/ ___/ _ \/ __ \/ __/
//  / ___ |(__  |__  )  __/ / / / /_  
// /_/  |_/____/____/\___/_/ /_/\__/  
// 
// 2022 - Assent Protocol

pragma solidity 0.8.11;

import "./ERC20Permit.sol";
import "./ERC20Burnable.sol";
import "./AccessControl.sol";
import "./Pausable.sol";
import "./SafeERC20.sol";

contract sASNTToken is
    ERC20Burnable,
    ERC20Permit,
    AccessControl,
    Pausable
{
    using SafeERC20 for IERC20;
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant RESCUER_ROLE = keccak256("RESCUER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    constructor() ERC20("Assent Protocol sASNT Token", "sASNT") ERC20Permit("Assent Protocol") {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(PAUSER_ROLE, msg.sender);
        _setupRole(MINTER_ROLE, msg.sender);
        _setupRole(RESCUER_ROLE, msg.sender);
    }

    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        _mint(to, amount);
    }

    function rescueTokens(IERC20 token, uint256 value)
        external
        onlyRole(RESCUER_ROLE)
    {
        token.transfer(msg.sender, value);
    }

    function pause() external onlyRole(PAUSER_ROLE) {
        _pause();
    }

    function unpause() external onlyRole(PAUSER_ROLE) {
        _unpause();
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override whenNotPaused {
        super._beforeTokenTransfer(from, to, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

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

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

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract sASNTToken","name":"_sASNT","type":"address"},{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"contract IMasterchef","name":"_masterchef","type":"address"},{"internalType":"uint256","name":"_stakingPid","type":"uint256"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mintSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastDepositedTime","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"}],"name":"DewhitelistedProxy","type":"event"},{"anonymous":false,"inputs":[],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"performanceFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"callFee","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"callFee","type":"uint256"}],"name":"SetCallFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"performanceFee","type":"uint256"}],"name":"SetPerformanceFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"treasury","type":"address"}],"name":"SetTreasury","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"withdrawFee","type":"uint256"}],"name":"SetWithdrawFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"withdrawFeePeriod","type":"uint256"}],"name":"SetWithdrawFeePeriod","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"}],"name":"WhitelistedProxy","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"currentAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"available","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculateHarvestTokenRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculateTotalPendingTokenRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"callFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_proxy","type":"address"}],"name":"dewhitelistProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getPricePerFullShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hadEmergencyWithdrawn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"inCaseTokensGetStuck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastHarvestedTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterchef","outputs":[{"internalType":"contract IMasterchef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingPerUser","outputs":[{"internalType":"uint256","name":"pending","type":"uint256"},{"internalType":"uint256","name":"userShare","type":"uint256"},{"internalType":"uint256","name":"inUserWallet","type":"uint256"},{"internalType":"uint256","name":"userASNTValue","type":"uint256"},{"internalType":"uint256","name":"userEarnSinceLastAction","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sASNT","outputs":[{"internalType":"contract sASNTToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_callFee","type":"uint256"}],"name":"setCallFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFee","type":"uint256"}],"name":"setPerformanceFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawFee","type":"uint256"}],"name":"setWithdrawFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawFeePeriod","type":"uint256"}],"name":"setWithdrawFeePeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingPid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenBalanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"lastDepositedTime","type":"uint256"},{"internalType":"uint256","name":"tokenAtLastUserAction","type":"uint256"},{"internalType":"uint256","name":"lastUserActionTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_proxy","type":"address"}],"name":"whitelistProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistedProxies","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawFeePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000104b2aa5333966360c4f28c206634759c546b8270000000000000000000000005b3c1f260e09e653290f24f75abc5e466fd423100000000000000000000000002df0d214239e20535060220ae54ef361606e346b0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000d8a8529abf3cde54c59126f99cb991f07fd3b1f1

-----Decoded View---------------
Arg [0] : _sASNT (address): 0x104b2aa5333966360C4F28C206634759C546B827
Arg [1] : _token (address): 0x5B3C1F260E09e653290f24F75abC5e466fD42310
Arg [2] : _masterchef (address): 0x2Df0d214239E20535060220aE54ef361606e346b
Arg [3] : _stakingPid (uint256): 2
Arg [4] : _treasury (address): 0xD8A8529ABf3cdE54c59126f99Cb991f07Fd3b1F1

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000104b2aa5333966360c4f28c206634759c546b827
Arg [1] : 0000000000000000000000005b3c1f260e09e653290f24f75abc5e466fd42310
Arg [2] : 0000000000000000000000002df0d214239e20535060220ae54ef361606e346b
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [4] : 000000000000000000000000d8a8529abf3cde54c59126f99cb991f07fd3b1f1

1026:10362:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1461:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;604:25:22;;;660:2;645:18;;638:34;;;;688:18;;;681:34;592:2;577:18;1461:44:2;;;;;;;;1512:50;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;891:14:22;;884:22;866:41;;854:2;839:18;1512:50:2;726:187:22;6467:357:2;;;;;;:::i;:::-;;:::i;:::-;;5975:218;;;;;;:::i;:::-;;:::i;3248:283::-;;;;;;:::i;:::-;;:::i;7963:1504::-;;;;;;:::i;:::-;;:::i;3543:283::-;;;;;;:::i;:::-;;:::i;7493:285::-;;;:::i;:::-;;;1249:25:22;;;1237:2;1222:18;7493:285:2;1103:177:22;7124:152:2;;;:::i;4897:561::-;;;:::i;3834:959::-;;;;;;:::i;:::-;;:::i;9475:107::-;;;:::i;1070:86:17:-;1117:4;1141:7;-1:-1:-1;;;1141:7:17;;;;1070:86;;1610:23:2;;;;;-1:-1:-1;;;;;1610:23:2;;;;;;-1:-1:-1;;;;;1769:32:22;;;1751:51;;1739:2;1724:18;1610:23:2;1605:203:22;10294:1087:2;;;;;;:::i;:::-;;:::i;:::-;;;;2072:25:22;;;2128:2;2113:18;;2106:34;;;;2156:18;;;2149:34;;;;2214:2;2199:18;;2192:34;2257:3;2242:19;;2235:35;2059:3;2044:19;10294:1087:2;1813:463:22;5679:288:2;;;;;;:::i;:::-;;:::i;1714:103:16:-;;;:::i;7786:169:2:-;;;:::i;2120:41::-;;;;;;;;;7053:63;;;:::i;4801:88::-;;;:::i;1952:35::-;;;;;;1063:87:16;1109:7;1136:6;-1:-1:-1;;;;;1136:6:16;1063:87;;1994:26:2;;;;;;7284:201;;;:::i;1571:32::-;;;;;;6201:258;;;;;;:::i;:::-;;:::i;9590:217::-;;;:::i;6832:213::-;;;:::i;10001:285::-;;;;;;:::i;:::-;;:::i;2064:43::-;;;;;;2027:30;;;;;;1295:33;;;;;5466:205;;;;;;:::i;:::-;;:::i;1972:201:16:-;;;;;;:::i;:::-;;:::i;1417:35:2:-;;;;;1371:39;;;;;1335:29;;;;;6467:357;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;;;;;;;;;1858:8:2::1;6577:18;:45;;6555:156;;;::::0;-1:-1:-1;;;6555:156:2;;3521:2:22;6555:156:2::1;::::0;::::1;3503:21:22::0;3560:2;3540:18;;;3533:30;3599:34;3579:18;;;3572:62;3670:31;3650:18;;;3643:59;3719:19;;6555:156:2::1;3319:425:22::0;6555:156:2::1;6722:17;:38:::0;;;6776:40:::1;::::0;1249:25:22;;;6776:40:2::1;::::0;1237:2:22;1222:18;6776:40:2::1;;;;;;;;6467:357:::0;:::o;5975:218::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1741:3:2::1;6051:8;:24;;6043:77;;;::::0;-1:-1:-1;;;6043:77:2;;3951:2:22;6043:77:2::1;::::0;::::1;3933:21:22::0;3990:2;3970:18;;;3963:30;4029:34;4009:18;;;4002:62;-1:-1:-1;;;4080:18:22;;;4073:38;4128:19;;6043:77:2::1;3749:404:22::0;6043:77:2::1;6131:7;:18:::0;;;6165:20:::1;::::0;1249:25:22;;;6165:20:2::1;::::0;1237:2:22;1222:18;6165:20:2::1;1103:177:22::0;3248:283:2;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;-1:-1:-1;;;;;3326:20:2;::::1;3318:45;;;::::0;-1:-1:-1;;;3318:45:2;;4360:2:22;3318:45:2::1;::::0;::::1;4342:21:22::0;4399:2;4379:18;;;4372:30;-1:-1:-1;;;4418:18:22;;;4411:42;4470:18;;3318:45:2::1;4158:336:22::0;3318:45:2::1;-1:-1:-1::0;;;;;3383:26:2;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;3382:27;3374:65;;;::::0;-1:-1:-1;;;3374:65:2;;4701:2:22;3374:65:2::1;::::0;::::1;4683:21:22::0;4740:2;4720:18;;;4713:30;4779:27;4759:18;;;4752:55;4824:18;;3374:65:2::1;4499:349:22::0;3374:65:2::1;-1:-1:-1::0;;;;;3450:26:2;::::1;;::::0;;;:18:::1;:26;::::0;;;;;:33;;-1:-1:-1;;3450:33:2::1;3479:4;3450:33;::::0;;3499:24;::::1;::::0;3450:26;3499:24:::1;3248:283:::0;:::o;7963:1504::-;1713:1:18;2311:7;;:19;;2303:63;;;;-1:-1:-1;;;2303:63:18;;;;;;;:::i;:::-;1713:1;2444:7;:18;;;8064:10:2::1;8031:21;8055:20:::0;;;::::1;::::0;;;;;;;8094:11;8086:43:::1;;;::::0;-1:-1:-1;;;8086:43:2;;5415:2:22;8086:43:2::1;::::0;::::1;5397:21:22::0;5454:2;5434:18;;;5427:30;-1:-1:-1;;;5473:18:22;;;5466:49;5532:18;;8086:43:2::1;5213:343:22::0;8086:43:2::1;8159:27;::::0;-1:-1:-1;;;8159:27:2;;8175:10:::1;8159:27;::::0;::::1;1751:51:22::0;8159:5:2::1;-1:-1:-1::0;;;;;8159:15:2::1;::::0;::::1;::::0;1724:18:22;;8159:27:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8148:7;:38;;8140:82;;;::::0;-1:-1:-1;;;8140:82:2;;5952:2:22;8140:82:2::1;::::0;::::1;5934:21:22::0;5991:2;5971:18;;;5964:30;6030:33;6010:18;;;6003:61;6081:18;;8140:82:2::1;5750:355:22::0;8140:82:2::1;8235:21;8288:5;-1:-1:-1::0;;;;;8288:17:2::1;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8278:7;8259:16;:14;:16::i;:::-;:26;;;;:::i;:::-;:48;;;;:::i;:::-;8318:35;::::0;-1:-1:-1;;;8318:35:2;;8333:10:::1;8318:35;::::0;::::1;6811:51:22::0;6878:18;;;6871:34;;;8235:72:2;;-1:-1:-1;8318:5:2::1;-1:-1:-1::0;;;;;8318:14:2::1;::::0;::::1;::::0;6784:18:22;;8318:35:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;8366:11;8380;:9;:11::i;:::-;8366:25;;8412:13;8406:3;:19;8402:351;;;8442:19;8464;8480:3:::0;8464:13;:19:::1;:::i;:::-;8498:57;::::0;-1:-1:-1;;;8498:57:2;;8531:10:::1;8498:57;::::0;::::1;7220:25:22::0;7261:18;;;7254:34;;;8442:41:2;;-1:-1:-1;8510:10:2::1;-1:-1:-1::0;;;;;8498:32:2::1;::::0;::::1;::::0;7193:18:22;;8498:57:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;8570:16;8589:11;:9;:11::i;:::-;8570:30:::0;-1:-1:-1;8615:12:2::1;8630:14;8641:3:::0;8570:30;8630:14:::1;:::i;:::-;8615:29;;8670:11;8663:4;:18;8659:83;;;8718:8;8702:24;;8659:83;8427:326;;;8402:351;8812:17;::::0;8787:22;;:42:::1;::::0;8812:17;8787:42:::1;:::i;:::-;8769:15;:60;8765:285;;;8846:26;8905:5;8891:11;;8875:13;:27;;;;:::i;:::-;:35;;;;:::i;:::-;8944:8;::::0;8846:64;;-1:-1:-1;8925:48:2::1;::::0;-1:-1:-1;;;;;8925:5:2::1;:18:::0;::::1;::::0;8944:8:::1;8846:64:::0;8925:18:::1;:48::i;:::-;9004:34;9020:18:::0;9004:13;:34:::1;:::i;:::-;8988:50;;8831:219;8765:285;9066:27;::::0;-1:-1:-1;;;9066:27:2;;9082:10:::1;9066:27;::::0;::::1;1751:51:22::0;9096:1:2::1;::::0;9066:5:::1;-1:-1:-1::0;;;;;9066:15:2::1;::::0;::::1;::::0;1724:18:22;;9066:27:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:31;9062:224;;;9192:5;-1:-1:-1::0;;;;;9192:17:2::1;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9173:16;:14;:16::i;:::-;9143:27;::::0;-1:-1:-1;;;9143:27:2;;9159:10:::1;9143:27;::::0;::::1;1751:51:22::0;9143:5:2::1;-1:-1:-1::0;;;;;9143:15:2::1;::::0;::::1;::::0;1724:18:22;;9143:27:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:46;;;;:::i;:::-;:68;;;;:::i;:::-;9114:26;::::0;::::1;:97:::0;9062:224:::1;;;9273:1;9244:26;::::0;::::1;:30:::0;9062:224:::1;9324:15;9298:23;::::0;::::1;:41:::0;9352:45:::1;-1:-1:-1::0;;;;;9352:5:2::1;:18;9371:10;9383:13:::0;9352:18:::1;:45::i;:::-;9415:44;::::0;;7220:25:22;;;7276:2;7261:18;;7254:34;;;9424:10:2::1;::::0;9415:44:::1;::::0;7193:18:22;9415:44:2::1;;;;;;;-1:-1:-1::0;;1669:1:18;2623:22;;-1:-1:-1;;7963:1504:2:o;3543:283::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;-1:-1:-1;;;;;3623:20:2;::::1;3615:45;;;::::0;-1:-1:-1;;;3615:45:2;;4360:2:22;3615:45:2::1;::::0;::::1;4342:21:22::0;4399:2;4379:18;;;4372:30;-1:-1:-1;;;4418:18:22;;;4411:42;4470:18;;3615:45:2::1;4158:336:22::0;3615:45:2::1;-1:-1:-1::0;;;;;3679:26:2;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;3671:60;;;::::0;-1:-1:-1;;;3671:60:2;;7634:2:22;3671:60:2::1;::::0;::::1;7616:21:22::0;7673:2;7653:18;;;7646:30;-1:-1:-1;;;7692:18:22;;;7685:51;7753:18;;3671:60:2::1;7432:345:22::0;3671:60:2::1;-1:-1:-1::0;;;;;3742:26:2;::::1;3771:5;3742:26:::0;;;:18:::1;:26;::::0;;;;;:34;;-1:-1:-1;;3742:34:2::1;::::0;;3792:26;::::1;::::0;3771:5;3792:26:::1;3543:283:::0;:::o;7493:285::-;7631:64;;-1:-1:-1;;;;;;7631:64:2;;7669:10;7631:64;;;7956:25:22;7689:4:2;7997:18:22;;;7990:60;7559:7:2;;7579:23;;-1:-1:-1;;;;;7643:10:2;7631:37;;;;7929:18:22;;7631:64:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7631:64:2;;;;;;;;;;;;:::i;:::-;7613:82;-1:-1:-1;7730:11:2;;-1:-1:-1;7730:9:2;;-1:-1:-1;;7730:11:2:i;:::-;7718:6;7725:1;7718:9;;;;;;;;:::i;:::-;;;;;;;:23;;;;:::i;:::-;7706:6;7713:1;7706:9;;;;;;;;:::i;:::-;;;;;;:35;;;;;7761:6;7768:1;7761:9;;;;;;;;:::i;:::-;;;;;;;7754:16;;;7493:285;:::o;7124:152::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;7182:21:2::1;::::0;::::1;;7181:22;7173:74;;;::::0;-1:-1:-1;;;7173:74:2;;13101:2:22;7173:74:2::1;::::0;::::1;13083:21:22::0;13140:2;13120:18;;;13113:30;13179:34;13159:18;;;13152:62;-1:-1:-1;;;13230:18:22;;;13223:37;13277:19;;7173:74:2::1;12899:403:22::0;7173:74:2::1;7258:10;:8;:10::i;:::-;7124:152::o:0;4897:561::-;1117:4:17;1141:7;-1:-1:-1;;;1141:7:17;;;;1395:9;1387:38;;;;-1:-1:-1;;;1387:38:17;;;;;;;:::i;:::-;1713:1:18::1;2311:7;;:19;;2303:63;;;;-1:-1:-1::0;;;2303:63:18::1;;;;;;;:::i;:::-;1713:1;2444:7;:18:::0;5010:8:2::2;::::0;4963:56:::2;::::0;-1:-1:-1;;;4963:56:2;;4995:10:::2;4963:56;::::0;::::2;13862:25:22::0;5007:1:2::2;13903:18:22::0;;;13896:34;-1:-1:-1;;;;;5010:8:2;;::::2;13946:18:22::0;;;13939:60;4975:10:2::2;4963:31:::0;;::::2;::::0;::::2;::::0;13835:18:22;;4963:56:2::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;5032:11;5046;:9;:11::i;:::-;5032:25;;5068:29;5123:5;5106:14;;5100:3;:20;;;;:::i;:::-;:28;;;;:::i;:::-;5158:8;::::0;5068:60;;-1:-1:-1;5139:51:2::2;::::0;-1:-1:-1;;;;;5139:5:2::2;:18:::0;::::2;::::0;5158:8:::2;5068:60:::0;5139:18:::2;:51::i;:::-;5203:22;5244:5;5234:7;;5228:3;:13;;;;:::i;:::-;:21;;;;:::i;:::-;5203:46:::0;-1:-1:-1;5260:46:2::2;-1:-1:-1::0;;;;;5260:5:2::2;:18;5279:10;5203:46:::0;5260:18:::2;:46::i;:::-;5319:7;:5;:7::i;:::-;5359:15;5339:17;:35:::0;5392:58:::2;::::0;;7220:25:22;;;7276:2;7261:18;;7254:34;;;5400:10:2::2;::::0;5392:58:::2;::::0;7193:18:22;5392:58:2::2;;;;;;;-1:-1:-1::0;;1669:1:18::1;2623:22:::0;;-1:-1:-1;4897:561:2:o;3834:959::-;1117:4:17;1141:7;-1:-1:-1;;;1141:7:17;;;;1395:9;1387:38;;;;-1:-1:-1;;;1387:38:17;;;;;;;:::i;:::-;1713:1:18::1;2311:7;;:19;;2303:63;;;;-1:-1:-1::0;;;2303:63:18::1;;;;;;;:::i;:::-;1713:1;2444:7;:18:::0;3938:11:2;3930:42:::2;;;::::0;-1:-1:-1;;;3930:42:2;;14212:2:22;3930:42:2::2;::::0;::::2;14194:21:22::0;14251:2;14231:18;;;14224:30;-1:-1:-1;;;14270:18:22;;;14263:48;14328:18;;3930:42:2::2;14010:342:22::0;3930:42:2::2;-1:-1:-1::0;;;;;3991:19:2;::::2;4000:10;3991:19;::::0;:53:::2;;-1:-1:-1::0;4033:10:2::2;4014:30;::::0;;;:18:::2;:30;::::0;;;;;::::2;;3991:53;3983:97;;;::::0;-1:-1:-1;;;3983:97:2;;14559:2:22;3983:97:2::2;::::0;::::2;14541:21:22::0;14598:2;14578:18;;;14571:30;14637:33;14617:18;;;14610:61;14688:18;;3983:97:2::2;14357:355:22::0;3983:97:2::2;4093:12;4108:16;:14;:16::i;:::-;4093:31:::0;-1:-1:-1;4135:58:2::2;-1:-1:-1::0;;;;;4135:5:2::2;:22;4158:10;4178:4;4185:7:::0;4135:22:::2;:58::i;:::-;4204:18;4241:5;-1:-1:-1::0;;;;;4241:17:2::2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:24:::0;4237:159:::2;;4327:4;4305:5;-1:-1:-1::0;;;;;4305:17:2::2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4295:29;::::0;:7;:29:::2;:::i;:::-;:36;;;;:::i;:::-;4282:49;;4237:159;;;-1:-1:-1::0;4377:7:2;4237:159:::2;-1:-1:-1::0;;;;;4430:15:2;;::::2;4406:21;4430:15:::0;;;:8:::2;:15;::::0;;;;;;4458:29;;-1:-1:-1;;;4458:29:2;;::::2;::::0;::::2;6811:51:22::0;;;;6878:18;;;6871:34;;;4430:15:2;4458:5:::2;:10;::::0;::::2;::::0;6784:18:22;;4458:29:2::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;4523:15;4498:4;:22;;:40;;;;4624:5;-1:-1:-1::0;;;;;4624:17:2::2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4605:16;:14;:16::i;:::-;4580:22;::::0;-1:-1:-1;;;4580:22:2;;-1:-1:-1;;;;;1769:32:22;;;4580:22:2::2;::::0;::::2;1751:51:22::0;4580:5:2::2;:15;::::0;::::2;::::0;1724:18:22;;4580:22:2::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:41;;;;:::i;:::-;:63;;;;:::i;:::-;4551:26;::::0;::::2;:92:::0;4680:15:::2;4654:23;::::0;::::2;:41:::0;4708:7:::2;:5;:7::i;:::-;4733:52;::::0;;604:25:22;;;660:2;645:18;;638:34;;;4769:15:2::2;688:18:22::0;;;681:34;4733:52:2;;-1:-1:-1;;;;;4733:52:2;::::2;::::0;::::2;::::0;;;;;592:2:22;4733:52:2;;::::2;-1:-1:-1::0;;1669:1:18::1;2623:22:::0;;-1:-1:-1;;;3834:959:2:o;9475:107::-;9544:30;;-1:-1:-1;;;9544:30:2;;9568:4;9544:30;;;1751:51:22;9517:7:2;;9544:5;-1:-1:-1;;;;;9544:15:2;;;;1724:18:22;;9544:30:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9537:37;;9475:107;:::o;10294:1087::-;10354:15;10370:17;10388:20;10409:21;10431:31;10477:21;10501:8;:15;10510:5;-1:-1:-1;;;;;10501:15:2;-1:-1:-1;;;;;10501:15:2;;;;;;;;;;;;10477:39;;10555:1;10533:5;-1:-1:-1;;;;;10533:17:2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:23;10529:666;;;10661:5;-1:-1:-1;;;;;10661:17:2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10629:22;;-1:-1:-1;;;10629:22:2;;-1:-1:-1;;;;;1769:32:22;;;10629:22:2;;;1751:51:22;10629:5:2;:15;;;;1724:18:22;;10629:22:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:29;;10654:4;10629:29;:::i;:::-;:51;;;;:::i;:::-;10617:63;;10824:5;-1:-1:-1;;;;;10824:17:2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10805:16;:14;:16::i;:::-;10780:22;;-1:-1:-1;;;10780:22:2;;-1:-1:-1;;;;;1769:32:22;;;10780:22:2;;;1751:51:22;10780:5:2;:15;;;;1724:18:22;;10780:22:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:41;;;;:::i;:::-;:63;;;;:::i;:::-;10764:79;;11004:4;10992:9;10954:35;:33;:35::i;:::-;:47;;;;:::i;:::-;:54;;;;:::i;:::-;10944:64;;11145:4;:26;;;11129:13;:42;;;;:::i;:::-;11103:68;;10529:666;11256:22;;-1:-1:-1;;;11256:22:2;;-1:-1:-1;;;;;1769:32:22;;;11256:22:2;;;1751:51:22;11256:5:2;:15;;;;1724:18:22;;11256:22:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11241:37;;11296:77;10294:1087;;;;;;;:::o;5679:288::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1690:3:2::1;5769:15;:38;;5761:105;;;::::0;-1:-1:-1;;;5761:105:2;;14919:2:22;5761:105:2::1;::::0;::::1;14901:21:22::0;14958:2;14938:18;;;14931:30;14997:34;14977:18;;;14970:62;-1:-1:-1;;;15048:18:22;;;15041:52;15110:19;;5761:105:2::1;14717:418:22::0;5761:105:2::1;5877:14;:32:::0;;;5925:34:::1;::::0;1249:25:22;;;5925:34:2::1;::::0;1237:2:22;1222:18;5925:34:2::1;1103:177:22::0;1714:103:16;1109:7;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1779:30:::1;1806:1;1779:18;:30::i;7786:169:2:-:0;7841:7;7868:5;-1:-1:-1;;;;;7868:17:2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:24;:79;;7928:5;-1:-1:-1;;;;;7928:17:2;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7902:16;:14;:16::i;:::-;:23;;7921:4;7902:23;:::i;:::-;:45;;;;:::i;7868:79::-;-1:-1:-1;7895:4:2;;7786:169::o;7053:63::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;7100:8:2::1;:6;:8::i;4801:88::-:0;4853:27;;-1:-1:-1;;;4853:27:2;;4869:10;4853:27;;;1751:51:22;4844:37:2;;4853:5;-1:-1:-1;;;;;4853:15:2;;;;1724:18:22;;4853:27:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;7284:201::-;7347:7;7367:22;7440:5;7430:7;;7392:35;:33;:35::i;:::-;:45;;;;:::i;:::-;:53;;;;:::i;:::-;7367:78;7284:201;-1:-1:-1;;7284:201:2:o;6201:258::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;1796:3:2::1;6285:12;:32;;6277:93;;;::::0;-1:-1:-1;;;6277:93:2;;15342:2:22;6277:93:2::1;::::0;::::1;15324:21:22::0;15381:2;15361:18;;;15354:30;15420:34;15400:18;;;15393:62;-1:-1:-1;;;15471:18:22;;;15464:46;15527:19;;6277:93:2::1;15140:412:22::0;6277:93:2::1;6381:11;:26:::0;;;6423:28:::1;::::0;1249:25:22;;;6423:28:2::1;::::0;1237:2:22;1222:18;6423:28:2::1;1103:177:22::0;9590:217:2;9683:59;;-1:-1:-1;;;9683:59:2;;9716:10;9683:59;;;7956:25:22;9736:4:2;7997:18:22;;;7990:60;9637:7:2;;;;-1:-1:-1;;;;;9695:10:2;9683:32;;;;7929:18:22;;9683:59:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;9760:30:2;;-1:-1:-1;;;9760:30:2;;9784:4;9760:30;;;1751:51:22;9657:85:2;;-1:-1:-1;9657:85:2;;-1:-1:-1;;;;;9760:5:2;:15;;-1:-1:-1;9760:15:2;;-1:-1:-1;1724:18:22;;9760:30:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:39;;;;:::i;:::-;9753:46;;;9590:217;:::o;6832:213::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;6891:53:2::1;::::0;-1:-1:-1;;;6891:53:2;;6933:10:::1;6891:53;::::0;::::1;1249:25:22::0;6903:10:2::1;-1:-1:-1::0;;;;;6891:41:2::1;::::0;::::1;::::0;1222:18:22;;6891:53:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;6955:21:2::1;:28:::0;;-1:-1:-1;;6955:28:2::1;6979:4;6955:28;::::0;;-1:-1:-1;6994:8:2::1;::::0;-1:-1:-1;6994:6:2::1;:8::i;:::-;7018:19;::::0;::::1;::::0;;;::::1;6832:213::o:0;10001:285::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;10103:5:2::1;-1:-1:-1::0;;;;;10085:24:2::1;:6;-1:-1:-1::0;;;;;10085:24:2::1;;;10077:74;;;::::0;-1:-1:-1;;;10077:74:2;;16194:2:22;10077:74:2::1;::::0;::::1;16176:21:22::0;16233:2;16213:18;;;16206:30;16272:34;16252:18;;;16245:62;-1:-1:-1;;;16323:18:22;;;16316:35;16368:19;;10077:74:2::1;15992:401:22::0;10077:74:2::1;10181:39;::::0;-1:-1:-1;;;10181:39:2;;10214:4:::1;10181:39;::::0;::::1;1751:51:22::0;10164:14:2::1;::::0;-1:-1:-1;;;;;10181:24:2;::::1;::::0;::::1;::::0;1724:18:22;;10181:39:2::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10164:56:::0;-1:-1:-1;10231:47:2::1;-1:-1:-1::0;;;;;10231:27:2;::::1;10259:10;10164:56:::0;10231:27:::1;:47::i;:::-;10066:220;10001:285:::0;:::o;5466:205::-;1109:7:16;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;-1:-1:-1;;;;;5544:23:2;::::1;5536:58;;;::::0;-1:-1:-1;;;5536:58:2;;16600:2:22;5536:58:2::1;::::0;::::1;16582:21:22::0;16639:2;16619:18;;;16612:30;-1:-1:-1;;;16658:18:22;;;16651:52;16720:18;;5536:58:2::1;16398:346:22::0;5536:58:2::1;5605:8;:20:::0;;-1:-1:-1;;;;;;5605:20:2::1;-1:-1:-1::0;;;;;5605:20:2;::::1;::::0;;::::1;::::0;;;5641:22:::1;::::0;::::1;::::0;-1:-1:-1;;5641:22:2::1;5466:205:::0;:::o;1972:201:16:-;1109:7;1136:6;-1:-1:-1;;;;;1136:6:16;682:10:3;1283:23:16;1275:68;;;;-1:-1:-1;;;1275:68:16;;;;;;;:::i;:::-;-1:-1:-1;;;;;2061:22:16;::::1;2053:73;;;::::0;-1:-1:-1;;;2053:73:16;;16951:2:22;2053:73:16::1;::::0;::::1;16933:21:22::0;16990:2;16970:18;;;16963:30;17029:34;17009:18;;;17002:62;-1:-1:-1;;;17080:18:22;;;17073:36;17126:19;;2053:73:16::1;16749:402:22::0;2053:73:16::1;2137:28;2156:8;2137:18;:28::i;:::-;1972:201:::0;:::o;639:211:19:-;783:58;;-1:-1:-1;;;;;6829:32:22;;783:58:19;;;6811:51:22;6878:18;;;6871:34;;;756:86:19;;776:5;;-1:-1:-1;;;806:23:19;6784:18:22;;783:58:19;;;;-1:-1:-1;;783:58:19;;;;;;;;;;;;;;-1:-1:-1;;;;;783:58:19;-1:-1:-1;;;;;;783:58:19;;;;;;;;;;756:19;:86::i;:::-;639:211;;;:::o;2129:120:17:-;1117:4;1141:7;-1:-1:-1;;;1141:7:17;;;;1665:41;;;;-1:-1:-1;;;1665:41:17;;17358:2:22;1665:41:17;;;17340:21:22;17397:2;17377:18;;;17370:30;-1:-1:-1;;;17416:18:22;;;17409:50;17476:18;;1665:41:17;17156:344:22;1665:41:17;2198:5:::1;2188:15:::0;;-1:-1:-1;;;;2188:15:17::1;::::0;;2219:22:::1;682:10:3::0;2228:12:17::1;2219:22;::::0;-1:-1:-1;;;;;1769:32:22;;;1751:51;;1739:2;1724:18;2219:22:17::1;;;;;;;2129:120::o:0;9815:178:2:-;9852:11;9866;:9;:11::i;:::-;9852:25;-1:-1:-1;9892:7:2;;9888:98;;9965:8;;9916:58;;-1:-1:-1;;;9916:58:2;;9948:10;9916:58;;;13862:25:22;13903:18;;;13896:34;;;-1:-1:-1;;;;;9965:8:2;;;13946:18:22;;;13939:60;9928:10:2;9916:31;;;;;;13835:18:22;;9916:58:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9841:152;9815:178::o;858:248:19:-;1029:68;;-1:-1:-1;;;;;18113:15:22;;;1029:68:19;;;18095:34:22;18165:15;;18145:18;;;18138:43;18197:18;;;18190:34;;;1002:96:19;;1022:5;;-1:-1:-1;;;1052:27:19;18030:18:22;;1029:68:19;17855:375:22;1002:96:19;858:248;;;;:::o;2333:191:16:-;2407:16;2426:6;;-1:-1:-1;;;;;2443:17:16;;;-1:-1:-1;;;;;;2443:17:16;;;;;;2476:40;;2426:6;;;;;;;2476:40;;2407:16;2476:40;2396:128;2333:191;:::o;1870:118:17:-;1117:4;1141:7;-1:-1:-1;;;1141:7:17;;;;1395:9;1387:38;;;;-1:-1:-1;;;1387:38:17;;;;;;;:::i;:::-;1930:7:::1;:14:::0;;-1:-1:-1;;;;1930:14:17::1;-1:-1:-1::0;;;1930:14:17::1;::::0;;1960:20:::1;1967:12;682:10:3::0;;602:98;3212:716:19;3636:23;3662:69;3690:4;3662:69;;;;;;;;;;;;;;;;;3670:5;-1:-1:-1;;;;;3662:27:19;;;:69;;;;;:::i;:::-;3746:17;;3636:95;;-1:-1:-1;3746:21:19;3742:179;;3843:10;3832:30;;;;;;;;;;;;:::i;:::-;3824:85;;;;-1:-1:-1;;;3824:85:19;;18719:2:22;3824:85:19;;;18701:21:22;18758:2;18738:18;;;18731:30;18797:34;18777:18;;;18770:62;-1:-1:-1;;;18848:18:22;;;18841:40;18898:19;;3824:85:19;18517:406:22;3549:229:1;3686:12;3718:52;3740:6;3748:4;3754:1;3757:12;3718:21;:52::i;:::-;3711:59;;3549:229;;;;;;:::o;4669:510::-;4839:12;4897:5;4872:21;:30;;4864:81;;;;-1:-1:-1;;;4864:81:1;;19130:2:22;4864:81:1;;;19112:21:22;19169:2;19149:18;;;19142:30;19208:34;19188:18;;;19181:62;-1:-1:-1;;;19259:18:22;;;19252:36;19305:19;;4864:81:1;18928:402:22;4864:81:1;1066:20;;4956:60;;;;-1:-1:-1;;;4956:60:1;;19537:2:22;4956:60:1;;;19519:21:22;19576:2;19556:18;;;19549:30;19615:31;19595:18;;;19588:59;19664:18;;4956:60:1;19335:353:22;4956:60:1;5030:12;5044:23;5071:6;-1:-1:-1;;;;;5071:11:1;5090:5;5097:4;5071:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5029:73;;;;5120:51;5137:7;5146:10;5158:12;5120:16;:51::i;:::-;5113:58;4669:510;-1:-1:-1;;;;;;;4669:510:1:o;7355:712::-;7505:12;7534:7;7530:530;;;-1:-1:-1;7565:10:1;7558:17;;7530:530;7679:17;;:21;7675:374;;7877:10;7871:17;7938:15;7925:10;7921:2;7917:19;7910:44;7675:374;8020:12;8013:20;;-1:-1:-1;;;8013:20:1;;;;;;;;:::i;14:131:22:-;-1:-1:-1;;;;;89:31:22;;79:42;;69:70;;135:1;132;125:12;150:247;209:6;262:2;250:9;241:7;237:23;233:32;230:52;;;278:1;275;268:12;230:52;317:9;304:23;336:31;361:5;336:31;:::i;918:180::-;977:6;1030:2;1018:9;1009:7;1005:23;1001:32;998:52;;;1046:1;1043;1036:12;998:52;-1:-1:-1;1069:23:22;;918:180;-1:-1:-1;918:180:22:o;1285:315::-;1353:6;1361;1414:2;1402:9;1393:7;1389:23;1385:32;1382:52;;;1430:1;1427;1420:12;1382:52;1469:9;1456:23;1488:31;1513:5;1488:31;:::i;:::-;1538:5;1590:2;1575:18;;;;1562:32;;-1:-1:-1;;;1285:315:22:o;2958:356::-;3160:2;3142:21;;;3179:18;;;3172:30;3238:34;3233:2;3218:18;;3211:62;3305:2;3290:18;;2958:356::o;4853:355::-;5055:2;5037:21;;;5094:2;5074:18;;;5067:30;5133:33;5128:2;5113:18;;5106:61;5199:2;5184:18;;4853:355::o;5561:184::-;5631:6;5684:2;5672:9;5663:7;5659:23;5655:32;5652:52;;;5700:1;5697;5690:12;5652:52;-1:-1:-1;5723:16:22;;5561:184;-1:-1:-1;5561:184:22:o;6110:127::-;6171:10;6166:3;6162:20;6159:1;6152:31;6202:4;6199:1;6192:15;6226:4;6223:1;6216:15;6242:168;6282:7;6348:1;6344;6340:6;6336:14;6333:1;6330:21;6325:1;6318:9;6311:17;6307:45;6304:71;;;6355:18;;:::i;:::-;-1:-1:-1;6395:9:22;;6242:168::o;6415:217::-;6455:1;6481;6471:132;;6525:10;6520:3;6516:20;6513:1;6506:31;6560:4;6557:1;6550:15;6588:4;6585:1;6578:15;6471:132;-1:-1:-1;6617:9:22;;6415:217::o;6916:125::-;6956:4;6984:1;6981;6978:8;6975:34;;;6989:18;;:::i;:::-;-1:-1:-1;7026:9:22;;6916:125::o;7299:128::-;7339:3;7370:1;7366:6;7363:1;7360:13;7357:39;;;7376:18;;:::i;:::-;-1:-1:-1;7412:9:22;;7299:128::o;8061:127::-;8122:10;8117:3;8113:20;8110:1;8103:31;8153:4;8150:1;8143:15;8177:4;8174:1;8167:15;8193:275;8264:2;8258:9;8329:2;8310:13;;-1:-1:-1;;8306:27:22;8294:40;;8364:18;8349:34;;8385:22;;;8346:62;8343:88;;;8411:18;;:::i;:::-;8447:2;8440:22;8193:275;;-1:-1:-1;8193:275:22:o;8473:183::-;8533:4;8566:18;8558:6;8555:30;8552:56;;;8588:18;;:::i;:::-;-1:-1:-1;8633:1:22;8629:14;8645:4;8625:25;;8473:183::o;8661:258::-;8733:1;8743:113;8757:6;8754:1;8751:13;8743:113;;;8833:11;;;8827:18;8814:11;;;8807:39;8779:2;8772:10;8743:113;;;8874:6;8871:1;8868:13;8865:48;;;-1:-1:-1;;8909:1:22;8891:16;;8884:27;8661:258::o;8924:1490::-;8988:5;9018:4;9062:3;9057:2;9049:6;9045:15;9041:25;9031:53;;9080:1;9077;9070:12;9031:53;9109:6;9103:13;9135:4;9159:60;9175:43;9215:2;9175:43;:::i;:::-;9159:60;:::i;:::-;9253:15;;;9339:1;9335:10;;;;9323:23;;9319:32;;;9284:12;;;;9363:15;;;9360:35;;;9391:1;9388;9381:12;9360:35;9427:2;9419:6;9415:15;9439:946;9455:6;9450:3;9447:15;9439:946;;;9534:3;9528:10;9561:18;9611:2;9598:11;9595:19;9592:109;;;9655:1;9684:2;9680;9673:14;9592:109;9736:11;9728:6;9724:24;9714:34;;9788:3;9783:2;9779;9775:11;9771:21;9761:119;;9834:1;9863:2;9859;9852:14;9761:119;9917:2;9913;9909:11;9903:18;9944:2;9969;9965;9962:10;9959:36;;;9975:18;;:::i;:::-;10023:51;10047:11;;;-1:-1:-1;;10043:25:22;10039:34;;10023:51;:::i;:::-;10008:66;;10103:2;10094:7;10087:19;10147:3;10142:2;10137;10133;10129:11;10125:20;10122:29;10119:122;;;10193:1;10223:3;10218;10211:16;10119:122;10254:56;10307:2;10302;10293:7;10289:16;10284:2;10280;10276:11;10254:56;:::i;:::-;-1:-1:-1;;10323:20:22;;-1:-1:-1;10363:12:22;;;;9472;;9439:946;;;-1:-1:-1;10403:5:22;8924:1490;-1:-1:-1;;;;;;;8924:1490:22:o;10419:659::-;10484:5;10537:3;10530:4;10522:6;10518:17;10514:27;10504:55;;10555:1;10552;10545:12;10504:55;10584:6;10578:13;10610:4;10634:60;10650:43;10690:2;10650:43;:::i;10634:60::-;10728:15;;;10814:1;10810:10;;;;10798:23;;10794:32;;;10759:12;;;;10838:15;;;10835:35;;;10866:1;10863;10856:12;10835:35;10902:2;10894:6;10890:15;10914:135;10930:6;10925:3;10922:15;10914:135;;;10996:10;;10984:23;;11027:12;;;;10947;;10914:135;;;-1:-1:-1;11067:5:22;10419:659;-1:-1:-1;;;;;;10419:659:22:o;11083:1679::-;11290:6;11298;11306;11314;11367:3;11355:9;11346:7;11342:23;11338:33;11335:53;;;11384:1;11381;11374:12;11335:53;11417:9;11411:16;11446:18;11487:2;11479:6;11476:14;11473:34;;;11503:1;11500;11493:12;11473:34;11541:6;11530:9;11526:22;11516:32;;11586:7;11579:4;11575:2;11571:13;11567:27;11557:55;;11608:1;11605;11598:12;11557:55;11637:2;11631:9;11659:4;11683:60;11699:43;11739:2;11699:43;:::i;11683:60::-;11777:15;;;11859:1;11855:10;;;;11847:19;;11843:28;;;11808:12;;;;11883:19;;;11880:39;;;11915:1;11912;11905:12;11880:39;11939:11;;;;11959:210;11975:6;11970:3;11967:15;11959:210;;;12048:3;12042:10;12065:31;12090:5;12065:31;:::i;:::-;12109:18;;11992:12;;;;12147;;;;11959:210;;;12224:18;;;12218:25;12188:5;;-1:-1:-1;12218:25:22;;-1:-1:-1;;;12255:16:22;;;12252:36;;;12284:1;12281;12274:12;12252:36;12307:73;12372:7;12361:8;12350:9;12346:24;12307:73;:::i;:::-;12297:83;;12426:2;12415:9;12411:18;12405:25;12389:41;;12455:2;12445:8;12442:16;12439:36;;;12471:1;12468;12461:12;12439:36;12494:74;12560:7;12549:8;12538:9;12534:24;12494:74;:::i;:::-;12484:84;;12614:2;12603:9;12599:18;12593:25;12577:41;;12643:2;12633:8;12630:16;12627:36;;;12659:1;12656;12649:12;12627:36;;12682:74;12748:7;12737:8;12726:9;12722:24;12682:74;:::i;:::-;12672:84;;;11083:1679;;;;;;;:::o;12767:127::-;12828:10;12823:3;12819:20;12816:1;12809:31;12859:4;12856:1;12849:15;12883:4;12880:1;12873:15;13307:340;13509:2;13491:21;;;13548:2;13528:18;;;13521:30;-1:-1:-1;;;13582:2:22;13567:18;;13560:46;13638:2;13623:18;;13307:340::o;15557:430::-;15663:6;15671;15679;15687;15695;15748:3;15736:9;15727:7;15723:23;15719:33;15716:53;;;15765:1;15762;15755:12;15716:53;-1:-1:-1;;15788:16:22;;15844:2;15829:18;;15823:25;15888:2;15873:18;;15867:25;15932:2;15917:18;;15911:25;15976:3;15961:19;;;15955:26;15788:16;;15823:25;;-1:-1:-1;15867:25:22;15911;-1:-1:-1;15955:26:22;;-1:-1:-1;15557:430:22;-1:-1:-1;15557:430:22:o;18235:277::-;18302:6;18355:2;18343:9;18334:7;18330:23;18326:32;18323:52;;;18371:1;18368;18361:12;18323:52;18403:9;18397:16;18456:5;18449:13;18442:21;18435:5;18432:32;18422:60;;18478:1;18475;18468:12;19693:274;19822:3;19860:6;19854:13;19876:53;19922:6;19917:3;19910:4;19902:6;19898:17;19876:53;:::i;:::-;19945:16;;;;;19693:274;-1:-1:-1;;19693:274:22:o;19972:383::-;20121:2;20110:9;20103:21;20084:4;20153:6;20147:13;20196:6;20191:2;20180:9;20176:18;20169:34;20212:66;20271:6;20266:2;20255:9;20251:18;20246:2;20238:6;20234:15;20212:66;:::i;:::-;20339:2;20318:15;-1:-1:-1;;20314:29:22;20299:45;;;;20346:2;20295:54;;19972:383;-1:-1:-1;;19972:383:22:o

ipfs://1aef0eddcf5c321a87730dccbe9c6d99f17a83aa6c81d8b5069054634017a1b2