Contract 0xCd426834D733e5B4bFFC89D3f21FA7e16D0Bf583

/**
 *Submitted for verification at snowtrace.io on 2021-12-20
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

//  SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, 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);
}

// File: @openzeppelin/contracts/utils/Context.sol

//

pragma solidity >=0.6.0 <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 GSN 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 payable) {
        return msg.sender;
    }

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

// File: @openzeppelin/contracts/math/SafeMath.sol

//

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

//

pragma solidity >=0.6.0 <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 guidelines: functions revert instead
 * of 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 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

    /**
     * @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);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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].add(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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(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:
     *
     * - `to` 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 = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(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);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @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 to 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 { }
}

// File: @openzeppelin/contracts/token/ERC20/ERC20Burnable.sol

//

pragma solidity >=0.6.0 <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 {
    using SafeMath for uint256;

    /**
     * @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 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }
}

// File: @openzeppelin/contracts/utils/Address.sol

//

pragma solidity >=0.6.2 <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;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

//

pragma solidity >=0.6.0 <0.8.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    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'
        // solhint-disable-next-line max-line-length
        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).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol

//

pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Pausable.sol

//

pragma solidity >=0.6.0 <0.8.0;


/**
 * @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 () internal {
        _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());
    }
}

// File: @openzeppelin/contracts/math/Math.sol

//

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// File: contracts/ECDSA.sol

//

pragma solidity ^0.6.0;

// A copy from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/files

/**
 * @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 {
  /**
   * @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) {
    // Check the signature length
    if (signature.length != 65) {
      revert("ECDSA: invalid signature length");
    }

    // Divide the signature in r, s and v variables
    bytes32 r;
    bytes32 s;
    uint8 v;

    // ecrecover takes the signature parameters, and the only way to get them
    // currently is to use assembly.
    // solhint-disable-next-line no-inline-assembly
    assembly {
      r := mload(add(signature, 0x20))
      s := mload(add(signature, 0x40))
      v := mload(add(signature, 0x41))
    }

    return recover(hash, v, r, s);
  }

  /**
   * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,
   * `r` and `s` signature fields separately.
   */
  function recover(
    bytes32 hash,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) internal pure returns (address) {
    // 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 (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): 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.
    require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
    require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");

    // If the signature is valid (and not malleable), return the signer address
    address signer = ecrecover(hash, v, r, s);
    require(signer != address(0), "ECDSA: invalid signature");

    return signer;
  }

  /**
   * @dev Returns an Ethereum Signed Message, created from a `hash`. This
   * replicates the behavior of the
   * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
   * JSON-RPC method.
   *
   * 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));
  }
}

// File: contracts/ERC20Permit.sol

//

pragma solidity ^0.6.0;

// Adapted copy from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/files



/**
 * @dev Extension of {ERC20} that allows token holders to use their tokens
 * without sending any transactions by setting {IERC20-allowance} with a
 * signature using the {permit} method, and then spend them via
 * {IERC20-transferFrom}.
 *
 * The {permit} signature mechanism conforms to the {IERC2612Permit} interface.
 */
abstract contract ERC20Permit is ERC20 {
  mapping(address => uint256) private _nonces;

  bytes32 private constant _PERMIT_TYPEHASH = keccak256(
    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
  );

  // Mapping of ChainID to domain separators. This is a very gas efficient way
  // to not recalculate the domain separator on every call, while still
  // automatically detecting ChainID changes.
  mapping(uint256 => bytes32) private _domainSeparators;

  constructor() internal {
    _updateDomainSeparator();
  }

  /**
   * @dev See {IERC2612Permit-permit}.
   *
   * If https://eips.ethereum.org/EIPS/eip-1344[ChainID] ever changes, the
   * EIP712 Domain Separator is automatically recalculated.
   */
  function permit(
    address owner,
    address spender,
    uint256 amount,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) public {
    require(blockTimestamp() <= deadline, "ERC20Permit: expired deadline");

    bytes32 hashStruct = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner], deadline));

    bytes32 hash = keccak256(abi.encodePacked(uint16(0x1901), _domainSeparator(), hashStruct));

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

    _nonces[owner]++;
    _approve(owner, spender, amount);
  }

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

  function _updateDomainSeparator() private returns (bytes32) {
    uint256 _chainID = chainID();

    bytes32 newDomainSeparator = keccak256(
      abi.encode(
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
        keccak256(bytes(name())),
        keccak256(bytes("1")), // Version
        _chainID,
        address(this)
      )
    );

    _domainSeparators[_chainID] = newDomainSeparator;

    return newDomainSeparator;
  }

  // Returns the domain separator, updating it if chainID changes
  function _domainSeparator() private returns (bytes32) {
    bytes32 domainSeparator = _domainSeparators[chainID()];
    if (domainSeparator != 0x00) {
      return domainSeparator;
    } else {
      return _updateDomainSeparator();
    }
  }

  function chainID() public view virtual returns (uint256 _chainID) {
    assembly {
      _chainID := chainid()
    }
  }

  function blockTimestamp() public view virtual returns (uint256) {
    return block.timestamp;
  }
}

// File: contracts/CASH.sol

//

pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;








//import "./ENS.sol";

contract CASH is ERC20("Avacash.Finance", "CASH"), ERC20Burnable, ERC20Permit, Ownable {
  using SafeERC20 for IERC20;

  address public governance;
  bool public distributed;

  event GovernanceTransferred(address indexed previousGovernance, address indexed newGovernance);

  struct Recipient {
    address to;
    uint256 amount;
  }

  constructor(
    address _governance
  ) public {
    governance = _governance;
    emit GovernanceTransferred(address(0), _governance);
  }

  modifier onlyGovernance() {
    require(_msgSender() == governance, "CASH: only governance can perform this action");
    _;
  }

  function initialDistribution(Recipient[] memory _vestings) public onlyOwner {
    require(!distributed, "CASH: distribution can be done only once");

    for (uint256 i = 0; i < _vestings.length; i++) {
      address to = _vestings[i].to;
      _mint(to, _vestings[i].amount);
    }
    distributed = true;
    require(totalSupply() == 1000000 ether, "CASH: incorrect distribution");
  }


  /// @dev Method to claim junk and accidentally sent tokens
  function rescueTokens(
    IERC20 _token,
    address payable _to,
    uint256 _balance
  ) external onlyGovernance {
    require(_to != address(0), "CASH: can not send to zero address");

    if (_token == IERC20(0)) {
      // for Ether
      uint256 totalBalance = address(this).balance;
      uint256 balance = _balance == 0 ? totalBalance : Math.min(totalBalance, _balance);
      _to.transfer(balance);
    } else {
      // any other erc20
      uint256 totalBalance = _token.balanceOf(address(this));
      uint256 balance = _balance == 0 ? totalBalance : Math.min(totalBalance, _balance);
      require(balance > 0, "CASH: trying to send 0 balance");
      _token.safeTransfer(_to, balance);
    }
  }

  /**
   * @dev Transfers governance of the contract to a new account (`newGovernance`).
   * Can only be called by the current governance.
   */
  function transferGovernance(address newGovernance) public virtual onlyGovernance {
      require(newGovernance != address(0), "CASH: new governance is the zero address");
      emit GovernanceTransferred(governance, newGovernance);
      governance = newGovernance;
  }

}

[{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousGovernance","type":"address"},{"indexed":true,"internalType":"address","name":"newGovernance","type":"address"}],"name":"GovernanceTransferred","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":"blockTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"chainID","outputs":[{"internalType":"uint256","name":"_chainID","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":[],"name":"distributed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct CASH.Recipient[]","name":"_vestings","type":"tuple[]"}],"name":"initialDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"address payable","name":"_to","type":"address"},{"internalType":"uint256","name":"_balance","type":"uint256"}],"name":"rescueTokens","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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newGovernance","type":"address"}],"name":"transferGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

47985:2270:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13471:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15617:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;14570:108::-;;;:::i;:::-;;;;;;;:::i;16268:321::-;;;;;;:::i;:::-;;:::i;14414:91::-;;;:::i;:::-;;;;;;;:::i;16998:218::-;;;;;;:::i;:::-;;:::i;22869:91::-;;;;;;:::i;:::-;;:::i;:::-;;48626:396;;;;;;:::i;:::-;;:::i;48110:25::-;;;:::i;:::-;;;;;;;:::i;14741:127::-;;;;;;:::i;:::-;;:::i;37121:148::-;;;:::i;23279:295::-;;;;;;:::i;:::-;;:::i;46681:95::-;;;;;;:::i;:::-;;:::i;36470:87::-;;;:::i;13681:95::-;;;:::i;17719:269::-;;;;;;:::i;:::-;;:::i;15081:175::-;;;;;;:::i;:::-;;:::i;47741:99::-;;;:::i;47611:124::-;;;:::i;49092:729::-;;;;;;:::i;:::-;;:::i;49977:273::-;;;;;;:::i;:::-;;:::i;45977:644::-;;;;;;:::i;:::-;;:::i;15319:151::-;;;;;;:::i;:::-;;:::i;37424:244::-;;;;;;:::i;:::-;;:::i;48140:23::-;;;:::i;13471:91::-;13549:5;13542:12;;;;;;;;-1:-1:-1;;13542:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13516:13;;13542:12;;13549:5;;13542:12;;13549:5;13542:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13471:91;;:::o;15617:169::-;15700:4;15717:39;15726:12;:10;:12::i;:::-;15740:7;15749:6;15717:8;:39::i;:::-;-1:-1:-1;15774:4:0;15617:169;;;;:::o;14570:108::-;14658:12;;14570:108;:::o;16268:321::-;16374:4;16391:36;16401:6;16409:9;16420:6;16391:9;:36::i;:::-;16438:121;16447:6;16455:12;:10;:12::i;:::-;16469:89;16507:6;16469:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16469:19:0;;;;;;:11;:19;;;;;;16489:12;:10;:12::i;:::-;-1:-1:-1;;;;;16469:33:0;;;;;;;;;;;;-1:-1:-1;16469:33:0;;;:89;;:37;:89;:::i;:::-;16438:8;:121::i;:::-;-1:-1:-1;16577:4:0;16268:321;;;;;;:::o;14414:91::-;14488:9;;;;14414:91;:::o;16998:218::-;17086:4;17103:83;17112:12;:10;:12::i;:::-;17126:7;17135:50;17174:10;17135:11;:25;17147:12;:10;:12::i;:::-;-1:-1:-1;;;;;17135:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;17135:25:0;;;:34;;;;;;;;;;;:50;:38;:50;:::i;22869:91::-;22925:27;22931:12;:10;:12::i;:::-;22945:6;22925:5;:27::i;:::-;22869:91;:::o;48626:396::-;36701:12;:10;:12::i;:::-;-1:-1:-1;;;;;36690:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;36690:23:0;;36682:68;;;;-1:-1:-1;;;36682:68:0;;;;;;;:::i;:::-;;;;;;;;;48718:11:::1;::::0;-1:-1:-1;;;48718:11:0;::::1;;;48717:12;48709:65;;;;-1:-1:-1::0;;;48709:65:0::1;;;;;;;:::i;:::-;48788:9;48783:131;48807:9;:16;48803:1;:20;48783:131;;;48839:10;48852:9;48862:1;48852:12;;;;;;;;;;;;;;:15;;;48839:28;;48876:30;48882:2;48886:9;48896:1;48886:12;;;;;;;;;;;;;;:19;;;48876:5;:30::i;:::-;-1:-1:-1::0;48825:3:0::1;;48783:131;;;-1:-1:-1::0;48920:11:0::1;:18:::0;;-1:-1:-1;;;;48920:18:0::1;-1:-1:-1::0;;;48920:18:0::1;::::0;;48953:13:::1;:11;:13::i;:::-;48970;48953:30;48945:71;;;;-1:-1:-1::0;;;48945:71:0::1;;;;;;;:::i;48110:25::-:0;;;-1:-1:-1;;;;;48110:25:0;;:::o;14741:127::-;-1:-1:-1;;;;;14842:18:0;14815:7;14842:18;;;;;;;;;;;;14741:127::o;37121:148::-;36701:12;:10;:12::i;:::-;-1:-1:-1;;;;;36690:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;36690:23:0;;36682:68;;;;-1:-1:-1;;;36682:68:0;;;;;;;:::i;:::-;37212:6:::1;::::0;37191:40:::1;::::0;37228:1:::1;::::0;-1:-1:-1;;;;;37212:6:0::1;::::0;37191:40:::1;::::0;37228:1;;37191:40:::1;37242:6;:19:::0;;-1:-1:-1;;;;;;37242:19:0::1;::::0;;37121:148::o;23279:295::-;23356:26;23385:84;23422:6;23385:84;;;;;;;;;;;;;;;;;:32;23395:7;23404:12;:10;:12::i;23385:32::-;:36;:84;;:36;:84;:::i;:::-;23356:113;;23482:51;23491:7;23500:12;:10;:12::i;:::-;23514:18;23482:8;:51::i;:::-;23544:22;23550:7;23559:6;23544:5;:22::i;:::-;23279:295;;;:::o;46681:95::-;-1:-1:-1;;;;;46756:14:0;46733:7;46756:14;;;:7;:14;;;;;;;46681:95::o;36470:87::-;36543:6;;-1:-1:-1;;;;;36543:6:0;36470:87;:::o;13681:95::-;13761:7;13754:14;;;;;;;;-1:-1:-1;;13754:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13728:13;;13754:14;;13761:7;;13754:14;;13761:7;13754:14;;;;;;;;;;;;;;;;;;;;;;;;17719:269;17812:4;17829:129;17838:12;:10;:12::i;:::-;17852:7;17861:96;17900:15;17861:96;;;;;;;;;;;;;;;;;:11;:25;17873:12;:10;:12::i;:::-;-1:-1:-1;;;;;17861:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;17861:25:0;;;:34;;;;;;;;;;;:96;;:38;:96;:::i;15081:175::-;15167:4;15184:42;15194:12;:10;:12::i;:::-;15208:9;15219:6;15184:9;:42::i;47741:99::-;47819:15;47741:99;:::o;47611:124::-;47714:9;;47693:37::o;49092:729::-;48546:10;;-1:-1:-1;;;;;48546:10:0;48530:12;:10;:12::i;:::-;-1:-1:-1;;;;;48530:26:0;;48522:84;;;;-1:-1:-1;;;48522:84:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49227:17:0;::::1;49219:64;;;;-1:-1:-1::0;;;49219:64:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;49296:19:0;::::1;49292:524;;49369:21;49346:20;49417:13:::0;;:63:::1;;49448:32;49457:12;49471:8;49448;:32::i;:::-;49417:63;;;49433:12;49417:63;49489:21;::::0;49399:81;;-1:-1:-1;;;;;;49489:12:0;::::1;::::0;:21;::::1;;;::::0;49399:81;;49489:21:::1;::::0;;;49399:81;49489:12;:21;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;49292:524;;;;;49582:31;::::0;-1:-1:-1;;;49582:31:0;;49559:20:::1;::::0;-1:-1:-1;;;;;49582:16:0;::::1;::::0;::::1;::::0;:31:::1;::::0;49607:4:::1;::::0;49582:31:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49559:54:::0;-1:-1:-1;49622:15:0::1;49640:13:::0;;:63:::1;;49671:32;49680:12;49694:8;49671;:32::i;:::-;49640:63;;;49656:12;49640:63;49622:81;;49730:1;49720:7;:11;49712:54;;;;-1:-1:-1::0;;;49712:54:0::1;;;;;;;:::i;:::-;49775:33;-1:-1:-1::0;;;;;49775:19:0;::::1;49795:3:::0;49800:7;49775:33:::1;:19;:33;:::i;:::-;49292:524;;49092:729:::0;;;:::o;49977:273::-;48546:10;;-1:-1:-1;;;;;48546:10:0;48530:12;:10;:12::i;:::-;-1:-1:-1;;;;;48530:26:0;;48522:84;;;;-1:-1:-1;;;48522:84:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50075:27:0;::::1;50067:80;;;;-1:-1:-1::0;;;50067:80:0::1;;;;;;;:::i;:::-;50183:10;::::0;50161:48:::1;::::0;-1:-1:-1;;;;;50161:48:0;;::::1;::::0;50183:10:::1;::::0;50161:48:::1;::::0;50183:10:::1;::::0;50161:48:::1;50218:10;:26:::0;;-1:-1:-1;;;;;;50218:26:0::1;-1:-1:-1::0;;;;;50218:26:0;;;::::1;::::0;;;::::1;::::0;;49977:273::o;45977:644::-;46172:8;46152:16;:14;:16::i;:::-;:28;;46144:70;;;;-1:-1:-1;;;46144:70:0;;;;;;;:::i;:::-;46223:18;45342:105;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;;;;46307:14:0;;;;;;:7;:14;;;;;;;;46254:78;;45342:105;;46283:5;;46290:7;;46299:6;;46307:14;;46323:8;;46254:78;;:::i;:::-;;;;;;;;;;;;;46244:89;;;;;;46223:110;;46342:12;46391:6;46400:18;:16;:18::i;:::-;46420:10;46367:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;46357:75;;;;;;46342:90;;46441:14;46458:28;46472:4;46478:1;46481;46484;46458:13;:28::i;:::-;46441:45;;46511:5;-1:-1:-1;;;;;46501:15:0;:6;-1:-1:-1;;;;;46501:15:0;;46493:58;;;;-1:-1:-1;;;46493:58:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46560:14:0;;;;;;:7;:14;;;;;:16;;;;;;46583:32;46568:5;46599:7;46608:6;46583:8;:32::i;:::-;45977:644;;;;;;;;;;:::o;15319:151::-;-1:-1:-1;;;;;15435:18:0;;;15408:7;15435:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15319:151::o;37424:244::-;36701:12;:10;:12::i;:::-;-1:-1:-1;;;;;36690:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;36690:23:0;;36682:68;;;;-1:-1:-1;;;36682:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;37513:22:0;::::1;37505:73;;;;-1:-1:-1::0;;;37505:73:0::1;;;;;;;:::i;:::-;37615:6;::::0;37594:38:::1;::::0;-1:-1:-1;;;;;37594:38:0;;::::1;::::0;37615:6:::1;::::0;37594:38:::1;::::0;37615:6:::1;::::0;37594:38:::1;37643:6;:17:::0;;-1:-1:-1;;;;;;37643:17:0::1;-1:-1:-1::0;;;;;37643:17:0;;;::::1;::::0;;;::::1;::::0;;37424:244::o;48140:23::-;;;-1:-1:-1;;;48140:23:0;;;;;:::o;3481:106::-;3569:10;3481:106;:::o;20866:346::-;-1:-1:-1;;;;;20968:19:0;;20960:68;;;;-1:-1:-1;;;20960:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;21047:21:0;;21039:68;;;;-1:-1:-1;;;21039:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;21120:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;21172:32;;;;;21150:6;;21172:32;:::i;:::-;;;;;;;;20866:346;;;:::o;18478:539::-;-1:-1:-1;;;;;18584:20:0;;18576:70;;;;-1:-1:-1;;;18576:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;18665:23:0;;18657:71;;;;-1:-1:-1;;;18657:71:0;;;;;;;:::i;:::-;18741:47;18762:6;18770:9;18781:6;18741:20;:47::i;:::-;18821:71;18843:6;18821:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18821:17:0;;:9;:17;;;;;;;;;;;;:71;;:21;:71;:::i;:::-;-1:-1:-1;;;;;18801:17:0;;;:9;:17;;;;;;;;;;;:91;;;;18926:20;;;;;;;:32;;18951:6;18926:32;:24;:32;:::i;:::-;-1:-1:-1;;;;;18903:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;18974:35;;;;;;;;;;19002:6;;18974:35;:::i;9461:166::-;9547:7;9583:12;9575:6;;;;9567:29;;;;-1:-1:-1;;;9567:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;9614:5:0;;;9461:166::o;6634:179::-;6692:7;6724:5;;;6748:6;;;;6740:46;;;;-1:-1:-1;;;6740:46:0;;;;;;;:::i;20010:418::-;-1:-1:-1;;;;;20094:21:0;;20086:67;;;;-1:-1:-1;;;20086:67:0;;;;;;;:::i;:::-;20166:49;20187:7;20204:1;20208:6;20166:20;:49::i;:::-;20249:68;20272:6;20249:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20249:18:0;;:9;:18;;;;;;;;;;;;:68;;:22;:68;:::i;:::-;-1:-1:-1;;;;;20228:18:0;;:9;:18;;;;;;;;;;:89;20343:12;;:24;;20360:6;20343:24;:16;:24;:::i;:::-;20328:12;:39;20383:37;;20409:1;;-1:-1:-1;;;;;20383:37:0;;;;;;;20413:6;;20383:37;:::i;:::-;;;;;;;;20010:418;;:::o;19299:378::-;-1:-1:-1;;;;;19383:21:0;;19375:65;;;;-1:-1:-1;;;19375:65:0;;;;;;;:::i;:::-;19453:49;19482:1;19486:7;19495:6;19453:20;:49::i;:::-;19530:12;;:24;;19547:6;19530:24;:16;:24;:::i;:::-;19515:12;:39;-1:-1:-1;;;;;19586:18:0;;:9;:18;;;;;;;;;;;:30;;19609:6;19586:30;:22;:30;:::i;:::-;-1:-1:-1;;;;;19565:18:0;;:9;:18;;;;;;;;;;;:51;;;;19632:37;;19565:18;;:9;19632:37;;;;19662:6;;19632:37;:::i;40390:106::-;40448:7;40479:1;40475;:5;:13;;40487:1;40475:13;;;-1:-1:-1;40483:1:0;;40468:20;-1:-1:-1;40390:106:0:o;32284:177::-;32367:86;32387:5;32417:23;;;32442:2;32446:5;32394:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;32394:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;32394:58:0;-1:-1:-1;;;;;;32394:58:0;;;;;;;;;;32367:19;:86::i;47356:249::-;47401:7;47417:23;47443:17;:28;47461:9;:7;:9::i;:::-;47443:28;;;;;;;;;;;-1:-1:-1;47443:28:0;;;-1:-1:-1;47482:23:0;;47478:122;;47523:15;-1:-1:-1;47516:22:0;;47478:122;47568:24;:22;:24::i;:::-;47561:31;;;;;42784:1395;42894:7;43779:66;43765:80;;;43757:127;;;;-1:-1:-1;;;43757:127:0;;;;;;;:::i;:::-;43899:1;:7;;43904:2;43899:7;:18;;;;43910:1;:7;;43915:2;43910:7;43899:18;43891:65;;;;-1:-1:-1;;;43891:65:0;;;;;;;:::i;:::-;44046:14;44063:24;44073:4;44079:1;44082;44085;44063:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;44063:24:0;;-1:-1:-1;;44063:24:0;;;-1:-1:-1;;;;;;;44102:20:0;;44094:57;;;;-1:-1:-1;;;44094:57:0;;;;;;;:::i;:::-;44167:6;42784:1395;-1:-1:-1;;;;;42784:1395:0:o;7096:158::-;7154:7;7187:1;7182;:6;;7174:49;;;;-1:-1:-1;;;7174:49:0;;;;;;;:::i;:::-;-1:-1:-1;7241:5:0;;;7096:158::o;34589:761::-;35013:23;35039:69;35067:4;35039:69;;;;;;;;;;;;;;;;;35047:5;-1:-1:-1;;;;;35039:27:0;;;:69;;;;;:::i;:::-;35123:17;;35013:95;;-1:-1:-1;35123:21:0;35119:224;;35265:10;35254:30;;;;;;;;;;;;:::i;:::-;35246:85;;;;-1:-1:-1;;;35246:85:0;;;;;;;:::i;46782:501::-;46833:7;46849:16;46868:9;:7;:9::i;:::-;46849:28;;46886:26;46954:95;;;;;:::i;:::-;;;;;;;;47076:6;:4;:6::i;:::-;47060:24;;;;;;;47105:10;;;;;;;;;;;-1:-1:-1;;;47105:10:0;;;;46933:246;;;;47095:21;;47138:8;;47165:4;;46933:246;;:::i;:::-;;;;-1:-1:-1;;46933:246:0;;;;;;;;;46915:271;;46933:246;46915:271;;;;47195:27;;;;:17;:27;;;;;;:48;;;-1:-1:-1;46915:271:0;-1:-1:-1;46782:501:0;:::o;27275:195::-;27378:12;27410:52;27432:6;27440:4;27446:1;27449:12;27410:21;:52::i;:::-;27403:59;27275:195;-1:-1:-1;;;;27275:195:0:o;28327:530::-;28454:12;28512:5;28487:21;:30;;28479:81;;;;-1:-1:-1;;;28479:81:0;;;;;;;:::i;:::-;28579:18;28590:6;28579:10;:18::i;:::-;28571:60;;;;-1:-1:-1;;;28571:60:0;;;;;;;:::i;:::-;28705:12;28719:23;28746:6;-1:-1:-1;;;;;28746:11:0;28766:5;28774:4;28746:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28704:75;;;;28797:52;28815:7;28824:10;28836:12;28797:17;:52::i;:::-;28790:59;28327:530;-1:-1:-1;;;;;;;28327:530:0:o;24357:422::-;24724:20;24763:8;;;24357:422::o;30867:742::-;30982:12;31011:7;31007:595;;;-1:-1:-1;31042:10:0;31035:17;;31007:595;31156:17;;:21;31152:439;;31419:10;31413:17;31480:15;31467:10;31463:2;31459:19;31452:44;31367:148;31562:12;31555:20;;-1:-1:-1;;;31555:20:0;;;;;;;;:::i;1586:469:-1:-;;1702:4;1690:9;1685:3;1681:19;1677:30;1674:2;;;-1:-1;;1710:12;1674:2;1738:20;1702:4;1738:20;:::i;:::-;1729:29;;85:6;72:20;97:33;124:5;97:33;:::i;:::-;1838:49;1820:16;1813:75;;1951:2;2009:9;2005:22;2129:20;1951:2;1970:5;1966:16;1959:75;1668:387;;;;:::o;2473:241::-;;2577:2;2565:9;2556:7;2552:23;2548:32;2545:2;;;-1:-1;;2583:12;2545:2;85:6;72:20;97:33;124:5;97:33;:::i;2721:366::-;;;2842:2;2830:9;2821:7;2817:23;2813:32;2810:2;;;-1:-1;;2848:12;2810:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2900:63;-1:-1;3000:2;3039:22;;72:20;97:33;72:20;97:33;:::i;:::-;3008:63;;;;2804:283;;;;;:::o;3094:491::-;;;;3232:2;3220:9;3211:7;3207:23;3203:32;3200:2;;;-1:-1;;3238:12;3200:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3290:63;-1:-1;3390:2;3429:22;;72:20;97:33;72:20;97:33;:::i;:::-;3194:391;;3398:63;;-1:-1;;;3498:2;3537:22;;;;2129:20;;3194:391::o;3592:991::-;;;;;;;;3796:3;3784:9;3775:7;3771:23;3767:33;3764:2;;;-1:-1;;3803:12;3764:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3855:63;-1:-1;3955:2;3994:22;;72:20;97:33;72:20;97:33;:::i;:::-;3963:63;-1:-1;4063:2;4102:22;;2129:20;;-1:-1;4171:2;4210:22;;2129:20;;-1:-1;4279:3;4317:22;;2405:20;35586:4;35575:16;;37103:33;;37093:2;;-1:-1;;37140:12;37093:2;3758:825;;;;-1:-1;3758:825;;;;4288:61;4386:3;4426:22;;1325:20;;-1:-1;4495:3;4535:22;;;1325:20;;3758:825;-1:-1;;3758:825::o;4590:366::-;;;4711:2;4699:9;4690:7;4686:23;4682:32;4679:2;;;-1:-1;;4717:12;4679:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;4769:63;4869:2;4908:22;;;;2129:20;;-1:-1;;;4673:283::o;4963:431::-;;5119:2;;5107:9;5098:7;5094:23;5090:32;5087:2;;;-1:-1;;5125:12;5087:2;5183:17;5170:31;5221:18;;5213:6;5210:30;5207:2;;;-1:-1;;5243:12;5207:2;5361:6;5350:9;5346:22;471:3;464:4;456:6;452:17;448:27;438:2;;-1:-1;;479:12;438:2;526:6;513:20;499:34;;5221:18;33835:6;33832:30;33829:2;;;-1:-1;;33865:12;33829:2;548:107;5119:2;;33902:6;33898:17;33963:15;548:107;:::i;:::-;683:21;;;740:14;;;;-1:-1;715:17;;;841:4;829:17;;;820:27;;;;817:36;-1:-1;814:2;;;-1:-1;;856:12;814:2;-1:-1;882:10;;876:233;901:6;898:1;895:13;876:233;;;981:64;1041:3;1029:10;981:64;:::i;:::-;969:77;;1060:14;;;;923:1;916:9;;;;;1088:14;;;;876:233;;;-1:-1;5263:115;;5081:313;-1:-1;;;;;;;;5081:313::o;5401:257::-;;5513:2;5501:9;5492:7;5488:23;5484:32;5481:2;;;-1:-1;;5519:12;5481:2;1204:6;1198:13;36611:5;35001:13;34994:21;36589:5;36586:32;36576:2;;-1:-1;;36622:12;5665:533;;;;5824:2;5812:9;5803:7;5799:23;5795:32;5792:2;;;-1:-1;;5830:12;6205:241;;6309:2;6297:9;6288:7;6284:23;6280:32;6277:2;;;-1:-1;;6315:12;6277:2;-1:-1;2129:20;;6271:175;-1:-1;6271:175::o;6453:263::-;;6568:2;6556:9;6547:7;6543:23;6539:32;6536:2;;;-1:-1;;6574:12;6536:2;-1:-1;2277:13;;6530:186;-1:-1;6530:186::o;18085:271::-;;7393:5;34082:12;7504:52;7549:6;7544:3;7537:4;7530:5;7526:16;7504:52;:::i;:::-;7568:16;;;;;18219:137;-1:-1;;18219:137::o;18363:381::-;12225:34;12205:55;;12294:34;12289:2;12280:12;;12273:56;-1:-1;;;12358:2;12349:12;;12342:42;12189:2;12403:12;;18552:192::o;18751:381::-;13106:34;13086:55;;13175:34;13170:2;13161:12;;13154:56;-1:-1;;;13239:2;13230:12;;13223:42;13070:2;13284:12;;18940:192::o;19139:526::-;36233:15;;;;;-1:-1;;;;;;36233:15;17783:56;;19416:1;19407:11;;7025:37;;;;19517:12;;;7025:37;19628:12;;;19309:356::o;19672:222::-;-1:-1;;;;;35370:54;;;;6794:37;;19799:2;19784:18;;19770:124::o;19901:333::-;-1:-1;;;;;35370:54;;;;6794:37;;20220:2;20205:18;;7025:37;20056:2;20041:18;;20027:207::o;20241:210::-;35001:13;;34994:21;6908:34;;20362:2;20347:18;;20333:118::o;20458:780::-;7025:37;;;-1:-1;;;;;35370:54;;;20890:2;20875:18;;6794:37;35370:54;;;;20973:2;20958:18;;6794:37;21056:2;21041:18;;7025:37;21139:3;21124:19;;7025:37;;;;35381:42;21208:19;;7025:37;20725:3;20710:19;;20696:542::o;21245:668::-;7025:37;;;21649:2;21634:18;;7025:37;;;;21732:2;21717:18;;7025:37;;;;21815:2;21800:18;;7025:37;-1:-1;;;;;35370:54;21898:3;21883:19;;6794:37;21484:3;21469:19;;21455:458::o;21920:548::-;7025:37;;;35586:4;35575:16;;;;22288:2;22273:18;;18038:35;22371:2;22356:18;;7025:37;22454:2;22439:18;;7025:37;22127:3;22112:19;;22098:370::o;22475:310::-;;22622:2;22643:17;22636:47;7741:5;34082:12;34521:6;22622:2;22611:9;22607:18;34509:19;7835:52;7880:6;34549:14;22611:9;34549:14;22622:2;7861:5;7857:16;7835:52;:::i;:::-;36141:7;36125:14;-1:-1;;36121:28;7899:39;;;;34549:14;7899:39;;22593:192;-1:-1;;22593:192::o;22792:416::-;22992:2;23006:47;;;8175:2;22977:18;;;34509:19;8211:26;34549:14;;;8191:47;8257:12;;;22963:245::o;23215:416::-;23415:2;23429:47;;;8508:2;23400:18;;;34509:19;8544:34;34549:14;;;8524:55;-1:-1;;;8599:12;;;8592:27;8638:12;;;23386:245::o;23638:416::-;23838:2;23852:47;;;8889:2;23823:18;;;34509:19;8925:34;34549:14;;;8905:55;-1:-1;;;8980:12;;;8973:30;9022:12;;;23809:245::o;24061:416::-;24261:2;24275:47;;;9273:2;24246:18;;;34509:19;9309:34;34549:14;;;9289:55;-1:-1;;;9364:12;;;9357:26;9402:12;;;24232:245::o;24484:416::-;24684:2;24698:47;;;9653:2;24669:18;;;34509:19;9689:29;34549:14;;;9669:50;9738:12;;;24655:245::o;24907:416::-;25107:2;25121:47;;;9989:2;25092:18;;;34509:19;10025:34;34549:14;;;10005:55;-1:-1;;;10080:12;;;10073:32;10124:12;;;25078:245::o;25330:416::-;25530:2;25544:47;;;10375:2;25515:18;;;34509:19;10411:31;34549:14;;;10391:52;10462:12;;;25501:245::o;25753:416::-;25953:2;25967:47;;;10713:2;25938:18;;;34509:19;10749:32;34549:14;;;10729:53;10801:12;;;25924:245::o;26176:416::-;26376:2;26390:47;;;11052:2;26361:18;;;34509:19;11088:34;34549:14;;;11068:55;-1:-1;;;11143:12;;;11136:26;11181:12;;;26347:245::o;26599:416::-;26799:2;26813:47;;;11432:2;26784:18;;;34509:19;11468:30;34549:14;;;11448:51;11518:12;;;26770:245::o;27022:416::-;27222:2;27236:47;;;11769:2;27207:18;;;34509:19;11805:34;34549:14;;;11785:55;-1:-1;;;11860:12;;;11853:30;11902:12;;;27193:245::o;27445:416::-;27645:2;27659:47;;;12654:2;27630:18;;;34509:19;12690:34;34549:14;;;12670:55;-1:-1;;;12745:12;;;12738:26;12783:12;;;27616:245::o;27868:416::-;28068:2;28082:47;;;13535:2;28053:18;;;34509:19;13571:34;34549:14;;;13551:55;-1:-1;;;13626:12;;;13619:26;13664:12;;;28039:245::o;28291:416::-;28491:2;28505:47;;;13915:2;28476:18;;;34509:19;13951:32;34549:14;;;13931:53;14003:12;;;28462:245::o;28714:416::-;28914:2;28928:47;;;28899:18;;;34509:19;14290:34;34549:14;;;14270:55;14344:12;;;28885:245::o;29137:416::-;29337:2;29351:47;;;14595:2;29322:18;;;34509:19;14631:34;34549:14;;;14611:55;-1:-1;;;14686:12;;;14679:25;14723:12;;;29308:245::o;29560:416::-;29760:2;29774:47;;;14974:2;29745:18;;;34509:19;15010:34;34549:14;;;14990:55;-1:-1;;;15065:12;;;15058:29;15106:12;;;29731:245::o;29983:416::-;30183:2;30197:47;;;15357:2;30168:18;;;34509:19;15393:34;34549:14;;;15373:55;-1:-1;;;15448:12;;;15441:28;15488:12;;;30154:245::o;30406:416::-;30606:2;30620:47;;;15739:2;30591:18;;;34509:19;15775:31;34549:14;;;15755:52;15826:12;;;30577:245::o;30829:416::-;31029:2;31043:47;;;16077:2;31014:18;;;34509:19;16113:32;34549:14;;;16093:53;16165:12;;;31000:245::o;31252:416::-;31452:2;31466:47;;;16416:2;31437:18;;;34509:19;16452:34;34549:14;;;16432:55;-1:-1;;;16507:12;;;16500:34;16553:12;;;31423:245::o;31675:416::-;31875:2;31889:47;;;16804:2;31860:18;;;34509:19;16840:34;34549:14;;;16820:55;-1:-1;;;16895:12;;;16888:37;16944:12;;;31846:245::o;32098:416::-;32298:2;32312:47;;;17195:2;32283:18;;;34509:19;17231:34;34549:14;;;17211:55;-1:-1;;;17286:12;;;17279:32;17330:12;;;32269:245::o;32521:416::-;32721:2;32735:47;;;17581:2;32706:18;;;34509:19;17617:33;34549:14;;;17597:54;17670:12;;;32692:245::o;32944:222::-;7025:37;;;33071:2;33056:18;;33042:124::o;33173:214::-;35586:4;35575:16;;;;18038:35;;33296:2;33281:18;;33267:120::o;33394:256::-;33456:2;33450:9;33482:17;;;33557:18;33542:34;;33578:22;;;33539:62;33536:2;;;33614:1;;33604:12;33536:2;33456;33623:22;33434:216;;-1:-1;33434:216::o;35604:268::-;35669:1;35676:101;35690:6;35687:1;35684:13;35676:101;;;35757:11;;;35751:18;35738:11;;;35731:39;35712:2;35705:10;35676:101;;;35792:6;35789:1;35786:13;35783:2;;;35669:1;35848:6;35843:3;35839:16;35832:27;35783:2;;35653:219;;;:::o;36266:117::-;-1:-1;;;;;35370:54;;36325:35;;36315:2;;36374:1;;36364:12

ipfs://72a1ab2b77d1a88e3fe33849ae169ddc2ea7d3ccd69b6fdd6529421d0573ec29