Contract 0xffb51354e80a2dac1caa8f5cda934ed9c1938470

/**
 *Submitted for verification at FTMScan.com on 2022-07-10
*/

pragma solidity 0.8.13;


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

        return account.code.length > 0;
    }

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

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

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

// 
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol)
/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
        // contract may have been reentered.
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} modifier, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}

// 
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

// 
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
    /**
     * @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);
}

// 
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// 
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)
/**
 * @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 ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
    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.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        _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 Spend `amount` form the allowance of `owner` toward `spender`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[45] private __gap;
}

// 
// OpenZeppelin Contracts v4.4.1 (access/Ownable.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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _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);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// 
contract xHNR is Initializable, ERC20Upgradeable, OwnableUpgradeable {
  function initialize() external initializer {
    __ERC20_init("xHonour", "xHNR");
    OwnableUpgradeable.__Ownable_init();
  }

  function mint(uint256 amount) external onlyOwner {
    _mint(owner(), amount);
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405234801561001057600080fd5b50610ede806100206000396000f3fe608060405234801561001057600080fd5b50600436106101005760003560e01c80638129fc1c11610097578063a457c2d711610066578063a457c2d7146101fe578063a9059cbb14610211578063dd62ed3e14610224578063f2fde38b1461025d57600080fd5b80638129fc1c146101c05780638da5cb5b146101c857806395d89b41146101e3578063a0712d68146101eb57600080fd5b8063313ce567116100d3578063313ce5671461016b578063395093511461017a57806370a082311461018d578063715018a6146101b657600080fd5b806306fdde0314610105578063095ea7b31461012357806318160ddd1461014657806323b872dd14610158575b600080fd5b61010d610270565b60405161011a9190610c83565b60405180910390f35b610136610131366004610cf4565b610302565b604051901515815260200161011a565b6035545b60405190815260200161011a565b610136610166366004610d1e565b61031a565b6040516012815260200161011a565b610136610188366004610cf4565b61033e565b61014a61019b366004610d5a565b6001600160a01b031660009081526033602052604090205490565b6101be61037d565b005b6101be6103bc565b6065546040516001600160a01b03909116815260200161011a565b61010d6104c2565b6101be6101f9366004610d7c565b6104d1565b61013661020c366004610cf4565b610516565b61013661021f366004610cf4565b6105a8565b61014a610232366004610d95565b6001600160a01b03918216600090815260346020908152604080832093909416825291909152205490565b6101be61026b366004610d5a565b6105b6565b60606036805461027f90610dc8565b80601f01602080910402602001604051908101604052809291908181526020018280546102ab90610dc8565b80156102f85780601f106102cd576101008083540402835291602001916102f8565b820191906000526020600020905b8154815290600101906020018083116102db57829003601f168201915b5050505050905090565b60003361031081858561064e565b5060019392505050565b600033610328858285610772565b610333858585610804565b506001949350505050565b3360008181526034602090815260408083206001600160a01b03871684529091528120549091906103109082908690610378908790610e02565b61064e565b6065546001600160a01b031633146103b05760405162461bcd60e51b81526004016103a790610e28565b60405180910390fd5b6103ba60006109d2565b565b600054610100900460ff166103d75760005460ff16156103db565b303b155b61043e5760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084016103a7565b600054610100900460ff16158015610460576000805461ffff19166101011790555b6104a5604051806040016040528060078152602001663c2437b737bab960c91b815250604051806040016040528060048152602001633c24272960e11b815250610a24565b6104ad610a59565b80156104bf576000805461ff00191690555b50565b60606037805461027f90610dc8565b6065546001600160a01b031633146104fb5760405162461bcd60e51b81526004016103a790610e28565b6104bf6105106065546001600160a01b031690565b82610a88565b3360008181526034602090815260408083206001600160a01b03871684529091528120549091908381101561059b5760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b60648201526084016103a7565b610333828686840361064e565b600033610310818585610804565b6065546001600160a01b031633146105e05760405162461bcd60e51b81526004016103a790610e28565b6001600160a01b0381166106455760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016103a7565b6104bf816109d2565b6001600160a01b0383166106b05760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b60648201526084016103a7565b6001600160a01b0382166107115760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b60648201526084016103a7565b6001600160a01b0383811660008181526034602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b0383811660009081526034602090815260408083209386168352929052205460001981146107fe57818110156107f15760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016103a7565b6107fe848484840361064e565b50505050565b6001600160a01b0383166108685760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b60648201526084016103a7565b6001600160a01b0382166108ca5760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b60648201526084016103a7565b6001600160a01b038316600090815260336020526040902054818110156109425760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b60648201526084016103a7565b6001600160a01b03808516600090815260336020526040808220858503905591851681529081208054849290610979908490610e02565b92505081905550826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516109c591815260200190565b60405180910390a36107fe565b606580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600054610100900460ff16610a4b5760405162461bcd60e51b81526004016103a790610e5d565b610a558282610b6c565b5050565b600054610100900460ff16610a805760405162461bcd60e51b81526004016103a790610e5d565b6103ba610bba565b6001600160a01b038216610ade5760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064016103a7565b8060356000828254610af09190610e02565b90915550506001600160a01b03821660009081526033602052604081208054839290610b1d908490610e02565b90915550506040518181526001600160a01b038316906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200160405180910390a35050565b505050565b600054610100900460ff16610b935760405162461bcd60e51b81526004016103a790610e5d565b8151610ba6906036906020850190610bea565b508051610b67906037906020840190610bea565b600054610100900460ff16610be15760405162461bcd60e51b81526004016103a790610e5d565b6103ba336109d2565b828054610bf690610dc8565b90600052602060002090601f016020900481019282610c185760008555610c5e565b82601f10610c3157805160ff1916838001178555610c5e565b82800160010185558215610c5e579182015b82811115610c5e578251825591602001919060010190610c43565b50610c6a929150610c6e565b5090565b5b80821115610c6a5760008155600101610c6f565b600060208083528351808285015260005b81811015610cb057858101830151858201604001528201610c94565b81811115610cc2576000604083870101525b50601f01601f1916929092016040019392505050565b80356001600160a01b0381168114610cef57600080fd5b919050565b60008060408385031215610d0757600080fd5b610d1083610cd8565b946020939093013593505050565b600080600060608486031215610d3357600080fd5b610d3c84610cd8565b9250610d4a60208501610cd8565b9150604084013590509250925092565b600060208284031215610d6c57600080fd5b610d7582610cd8565b9392505050565b600060208284031215610d8e57600080fd5b5035919050565b60008060408385031215610da857600080fd5b610db183610cd8565b9150610dbf60208401610cd8565b90509250929050565b600181811c90821680610ddc57607f821691505b602082108103610dfc57634e487b7160e01b600052602260045260246000fd5b50919050565b60008219821115610e2357634e487b7160e01b600052601160045260246000fd5b500190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b60608201526080019056fea26469706673582212208c623cb114a153ba31dcc892ad290f75dc168f264d3576095a00dde4c60d5df964736f6c634300080d0033

31716:296:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17683:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20034:201;;;;;;:::i;:::-;;:::i;:::-;;;1218:14:1;;1211:22;1193:41;;1181:2;1166:18;20034:201:0;1053:187:1;18803:108:0;18891:12;;18803:108;;;1391:25:1;;;1379:2;1364:18;18803:108:0;1245:177:1;20815:295:0;;;;;;:::i;:::-;;:::i;18645:93::-;;;18728:2;1902:36:1;;1890:2;1875:18;18645:93:0;1760:184:1;21519:240:0;;;;;;:::i;:::-;;:::i;18974:127::-;;;;;;:::i;:::-;-1:-1:-1;;;;;19075:18:0;19048:7;19075:18;;;:9;:18;;;;;;;18974:127;30596:103;;;:::i;:::-;;31790:129;;;:::i;29945:87::-;30018:6;;29945:87;;-1:-1:-1;;;;;30018:6:0;;;2286:51:1;;2274:2;2259:18;29945:87:0;2140:203:1;17902:104:0;;;:::i;31925:84::-;;;;;;:::i;:::-;;:::i;22262:438::-;;;;;;:::i;:::-;;:::i;19307:193::-;;;;;;:::i;:::-;;:::i;19563:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;19679:18:0;;;19652:7;19679:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19563:151;30854:201;;;;;;:::i;:::-;;:::i;17683:100::-;17737:13;17770:5;17763:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17683:100;:::o;20034:201::-;20117:4;14933:10;20173:32;14933:10;20189:7;20198:6;20173:8;:32::i;:::-;-1:-1:-1;20223:4:0;;20034:201;-1:-1:-1;;;20034:201:0:o;20815:295::-;20946:4;14933:10;21004:38;21020:4;14933:10;21035:6;21004:15;:38::i;:::-;21053:27;21063:4;21069:2;21073:6;21053:9;:27::i;:::-;-1:-1:-1;21098:4:0;;20815:295;-1:-1:-1;;;;20815:295:0:o;21519:240::-;14933:10;21607:4;21688:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;21688:27:0;;;;;;;;;;21607:4;;14933:10;21663:66;;14933:10;;21688:27;;:40;;21718:10;;21688:40;:::i;:::-;21663:8;:66::i;30596:103::-;30018:6;;-1:-1:-1;;;;;30018:6:0;14933:10;30165:23;30157:68;;;;-1:-1:-1;;;30157:68:0;;;;;;;:::i;:::-;;;;;;;;;30661:30:::1;30688:1;30661:18;:30::i;:::-;30596:103::o:0;31790:129::-;9802:13;;;;;;;:48;;9838:12;;;;9837:13;9802:48;;;10605:4;1488:19;:23;9818:16;9794:107;;;;-1:-1:-1;;;9794:107:0;;3976:2:1;9794:107:0;;;3958:21:1;4015:2;3995:18;;;3988:30;4054:34;4034:18;;;4027:62;-1:-1:-1;;;4105:18:1;;;4098:44;4159:19;;9794:107:0;3774:410:1;9794:107:0;9914:19;9937:13;;;;;;9936:14;9961:101;;;;9996:13;:20;;-1:-1:-1;;10031:19:0;;;;;9961:101;31840:31:::1;;;;;;;;;;;;;;-1:-1:-1::0;;;31840:31:0::1;;::::0;::::1;;;;;;;;;;;;;-1:-1:-1::0;;;31840:31:0::1;;::::0;:12:::1;:31::i;:::-;31878:35;:33;:35::i;:::-;10092:14:::0;10088:68;;;10139:5;10123:21;;-1:-1:-1;;10123:21:0;;;10088:68;9509:654;31790:129::o;17902:104::-;17958:13;17991:7;17984:14;;;;;:::i;31925:84::-;30018:6;;-1:-1:-1;;;;;30018:6:0;14933:10;30165:23;30157:68;;;;-1:-1:-1;;;30157:68:0;;;;;;;:::i;:::-;31981:22:::1;31987:7;30018:6:::0;;-1:-1:-1;;;;;30018:6:0;;29945:87;31987:7:::1;31996:6;31981:5;:22::i;22262:438::-:0;14933:10;22355:4;22438:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;22438:27:0;;;;;;;;;;22355:4;;14933:10;22484:35;;;;22476:85;;;;-1:-1:-1;;;22476:85:0;;4391:2:1;22476:85:0;;;4373:21:1;4430:2;4410:18;;;4403:30;4469:34;4449:18;;;4442:62;-1:-1:-1;;;4520:18:1;;;4513:35;4565:19;;22476:85:0;4189:401:1;22476:85:0;22597:60;22606:5;22613:7;22641:15;22622:16;:34;22597:8;:60::i;19307:193::-;19386:4;14933:10;19442:28;14933:10;19459:2;19463:6;19442:9;:28::i;30854:201::-;30018:6;;-1:-1:-1;;;;;30018:6:0;14933:10;30165:23;30157:68;;;;-1:-1:-1;;;30157:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;30943:22:0;::::1;30935:73;;;::::0;-1:-1:-1;;;30935:73:0;;4797:2:1;30935:73:0::1;::::0;::::1;4779:21:1::0;4836:2;4816:18;;;4809:30;4875:34;4855:18;;;4848:62;-1:-1:-1;;;4926:18:1;;;4919:36;4972:19;;30935:73:0::1;4595:402:1::0;30935:73:0::1;31019:28;31038:8;31019:18;:28::i;25898:380::-:0;-1:-1:-1;;;;;26034:19:0;;26026:68;;;;-1:-1:-1;;;26026:68:0;;5204:2:1;26026:68:0;;;5186:21:1;5243:2;5223:18;;;5216:30;5282:34;5262:18;;;5255:62;-1:-1:-1;;;5333:18:1;;;5326:34;5377:19;;26026:68:0;5002:400:1;26026:68:0;-1:-1:-1;;;;;26113:21:0;;26105:68;;;;-1:-1:-1;;;26105:68:0;;5609:2:1;26105:68:0;;;5591:21:1;5648:2;5628:18;;;5621:30;5687:34;5667:18;;;5660:62;-1:-1:-1;;;5738:18:1;;;5731:32;5780:19;;26105:68:0;5407:398:1;26105:68:0;-1:-1:-1;;;;;26186:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;26238:32;;1391:25:1;;;26238:32:0;;1364:18:1;26238:32:0;;;;;;;25898:380;;;:::o;26565:453::-;-1:-1:-1;;;;;19679:18:0;;;26700:24;19679:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;26767:37:0;;26763:248;;26849:6;26829:16;:26;;26821:68;;;;-1:-1:-1;;;26821:68:0;;6012:2:1;26821:68:0;;;5994:21:1;6051:2;6031:18;;;6024:30;6090:31;6070:18;;;6063:59;6139:18;;26821:68:0;5810:353:1;26821:68:0;26933:51;26942:5;26949:7;26977:6;26958:16;:25;26933:8;:51::i;:::-;26689:329;26565:453;;;:::o;23179:671::-;-1:-1:-1;;;;;23310:18:0;;23302:68;;;;-1:-1:-1;;;23302:68:0;;6370:2:1;23302:68:0;;;6352:21:1;6409:2;6389:18;;;6382:30;6448:34;6428:18;;;6421:62;-1:-1:-1;;;6499:18:1;;;6492:35;6544:19;;23302:68:0;6168:401:1;23302:68:0;-1:-1:-1;;;;;23389:16:0;;23381:64;;;;-1:-1:-1;;;23381:64:0;;6776:2:1;23381:64:0;;;6758:21:1;6815:2;6795:18;;;6788:30;6854:34;6834:18;;;6827:62;-1:-1:-1;;;6905:18:1;;;6898:33;6948:19;;23381:64:0;6574:399:1;23381:64:0;-1:-1:-1;;;;;23531:15:0;;23509:19;23531:15;;;:9;:15;;;;;;23565:21;;;;23557:72;;;;-1:-1:-1;;;23557:72:0;;7180:2:1;23557:72:0;;;7162:21:1;7219:2;7199:18;;;7192:30;7258:34;7238:18;;;7231:62;-1:-1:-1;;;7309:18:1;;;7302:36;7355:19;;23557:72:0;6978:402:1;23557:72:0;-1:-1:-1;;;;;23665:15:0;;;;;;;:9;:15;;;;;;23683:20;;;23665:38;;23725:13;;;;;;;;:23;;23697:6;;23665:15;23725:23;;23697:6;;23725:23;:::i;:::-;;;;;;;;23781:2;-1:-1:-1;;;;;23766:26:0;23775:4;-1:-1:-1;;;;;23766:26:0;;23785:6;23766:26;;;;1391:25:1;;1379:2;1364:18;;1245:177;23766:26:0;;;;;;;;23805:37;27618:125;31215:191;31308:6;;;-1:-1:-1;;;;;31325:17:0;;;-1:-1:-1;;;;;;31325:17:0;;;;;;;31358:40;;31308:6;;;31325:17;31308:6;;31358:40;;31289:16;;31358:40;31278:128;31215:191;:::o;17294:149::-;10405:13;;;;;;;10397:69;;;;-1:-1:-1;;;10397:69:0;;;;;;;:::i;:::-;17397:38:::1;17420:5;17427:7;17397:22;:38::i;:::-;17294:149:::0;;:::o;29646:97::-;10405:13;;;;;;;10397:69;;;;-1:-1:-1;;;10397:69:0;;;;;;;:::i;:::-;29709:26:::1;:24;:26::i;24137:399::-:0;-1:-1:-1;;;;;24221:21:0;;24213:65;;;;-1:-1:-1;;;24213:65:0;;7999:2:1;24213:65:0;;;7981:21:1;8038:2;8018:18;;;8011:30;8077:33;8057:18;;;8050:61;8128:18;;24213:65:0;7797:355:1;24213:65:0;24369:6;24353:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;24386:18:0;;;;;;:9;:18;;;;;:28;;24408:6;;24386:18;:28;;24408:6;;24386:28;:::i;:::-;;;;-1:-1:-1;;24430:37:0;;1391:25:1;;;-1:-1:-1;;;;;24430:37:0;;;24447:1;;24430:37;;1379:2:1;1364:18;24430:37:0;;;;;;;17294:149;;:::o;27618:125::-;;;;:::o;17451:162::-;10405:13;;;;;;;10397:69;;;;-1:-1:-1;;;10397:69:0;;;;;;;:::i;:::-;17564:13;;::::1;::::0;:5:::1;::::0;:13:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;17588:17:0;;::::1;::::0;:7:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;29751:113::-:0;10405:13;;;;;;;10397:69;;;;-1:-1:-1;;;10397:69:0;;;;;;;:::i;:::-;29824:32:::1;14933:10:::0;29824:18:::1;:32::i;-1:-1:-1:-:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:597:1;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;616:173::-;684:20;;-1:-1:-1;;;;;733:31:1;;723:42;;713:70;;779:1;776;769:12;713:70;616:173;;;:::o;794:254::-;862:6;870;923:2;911:9;902:7;898:23;894:32;891:52;;;939:1;936;929:12;891:52;962:29;981:9;962:29;:::i;:::-;952:39;1038:2;1023:18;;;;1010:32;;-1:-1:-1;;;794:254:1:o;1427:328::-;1504:6;1512;1520;1573:2;1561:9;1552:7;1548:23;1544:32;1541:52;;;1589:1;1586;1579:12;1541:52;1612:29;1631:9;1612:29;:::i;:::-;1602:39;;1660:38;1694:2;1683:9;1679:18;1660:38;:::i;:::-;1650:48;;1745:2;1734:9;1730:18;1717:32;1707:42;;1427:328;;;;;:::o;1949:186::-;2008:6;2061:2;2049:9;2040:7;2036:23;2032:32;2029:52;;;2077:1;2074;2067:12;2029:52;2100:29;2119:9;2100:29;:::i;:::-;2090:39;1949:186;-1:-1:-1;;;1949:186:1:o;2348:180::-;2407:6;2460:2;2448:9;2439:7;2435:23;2431:32;2428:52;;;2476:1;2473;2466:12;2428:52;-1:-1:-1;2499:23:1;;2348:180;-1:-1:-1;2348:180:1:o;2533:260::-;2601:6;2609;2662:2;2650:9;2641:7;2637:23;2633:32;2630:52;;;2678:1;2675;2668:12;2630:52;2701:29;2720:9;2701:29;:::i;:::-;2691:39;;2749:38;2783:2;2772:9;2768:18;2749:38;:::i;:::-;2739:48;;2533:260;;;;;:::o;2798:380::-;2877:1;2873:12;;;;2920;;;2941:61;;2995:4;2987:6;2983:17;2973:27;;2941:61;3048:2;3040:6;3037:14;3017:18;3014:38;3011:161;;3094:10;3089:3;3085:20;3082:1;3075:31;3129:4;3126:1;3119:15;3157:4;3154:1;3147:15;3011:161;;2798:380;;;:::o;3183:225::-;3223:3;3254:1;3250:6;3247:1;3244:13;3241:136;;;3299:10;3294:3;3290:20;3287:1;3280:31;3334:4;3331:1;3324:15;3362:4;3359:1;3352:15;3241:136;-1:-1:-1;3393:9:1;;3183:225::o;3413:356::-;3615:2;3597:21;;;3634:18;;;3627:30;3693:34;3688:2;3673:18;;3666:62;3760:2;3745:18;;3413:356::o;7385:407::-;7587:2;7569:21;;;7626:2;7606:18;;;7599:30;7665:34;7660:2;7645:18;;7638:62;-1:-1:-1;;;7731:2:1;7716:18;;7709:41;7782:3;7767:19;;7385:407::o

ipfs://8c623cb114a153ba31dcc892ad290f75dc168f264d3576095a00dde4c60d5df9