Contract 0xd87265882b688eb76087cf9ca3b8adc10642ad2c

/**
 *Submitted for verification at polygonscan.com on 2021-09-01
*/

pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: UNLICENSED


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


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


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



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


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



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


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


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

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

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

interface IStrategy {
    //Returns the token sent to the fee dist contract, which is used to calculate the amount of ADDY to mint when claiming rewards
    function getFeeDistToken() external view returns (address);

    //Returns the harvested token, which is not guaranteed to be the fee dist token
    function getHarvestedToken() external view returns (address);

    function lastHarvestTime() external view returns (uint256);

    function rewards() external view returns (address);

    function want() external view returns (address);

    function deposit() external;

    function withdrawForSwap(uint256) external returns (uint256);

    function withdraw(uint256) external;

    function balanceOf() external view returns (uint256);

    function getHarvestable() external view returns (uint256);

    function harvest() external;

    function setJar(address _jar) external;
}

//A Jar is a contract that users deposit funds into.
//Jar contracts are paired with a strategy contract that interacts with the pool being farmed.
interface IJar {
    function token() external view returns (IERC20);

    function getRatio() external view returns (uint256);

    function balance() external view returns (uint256);

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

    function depositAll() external;

    function deposit(uint256) external;

    //function depositFor(address user, uint256 amount) external;

    function withdrawAll() external;

    //function withdraw(uint256) external;

    //function earn() external;

    function strategy() external view returns (address);

    //function decimals() external view returns (uint8);

    //function getLastTimeRestaked(address _address) external view returns (uint256);

    //function notifyReward(address _reward, uint256 _amount) external;

    //function getPendingReward(address _user) external view returns (uint256);
}
interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}
interface IUniswapRouterV2 {
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);
}


abstract contract BaseStrategy is IStrategy, Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using Address for address;
    using SafeMath for uint256;

    uint256 public override lastHarvestTime = 0;

    // Tokens
    address public override want; //The LP token, Harvest calls this "rewardToken"
    address public constant weth = 0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619; //weth for Matic
    address internal harvestedToken; //The token we harvest. If the reward pool emits multiple tokens, they should be converted to a single token.

    // Contracts
    address public override rewards; //The staking rewards/MasterChef contract
    address public strategist; //The address the performance fee is sent to
    address public multiHarvest = 0x3355743Db830Ed30FF4089DB8b18DEeb683F8546; //The multi harvest contract
    address public jar; //The vault/jar contract

    // Dex
    address public currentRouter = 0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff; //Quickswap router

    constructor(
        address _want,
        address _strategist,
        address _harvestedToken,
        address _currentRouter,
        address _rewards
    ) public {
        require(_want != address(0));
        require(_strategist != address(0));
        require(_harvestedToken != address(0));
        require(_currentRouter != address(0));
        require(_rewards != address(0));

        want = _want;
        strategist = _strategist;
        harvestedToken = _harvestedToken;
        currentRouter = _currentRouter;
        rewards = _rewards;
    }

    // **** Modifiers **** //

    //prevent unauthorized smart contracts from calling harvest()
    modifier onlyHumanOrWhitelisted {
        require(msg.sender == tx.origin || msg.sender == owner() || msg.sender == multiHarvest, "not authorized");
        _;
    }

    // **** Views **** //

    function balanceOfWant() public view returns (uint256) {
        return IERC20(want).balanceOf(address(this));
    }

    function balanceOfPool() public virtual view returns (uint256);

    function balanceOf() public override view returns (uint256) {
        return balanceOfWant().add(balanceOfPool());
    }

    function getHarvestedToken() public override view returns (address) {
        return harvestedToken;
    }

    // **** Setters **** //

    function setJar(address _jar) external override onlyOwner {
        require(jar == address(0), "jar already set");
        require(IJar(_jar).strategy() == address(this), "incorrect jar");
        jar = _jar;
        emit SetJar(_jar);
    }

    function setMultiHarvest(address _address) external onlyOwner {
        require(_address != address(0));
        multiHarvest = _address;
    }

    // **** State mutations **** //
    function deposit() public override virtual;

    // Withdraw partial funds, normally used with a jar withdrawal
    function withdraw(uint256 _amount) external override {
        require(msg.sender == jar, "!jar");
        uint256 _balance = IERC20(want).balanceOf(address(this));
        if (_balance < _amount) {
            _amount = _withdrawSome(_amount.sub(_balance));
            _amount = _amount.add(_balance);
        }

        IERC20(want).safeTransfer(jar, _amount);
    }

    // Withdraw funds, used to swap between strategies
    // Not utilized right now, but could be used for i.e. multi stablecoin strategies
    function withdrawForSwap(uint256 _amount)
        external override
        returns (uint256 balance)
    {
        require(msg.sender == jar, "!jar");
        _withdrawSome(_amount);

        balance = IERC20(want).balanceOf(address(this));

        IERC20(want).safeTransfer(jar, balance);
    }

    function _withdrawSome(uint256 _amount) internal virtual returns (uint256);

    function harvest() public override virtual;

    // **** Internal functions ****

    //Performs a swap through the current router, assuming infinite approval for the token was already given
    function _swapUniswapWithPathPreapproved(
        address[] memory path,
        uint256 _amount,
        address _router
    ) internal {
        require(path[1] != address(0));

        IUniswapRouterV2(_router).swapExactTokensForTokens(
            _amount,
            0,
            path,
            address(this),
            now.add(60)
        );
    }

    function _swapUniswapWithPathPreapproved(
        address[] memory path,
        uint256 _amount
    ) internal {
        _swapUniswapWithPathPreapproved(path, _amount, currentRouter);
    }

    //Legacy swap functions left in to not break compatibility with older strategy contracts
    function _swapUniswapWithPath(
        address[] memory path,
        uint256 _amount,
        address _router
    ) internal {
        require(path[1] != address(0));

        // Swap with uniswap
        IERC20(path[0]).safeApprove(_router, 0);
        IERC20(path[0]).safeApprove(_router, _amount);

        IUniswapRouterV2(_router).swapExactTokensForTokens(
            _amount,
            0,
            path,
            address(this),
            now.add(60)
        );
    }

    function _swapUniswapWithPath(
        address[] memory path,
        uint256 _amount
    ) internal {
        _swapUniswapWithPath(path, _amount, currentRouter);
    }

    function _swapUniswapWithPathForFeeOnTransferTokens(
        address[] memory path,
        uint256 _amount,
        address _router
    ) internal {
        require(path[1] != address(0));

        // Swap with uniswap
        IERC20(path[0]).safeApprove(_router, 0);
        IERC20(path[0]).safeApprove(_router, _amount);

        IUniswapRouterV2(_router).swapExactTokensForTokensSupportingFeeOnTransferTokens(
            _amount,
            0,
            path,
            address(this),
            now.add(60)
        );
    }

    function _swapUniswapWithPathForFeeOnTransferTokens(
        address[] memory path,
        uint256 _amount
    ) internal {
        _swapUniswapWithPathForFeeOnTransferTokens(path, _amount, currentRouter);
    }

    function _distributePerformanceFeesAndDeposit() internal {
        uint256 _want = IERC20(want).balanceOf(address(this));

        if (_want > 0) {
            deposit();
        }
        lastHarvestTime = now;
    }

    // **** Events **** //
    event SetJar(address indexed jar);
}
// Inheritance

// https://docs.synthetix.io/contracts/Pausable
abstract contract Pausable is Ownable {
    uint public lastPauseTime;
    bool public paused;

    constructor() internal {
        // This contract is abstract, and thus cannot be instantiated directly
        //require(owner != address(0), "Owner must be set");
        // Paused will be false, and lastPauseTime will be 0 upon initialisation
    }

    /**
     * @notice Change the paused state of the contract
     * @dev Only the contract owner may call this.
     */
    function setPaused(bool _paused) external onlyOwner {
        // Ensure we're actually changing the state before we do anything
        if (_paused == paused) {
            return;
        }

        // Set our paused state.
        paused = _paused;

        // If applicable, set the last pause time.
        if (paused) {
            lastPauseTime = now;
        }

        // Let everyone know that our pause state has changed.
        emit PauseChanged(paused);
    }

    event PauseChanged(bool isPaused);

    modifier notPaused {
        require(!paused, "This action cannot be performed while the contract is paused");
        _;
    }
}
struct RewardData {
    address token;
    uint256 amount;
}
struct LockedBalance {
    uint256 amount;
    uint256 unlockTime;
}

// Interface for EPS Staking contract - http://ellipsis.finance/
interface IMultiFeeDistribution {

    /* ========== VIEWS ========== */
    function totalSupply() external view returns (uint256);
    function lockedSupply() external view returns (uint256);

    function rewardPerToken(address _rewardsToken) external view returns (uint256);

    function getRewardForDuration(address _rewardsToken) external view returns (uint256);

    // Address and claimable amount of all reward tokens for the given account
    function claimableRewards(address account) external view returns (RewardData[] memory);

    // Total balance of an account, including unlocked, locked and earned tokens
    function totalBalance(address user) view external returns (uint256 amount);

    // Total withdrawable balance for an account to which no penalty is applied
    function unlockedBalance(address user) view external returns (uint256 amount);

    // Final balance received and penalty balance paid by user upon calling exit
    function withdrawableBalance(address user) view external returns (uint256 amount, uint256 penaltyAmount);

    // Information on the "earned" balances of a user
    // Earned balances may be withdrawn immediately for a 50% penalty
    function earnedBalances(address user) view external returns (uint256 total, LockedBalance[] memory earningsData);

    // Information on a user's locked balances
    function lockedBalances(address user) view external returns (uint256 total, uint256 unlockable, uint256 locked, LockedBalance[] memory lockData);

    /* ========== MUTATIVE FUNCTIONS ========== */

    // Mint new tokens
    // Minted tokens receive rewards normally but incur a 50% penalty when
    // withdrawn before lockDuration has passed.
    function mint(address user, uint256 amount) external;

    // Withdraw full unlocked balance and claim pending rewards
    function exit() external;

    // Withdraw all currently locked tokens where the unlock time has passed
    function withdrawExpiredLocks() external;

    // Claim all pending staking rewards (both BUSD and EPS)
    function getReward() external;

    // Stake tokens to receive rewards
    // Locked tokens cannot be withdrawn for lockDuration and are eligible to receive stakingReward rewards
    function stake(uint256 amount, bool lock) external;
    
    // Withdraw staked tokens
    // First withdraws unlocked tokens, then earned tokens. Withdrawing earned tokens
    // incurs a 50% penalty which is distributed based on locked balances.
    function withdraw(uint256 amount) external;
    
    /* ========== ADMIN CONFIGURATION ========== */

    // Used to let FeeDistribution know that _rewardsToken was added to it
    function notifyRewardAmount(address _rewardsToken, uint256 rewardAmount) external;
}

interface IStakingDualRewards {
    function notifyRewardAmount(uint256 rewardA, uint256 rewardB) external;
}

//Locks ADDY in the fee dist contract and sends ADDY + WMATIC it receives to a external vault contract
contract FeeDistStrategyLockedDual is BaseStrategy, Pausable {

    address public WAULT_ROUTER = 0x3a1D87f206D12415f5b0A33E786967680AAb4f6d;
    address public MULTI_FEE_DIST = 0x920f22E1e5da04504b765F8110ab96A20E6408Bd;
    address public TIMELOCK = 0x52D3Dcf0E59237B032802b40E69f65877091171F;

    address public WMATIC = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
    address public ADDY = 0xc3FdbadC7c795EF1D6Ba111e06fF8F16A20Ea539;

    constructor()
        public
        BaseStrategy(
            ADDY,
            msg.sender, //strategist arg isn't used because no fee is deducted
            WMATIC,
            WAULT_ROUTER, //not used, since no swaps are performed
            MULTI_FEE_DIST
        )
    {
        IERC20(want).safeApprove(rewards, uint256(-1));
    }

    // **** State Mutations ****

    function harvest() public override onlyHumanOrWhitelisted nonReentrant notPaused {
        _getReward();

        //Send WMATIC and ADDY to the vault
        uint256 _wmatic_balance = IERC20(harvestedToken).balanceOf(address(this));
        uint256 _addy_balance = IERC20(ADDY).balanceOf(address(this));
        if (_wmatic_balance > 0) {
            IERC20(WMATIC).safeTransfer(jar, _wmatic_balance);
            IStakingDualRewards(jar).notifyRewardAmount(_wmatic_balance, 0);
        }
        if (_addy_balance > 0) {
            IERC20(ADDY).safeTransfer(jar, _addy_balance);
            IStakingDualRewards(jar).notifyRewardAmount(0, _addy_balance);
        }
    }

    function deposit() public override notPaused {
        uint256 _want = IERC20(want).balanceOf(address(this));
        if (_want > 0) {
            IMultiFeeDistribution(rewards).stake(_want, true);
        }
    }

    function _withdrawSome(uint256 _amount) internal override returns (uint256) {
        uint256 unlocked = IMultiFeeDistribution(rewards).unlockedBalance(address(this));

        //After the first locked withdrawal, there will be a buffer of unlocked tokens remaining in the contract
        if(unlocked >= _amount) {
            IMultiFeeDistribution(rewards).withdraw(_amount);
            return _amount;
        }
        else {
            //Not enough unlocked tokens available, need to withdraw locked stakes as well
            if(unlocked > 0) {
                IMultiFeeDistribution(rewards).withdraw(unlocked);
            }
            //Need to withdraw ALL locked stakes
            IMultiFeeDistribution(rewards).withdrawExpiredLocks();

            uint256 _balance = IERC20(want).balanceOf(address(this));
            require(_balance >= _amount, "Not enough unlocked tokens to process withdrawal");

            //Deposit remaining tokens into buffer of unlocked tokens
            uint256 extra = _balance.sub(_amount);
            if(extra > 0) {
                IMultiFeeDistribution(rewards).stake(extra, false);
            }
            return _amount;
        }
    }

    function _getReward() internal {
        IMultiFeeDistribution(rewards).getReward();
    }

    // **** Views ****

    function balanceOfPool() public override view returns (uint256) {
        return IMultiFeeDistribution(rewards).totalBalance(address(this));
    }

    function getHarvestable() external override view returns (uint256) {
        return 0; //use AddyData on the frontend to get the amount of pending WMATIC and ADDY, since this function was only designed to handle one token
    }

    //Not used
    function getFeeDistToken() public override view returns (address) {
        return harvestedToken;
    }

    // **** Admin functions ****

    //Need this function to relock stakes because it's possible for all locked stakes to have been withdrawn
    //Transfer ownership to an external contract that calculates the number of users with stakes ending in > 91 days & their stake amounts
    function relock(uint256 amount) public onlyOwner nonReentrant {
        require(IMultiFeeDistribution(rewards).unlockedBalance(address(this)) >= amount, "Not enough unlocked tokens to withdraw");

        IMultiFeeDistribution(rewards).withdraw(amount);
        deposit();
    }

    // Added to support recovering LP Rewards from other systems to be distributed to holders
    function salvage(address recipient, address token, uint256 amount) public onlyOwner {
        // Admin cannot withdraw the staking or harvested token from the contract
        require(token != want, "cannot salvage want");
        require(token != harvestedToken, "cannot salvage harvestedToken");
        IERC20(token).safeTransfer(recipient, amount);
    }

    //Withdraw as much ADDY as possible from the fee dist contract and return it to the vault
    function emergencyExit() public onlyOwner {
        IMultiFeeDistribution(rewards).exit();
        IMultiFeeDistribution(rewards).withdrawExpiredLocks();
        uint256 _want = IERC20(want).balanceOf(address(this));
        if (_want > 0) {
            IERC20(want).safeTransfer(jar, _want);
        }
    }

    function executeTransaction(address target, uint value, string memory signature, bytes memory data) public payable onlyOwner returns (bytes memory) {
        require(msg.sender == TIMELOCK, "not timelock");
        require(target != address(0), "!target");

        bytes memory callData;

        if (bytes(signature).length == 0) {
            callData = data;
        } else {
            callData = abi.encodePacked(bytes4(keccak256(bytes(signature))), data);
        }

        // solium-disable-next-line security/no-call-value
        // XXX: Using ".value(...)" is deprecated. Use "{value: ...}" instead.
        (bool success, bytes memory returnData) = target.call{value : value}(callData);
        require(success, "Timelock::executeTransaction: Transaction execution reverted.");

        return returnData;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isPaused","type":"bool"}],"name":"PauseChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"jar","type":"address"}],"name":"SetJar","type":"event"},{"inputs":[],"name":"ADDY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MULTI_FEE_DIST","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TIMELOCK","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WAULT_ROUTER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WMATIC","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfWant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyExit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"string","name":"signature","type":"string"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"executeTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getFeeDistToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHarvestable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHarvestedToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"jar","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastHarvestTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastPauseTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiHarvest","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"relock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"salvage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_jar","type":"address"}],"name":"setJar","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setMultiHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"want","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawForSwap","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

56120:5946:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59392:229;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60431:363;;;;;;;;;;-1:-1:-1;60431:363:0;;;;;:::i;:::-;;:::i;:::-;;59236:148;;;;;;;;;;;;;:::i;46043:73::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;52216:488::-;;;;;;;;;;-1:-1:-1;52216:488:0;;;;;:::i;:::-;;:::i;59645:106::-;;;;;;;;;;;;;:::i;45365:28::-;;;;;;;;;;;;;:::i;45794:25::-;;;;;;;;;;;;;:::i;61220:843::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;56190:72::-;;;;;;;;;;;;;:::i;48073:378::-;;;;;;;;;;-1:-1:-1;48073:378:0;;;;;:::i;:::-;;:::i;45449:73::-;;;;;;;;;;;;;:::i;56967:685::-;;;;;;;;;;;;;:::i;56427:66::-;;;;;;;;;;;;;:::i;45871:72::-;;;;;;;;;;;;;:::i;60897:315::-;;;;;;;;;;;;;:::i;51800:18::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;35280:148::-;;;;;;;;;;;;;:::i;47232:122::-;;;;;;;;;;;;;:::i;56350:68::-;;;;;;;;;;;;;:::i;34629:87::-;;;;;;;;;;;;;:::i;51768:25::-;;;;;;;;;;;;;:::i;47763:146::-;;;;;;;;;;-1:-1:-1;47763:146:0;;;;;:::i;:::-;;:::i;45714:31::-;;;;;;;;;;;;;:::i;60045:283::-;;;;;;;;;;-1:-1:-1;60045:283:0;;;;;:::i;:::-;;:::i;56269:74::-;;;;;;;;;;;;;:::i;45979:18::-;;;;;;;;;;;;;:::i;47035:118::-;;;;;;;;;;;;;:::i;48602:307::-;;;;;;;;;;-1:-1:-1;48602:307:0;;;;;:::i;:::-;;:::i;45298:43::-;;;;;;;;;;;;;:::i;57660:218::-;;;;;;;;;;;;;:::i;56500:64::-;;;;;;;;;;;;;:::i;35583:244::-;;;;;;;;;;-1:-1:-1;35583:244:0;;;;;:::i;:::-;;:::i;47509:246::-;;;;;;;;;;-1:-1:-1;47509:246:0;;;;;:::i;:::-;;:::i;59392:229::-;59450:7;59392:229;:::o;60431:363::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;;;;;;;;;60626:4:::1;::::0;-1:-1:-1;;;;;60617:13:0;;::::1;60626:4:::0;::::1;60617:13;;60609:45;;;;-1:-1:-1::0;;;60609:45:0::1;;;;;;;:::i;:::-;60682:14;::::0;-1:-1:-1;;;;;60673:23:0;;::::1;60682:14:::0;::::1;60673:23;;60665:65;;;;-1:-1:-1::0;;;60665:65:0::1;;;;;;;:::i;:::-;60741:45;-1:-1:-1::0;;;;;60741:26:0;::::1;60768:9:::0;60779:6;60741:26:::1;:45::i;:::-;60431:363:::0;;;:::o;59236:148::-;59340:7;;59318:58;;-1:-1:-1;;;59318:58:0;;59291:7;;-1:-1:-1;;;;;59340:7:0;;59318:43;;:58;;59370:4;;59318:58;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59311:65;;59236:148;:::o;46043:73::-;;;-1:-1:-1;;;;;46043:73:0;;:::o;52216:488::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;52369:6:::1;::::0;::::1;;52358:17;;::::0;::::1;;;52354:56;;;52392:7;;52354:56;52456:6;:16:::0;;-1:-1:-1;;52456:16:0::1;::::0;::::1;;;::::0;;;;::::1;52541:6;52537:58;;;52580:3;52564:13;:19:::0;52537:58:::1;52689:6;::::0;52676:20:::1;::::0;::::1;::::0;::::1;::::0;52689:6:::1;::::0;;::::1;::::0;52676:20:::1;:::i;:::-;;;;;;;;34920:1;52216:488:::0;:::o;59645:106::-;59729:14;;-1:-1:-1;;;;;59729:14:0;59645:106;:::o;45365:28::-;;;-1:-1:-1;;;;;45365:28:0;;:::o;45794:25::-;;;-1:-1:-1;;;;;45794:25:0;;:::o;61220:843::-;61354:12;34860;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;61401:8:::1;::::0;-1:-1:-1;;;;;61401:8:0::1;61387:10;:22;61379:47;;;;-1:-1:-1::0;;;61379:47:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;61445:20:0;::::1;61437:40;;;;-1:-1:-1::0;;;61437:40:0::1;;;;;;;:::i;:::-;61490:21;61534:9;61528:23;61555:1;61528:28;61524:179;;;-1:-1:-1::0;61584:4:0;61524:179:::1;;;61672:9;61656:27;;;;;;61686:4;61632:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;61621:70;;61524:179;61856:12;61870:23;61897:6;-1:-1:-1::0;;;;;61897:11:0::1;61917:5;61924:8;61897:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61855:78;;;;61952:7;61944:81;;;;-1:-1:-1::0;;;61944:81:0::1;;;;;;;:::i;:::-;62045:10:::0;61220:843;-1:-1:-1;;;;;;;61220:843:0:o;56190:72::-;;;;;;-1:-1:-1;;;;;56190:72:0;;:::o;48073:378::-;48159:3;;-1:-1:-1;;;;;48159:3:0;48145:10;:17;48137:34;;;;-1:-1:-1;;;48137:34:0;;;;;;;:::i;:::-;48208:4;;48201:37;;-1:-1:-1;;;48201:37:0;;48182:16;;-1:-1:-1;;;;;48208:4:0;;48201:22;;:37;;48232:4;;48201:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48182:56;;48264:7;48253:8;:18;48249:143;;;48298:36;48312:21;:7;48324:8;48312:11;:21::i;:::-;48298:13;:36::i;:::-;48288:46;-1:-1:-1;48359:21:0;48288:46;48371:8;48359:11;:21::i;:::-;48349:31;;48249:143;48430:3;;48411:4;;48404:39;;-1:-1:-1;;;;;48411:4:0;;;;48430:3;48435:7;48404:25;:39::i;:::-;48073:378;;:::o;45449:73::-;45480:42;45449:73;:::o;56967:685::-;46881:10;46895:9;46881:23;;:48;;;46922:7;:5;:7::i;:::-;-1:-1:-1;;;;;46908:21:0;:10;-1:-1:-1;;;;;46908:21:0;;46881:48;:78;;;-1:-1:-1;46947:12:0;;-1:-1:-1;;;;;46947:12:0;46933:10;:26;46881:78;46873:105;;;;-1:-1:-1;;;46873:105:0;;;;;;;:::i;:::-;37487:1:::1;38093:7;;:19;;38085:63;;;;-1:-1:-1::0;;;38085:63:0::1;;;;;;;:::i;:::-;37487:1;38226:7;:18:::0;52793:6:::2;::::0;::::2;;52792:7;52784:80;;;;-1:-1:-1::0;;;52784:80:0::2;;;;;;;:::i;:::-;57059:12:::3;:10;:12::i;:::-;57162:14;::::0;;57155:47:::3;::::0;-1:-1:-1;;;57155:47:0;;57129:23:::3;::::0;-1:-1:-1;;;;;57162:14:0;;::::3;::::0;57155:32:::3;::::0;:47:::3;::::0;57196:4:::3;::::0;57155:47:::3;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57244:4;::::0;57237:37:::3;::::0;-1:-1:-1;;;57237:37:0;;57129:73;;-1:-1:-1;57213:21:0::3;::::0;-1:-1:-1;;;;;57244:4:0;;::::3;::::0;57237:22:::3;::::0;:37:::3;::::0;57268:4:::3;::::0;57237:37:::3;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57213:61:::0;-1:-1:-1;57289:19:0;;57285:179:::3;;57353:3;::::0;57332:6:::3;::::0;57325:49:::3;::::0;-1:-1:-1;;;;;57332:6:0;;::::3;::::0;57353:3:::3;57358:15:::0;57325:27:::3;:49::i;:::-;57409:3;::::0;57389:63:::3;::::0;-1:-1:-1;;;57389:63:0;;-1:-1:-1;;;;;57409:3:0;;::::3;::::0;57389:43:::3;::::0;:63:::3;::::0;57433:15;;57409:3:::3;::::0;57389:63:::3;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;57285:179;57478:17:::0;;57474:171:::3;;57538:3;::::0;57519:4:::3;::::0;57512:45:::3;::::0;-1:-1:-1;;;;;57519:4:0;;::::3;::::0;57538:3:::3;57543:13:::0;57512:25:::3;:45::i;:::-;57592:3;::::0;57572:61:::3;::::0;-1:-1:-1;;;57572:61:0;;-1:-1:-1;;;;;57592:3:0;;::::3;::::0;57572:43:::3;::::0;:61:::3;::::0;57592:3:::3;::::0;57619:13;;57572:61:::3;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;57474:171;-1:-1:-1::0;;37443:1:0::1;38405:22:::0;;56967:685::o;56427:66::-;;;-1:-1:-1;;;;;56427:66:0;;:::o;45871:72::-;;;-1:-1:-1;;;;;45871:72:0;;:::o;60897:315::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;60972:7:::1;;;;;;;;;-1:-1:-1::0;;;;;60972:7:0::1;-1:-1:-1::0;;;;;60950:35:0::1;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61020:7;;;;;;;;;-1:-1:-1::0;;;;;61020:7:0::1;-1:-1:-1::0;;;;;60998:51:0::1;;:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;61085:4:0::1;::::0;61078:37:::1;::::0;-1:-1:-1;;;61078:37:0;;61062:13:::1;::::0;-1:-1:-1;;;;;;61085:4:0;;::::1;::::0;-1:-1:-1;61078:22:0::1;::::0;:37:::1;::::0;61109:4:::1;::::0;61078:37:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61062:53:::0;-1:-1:-1;61130:9:0;;61126:79:::1;;61182:3;::::0;61163:4:::1;::::0;61156:37:::1;::::0;-1:-1:-1;;;;;61163:4:0;;::::1;::::0;61182:3:::1;61187:5:::0;61156:25:::1;:37::i;51800:18::-:0;;;;;;:::o;35280:148::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;35387:1:::1;35371:6:::0;;35350:40:::1;::::0;-1:-1:-1;;;;;35371:6:0;;::::1;::::0;35350:40:::1;::::0;35387:1;;35350:40:::1;35418:1;35401:19:::0;;-1:-1:-1;;;;;;35401:19:0::1;::::0;;35280:148::o;47232:122::-;47283:7;47310:36;47330:15;:13;:15::i;:::-;47310;:13;:15::i;:::-;:19;;:36::i;56350:68::-;;;-1:-1:-1;;;;;56350:68:0;;:::o;34629:87::-;34675:7;34702:6;-1:-1:-1;;;;;34702:6:0;34629:87;:::o;51768:25::-;;;;:::o;47763:146::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;47844:22:0;::::1;47836:31;;;::::0;::::1;;47878:12;:23:::0;;-1:-1:-1;;;;;;47878:23:0::1;-1:-1:-1::0;;;;;47878:23:0;;;::::1;::::0;;;::::1;::::0;;47763:146::o;45714:31::-;;;-1:-1:-1;;;;;45714:31:0;;:::o;60045:283::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;37487:1:::1;38093:7;;:19;;38085:63;;;;-1:-1:-1::0;;;38085:63:0::1;;;;;;;:::i;:::-;37487:1;38226:7;:18:::0;60148:7:::2;::::0;60126:61:::2;::::0;-1:-1:-1;;;60126:61:0;;60191:6;;-1:-1:-1;;;;;60148:7:0::2;::::0;60126:46:::2;::::0;:61:::2;::::0;60181:4:::2;::::0;60126:61:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:71;;60118:122;;;;-1:-1:-1::0;;;60118:122:0::2;;;;;;;:::i;:::-;60275:7;::::0;60253:47:::2;::::0;-1:-1:-1;;;60253:47:0;;-1:-1:-1;;;;;60275:7:0;;::::2;::::0;60253:39:::2;::::0;:47:::2;::::0;60293:6;;60253:47:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;60311:9;:7;:9::i;:::-;-1:-1:-1::0;37443:1:0::1;38405:22:::0;;60045:283::o;56269:74::-;;;-1:-1:-1;;;;;56269:74:0;;:::o;45979:18::-;;;-1:-1:-1;;;;;45979:18:0;;:::o;47035:118::-;47115:4;;47108:37;;-1:-1:-1;;;47108:37:0;;47081:7;;-1:-1:-1;;;;;47115:4:0;;47108:22;;:37;;47139:4;;47108:37;;;:::i;48602:307::-;48744:3;;48689:15;;-1:-1:-1;;;;;48744:3:0;48730:10;:17;48722:34;;;;-1:-1:-1;;;48722:34:0;;;;;;;:::i;:::-;48767:22;48781:7;48767:13;:22::i;:::-;-1:-1:-1;48819:4:0;;48812:37;;-1:-1:-1;;;48812:37:0;;-1:-1:-1;;;;;48819:4:0;;;;48812:22;;:37;;48843:4;;48812:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48888:3;;48869:4;;48802:47;;-1:-1:-1;48862:39:0;;-1:-1:-1;;;;;48869:4:0;;;;48888:3;48802:47;48862:25;:39::i;:::-;48602:307;;;:::o;45298:43::-;;;;:::o;57660:218::-;52793:6;;;;52792:7;52784:80;;;;-1:-1:-1;;;52784:80:0;;;;;;;:::i;:::-;57739:4:::1;::::0;57732:37:::1;::::0;-1:-1:-1;;;57732:37:0;;57716:13:::1;::::0;-1:-1:-1;;;;;57739:4:0::1;::::0;57732:22:::1;::::0;:37:::1;::::0;57763:4:::1;::::0;57732:37:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57716:53:::0;-1:-1:-1;57784:9:0;;57780:91:::1;;57832:7;::::0;57810:49:::1;::::0;-1:-1:-1;;;57810:49:0;;-1:-1:-1;;;;;57832:7:0;;::::1;::::0;57810:36:::1;::::0;:49:::1;::::0;57847:5;;57832:7;;57810:49:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;52875:1;57660:218::o:0;56500:64::-;;;-1:-1:-1;;;;;56500:64:0;;:::o;35583:244::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;35672:22:0;::::1;35664:73;;;;-1:-1:-1::0;;;35664:73:0::1;;;;;;;:::i;:::-;35774:6;::::0;;35753:38:::1;::::0;-1:-1:-1;;;;;35753:38:0;;::::1;::::0;35774:6;::::1;::::0;35753:38:::1;::::0;::::1;35802:6;:17:::0;;-1:-1:-1;;;;;;35802:17:0::1;-1:-1:-1::0;;;;;35802:17:0;;;::::1;::::0;;;::::1;::::0;;35583:244::o;47509:246::-;34860:12;:10;:12::i;:::-;-1:-1:-1;;;;;34849:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34849:23:0;;34841:68;;;;-1:-1:-1;;;34841:68:0;;;;;;;:::i;:::-;47586:3:::1;::::0;-1:-1:-1;;;;;47586:3:0::1;:17:::0;47578:45:::1;;;;-1:-1:-1::0;;;47578:45:0::1;;;;;;;:::i;:::-;47675:4;-1:-1:-1::0;;;;;47642:38:0::1;47647:4;-1:-1:-1::0;;;;;47642:19:0::1;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;47642:38:0::1;;47634:64;;;;-1:-1:-1::0;;;47634:64:0::1;;;;;;;:::i;:::-;47709:3;:10:::0;;-1:-1:-1;;;;;;47709:10:0::1;-1:-1:-1::0;;;;;47709:10:0;::::1;::::0;;::::1;::::0;;;47735:12:::1;::::0;::::1;::::0;-1:-1:-1;;47735:12:0::1;47509:246:::0;:::o;31196:622::-;31566:10;;;31565:62;;-1:-1:-1;31582:39:0;;-1:-1:-1;;;31582:39:0;;-1:-1:-1;;;;;31582:15:0;;;;;:39;;31606:4;;31613:7;;31582:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;31565:62;31557:152;;;;-1:-1:-1;;;31557:152:0;;;;;;;:::i;:::-;31720:90;31740:5;31770:22;;;31794:7;31803:5;31747:62;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;31747:62:0;;;;;;;;;;;;;;-1:-1:-1;;;;;31747:62:0;-1:-1:-1;;;;;;31747:62:0;;;;;;;;;;31720:19;:90::i;25633:195::-;25736:12;25768:52;25790:6;25798:4;25804:1;25807:12;25768:21;:52::i;:::-;25761:59;;25633:195;;;;;;:::o;648:106::-;736:10;648:106;:::o;30537:177::-;30620:86;30640:5;30670:23;;;30695:2;30699:5;30647:58;;;;;;;;;:::i;6885:158::-;6943:7;6976:1;6971;:6;;6963:49;;;;-1:-1:-1;;;6963:49:0;;;;;;;:::i;:::-;-1:-1:-1;7030:5:0;;;6885:158::o;57886:1216::-;58014:7;;57992:61;;-1:-1:-1;;;57992:61:0;;57953:7;;;;-1:-1:-1;;;;;58014:7:0;;;;57992:46;;:61;;58047:4;;57992:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57973:80;;58195:7;58183:8;:19;58180:915;;58241:7;;58219:48;;-1:-1:-1;;;58219:48:0;;-1:-1:-1;;;;;58241:7:0;;;;58219:39;;:48;;58259:7;;58219:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58289:7;58282:14;;;;;58180:915;58433:12;;58430:101;;58488:7;;58466:49;;-1:-1:-1;;;58466:49:0;;-1:-1:-1;;;;;58488:7:0;;;;58466:39;;:49;;58506:8;;58466:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58430:101;58617:7;;;;;;;;;-1:-1:-1;;;;;58617:7:0;-1:-1:-1;;;;;58595:51:0;;:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;58691:4:0;;58684:37;;-1:-1:-1;;;58684:37:0;;58665:16;;-1:-1:-1;;;;;;58691:4:0;;;;-1:-1:-1;58684:22:0;;:37;;58715:4;;58684:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58665:56;;58756:7;58744:8;:19;;58736:80;;;;-1:-1:-1;;;58736:80:0;;;;;;;:::i;:::-;58904:13;58920:21;:8;58933:7;58920:12;:21::i;:::-;58904:37;-1:-1:-1;58959:9:0;;58956:99;;59011:7;;58989:50;;-1:-1:-1;;;58989:50:0;;-1:-1:-1;;;;;59011:7:0;;;;58989:36;;:50;;59026:5;;59011:7;;58989:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58956:99;59076:7;59069:14;;;;;;;6423:179;6481:7;6513:5;;;6537:6;;;;6529:46;;;;-1:-1:-1;;;6529:46:0;;;;;;;:::i;59110:92::-;59174:7;;;;;;;;;-1:-1:-1;;;;;59174:7:0;-1:-1:-1;;;;;59152:40:0;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59110:92::o;32842:761::-;33266:23;33292:69;33320:4;33292:69;;;;;;;;;;;;;;;;;33300:5;-1:-1:-1;;;;;33292:27:0;;;:69;;;;;:::i;:::-;33376:17;;33266:95;;-1:-1:-1;33376:21:0;33372:224;;33518:10;33507:30;;;;;;;;;;;;:::i;:::-;33499:85;;;;-1:-1:-1;;;33499:85:0;;;;;;;:::i;26685:530::-;26812:12;26870:5;26845:21;:30;;26837:81;;;;-1:-1:-1;;;26837:81:0;;;;;;;:::i;:::-;26937:18;26948:6;26937:10;:18::i;:::-;26929:60;;;;-1:-1:-1;;;26929:60:0;;;;;;;:::i;:::-;27063:12;27077:23;27104:6;-1:-1:-1;;;;;27104:11:0;27124:5;27132:4;27104:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27062:75;;;;27155:52;27173:7;27182:10;27194:12;27155:17;:52::i;22715:422::-;23082:20;23121:8;;;22715:422::o;29225:742::-;29340:12;29369:7;29365:595;;;-1:-1:-1;29400:10:0;29393:17;;29365:595;29514:17;;:21;29510:439;;29777:10;29771:17;29838:15;29825:10;29821:2;29817:19;29810:44;29725:148;29920:12;29913:20;;-1:-1:-1;;;29913:20:0;;;;;;;;:::i;550:440:-1:-;;651:3;644:4;636:6;632:17;628:27;618:2;;-1:-1;;659:12;618:2;706:6;693:20;26751:18;;26743:6;26740:30;26737:2;;;-1:-1;;26773:12;26737:2;26407;26401:9;26846;26827:17;;-1:-1;;26823:33;26433:17;;26914:4;26433:17;26493:34;;;26529:22;;;26490:62;26487:2;;;-1:-1;;26555:12;26487:2;26407;26574:22;798:21;;;719:73;-1:-1;719:73;898:16;;;26914:4;898:16;895:25;-1:-1;892:2;;;933:1;;923:12;892:2;28771:6;26914:4;840:6;836:17;26914:4;874:5;870:16;28748:30;28827:1;26914:4;28818:6;874:5;28809:16;;28802:27;;;;611:379;;;;:::o;1727:241::-;;1831:2;1819:9;1810:7;1806:23;1802:32;1799:2;;;-1:-1;;1837:12;1799:2;85:6;72:20;97:33;124:5;97:33;:::i;1975:263::-;;2090:2;2078:9;2069:7;2065:23;2061:32;2058:2;;;-1:-1;;2096:12;2058:2;226:6;220:13;238:33;265:5;238:33;:::i;2245:491::-;;;;2383:2;2371:9;2362:7;2358:23;2354:32;2351:2;;;-1:-1;;2389:12;2351:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2441:63;-1:-1;2541:2;2580:22;;72:20;97:33;72:20;97:33;:::i;:::-;2345:391;;2549:63;;-1:-1;;;2649:2;2688:22;;;;1516:20;;2345:391::o;2743:827::-;;;;;2917:3;2905:9;2896:7;2892:23;2888:33;2885:2;;;-1:-1;;2924:12;2885:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2976:63;-1:-1;3076:2;3115:22;;1516:20;;-1:-1;3212:2;3197:18;;3184:32;3236:18;3225:30;;;3222:2;;;-1:-1;;3258:12;3222:2;3288:63;3343:7;3334:6;3323:9;3319:22;3288:63;:::i;:::-;3278:73;;3416:2;3405:9;3401:18;3388:32;3374:46;;3236:18;3432:6;3429:30;3426:2;;;-1:-1;;3462:12;3426:2;;3492:62;3546:7;3537:6;3526:9;3522:22;3492:62;:::i;:::-;3482:72;;;2879:691;;;;;;;:::o;3577:235::-;;3678:2;3666:9;3657:7;3653:23;3649:32;3646:2;;;-1:-1;;3684:12;3646:2;360:6;347:20;372:30;396:5;372:30;:::i;3819:257::-;;3931:2;3919:9;3910:7;3906:23;3902:32;3899:2;;;-1:-1;;3937:12;3899:2;495:6;489:13;507:30;531:5;507:30;:::i;4083:241::-;;4187:2;4175:9;4166:7;4162:23;4158:32;4155:2;;;-1:-1;;4193:12;4155:2;-1:-1;1516:20;;4149:175;-1:-1;4149:175::o;4331:263::-;;4446:2;4434:9;4425:7;4421:23;4417:32;4414:2;;;-1:-1;;4452:12;4414:2;-1:-1;1664:13;;4408:186;-1:-1;4408:186::o;4987:343::-;;5129:5;27352:12;27637:6;27632:3;27625:19;5222:52;5267:6;27674:4;27669:3;27665:14;27674:4;5248:5;5244:16;5222:52;:::i;:::-;26846:9;29268:14;-1:-1;;29264:28;5286:39;;;;27674:4;5286:39;;5077:253;-1:-1;;5077:253::o;13747:405::-;-1:-1;;;;;;28269:78;;4919:56;;27352:12;;13747:405;;5608:52;27352:12;14014:1;14005:11;;5641:4;5630:16;;5608:52;:::i;:::-;5672:16;;;;14014:1;5672:16;;13907:245;-1:-1;;;13907:245::o;14159:271::-;;5497:5;27352:12;5608:52;5653:6;5648:3;5641:4;5634:5;5630:16;5608:52;:::i;:::-;5672:16;;;;;14293:137;-1:-1;;14293:137::o;14437:222::-;-1:-1;;;;;28421:54;;;;4672:37;;14564:2;14549:18;;14535:124::o;14666:333::-;-1:-1;;;;;28421:54;;;4672:37;;28421:54;;14985:2;14970:18;;4672:37;14821:2;14806:18;;14792:207::o;15006:333::-;-1:-1;;;;;28421:54;;;;4672:37;;15325:2;15310:18;;13698:37;15161:2;15146:18;;15132:207::o;15346:210::-;28182:13;;28175:21;4786:34;;15467:2;15452:18;;15438:118::o;15563:306::-;;15708:2;15729:17;15722:47;15783:76;15708:2;15697:9;15693:18;15845:6;15783:76;:::i;15876:349::-;5779:58;;;16211:2;16196:18;;13698:37;16039:2;16024:18;;16010:215::o;16549:416::-;16749:2;16763:47;;;6428:2;16734:18;;;27625:19;6464:34;27665:14;;;6444:55;-1:-1;;;6519:12;;;6512:30;6561:12;;;16720:245::o;16972:416::-;17172:2;17186:47;;;6812:1;17157:18;;;27625:19;-1:-1;;;27665:14;;;6827:30;6876:12;;;17143:245::o;17395:416::-;17595:2;17609:47;;;7127:2;17580:18;;;27625:19;7163:34;27665:14;;;7143:55;-1:-1;;;7218:12;;;7211:30;7260:12;;;17566:245::o;17818:416::-;18018:2;18032:47;;;7511:2;18003:18;;;27625:19;-1:-1;;;27665:14;;;7527:42;7588:12;;;17989:245::o;18241:416::-;18441:2;18455:47;;;7839:2;18426:18;;;27625:19;7875:29;27665:14;;;7855:50;7924:12;;;18412:245::o;18664:416::-;18864:2;18878:47;;;8175:2;18849:18;;;27625:19;8211:31;27665:14;;;8191:52;8262:12;;;18835:245::o;19087:416::-;19287:2;19301:47;;;8513:2;19272:18;;;27625:19;8549:32;27665:14;;;8529:53;8601:12;;;19258:245::o;19510:416::-;19710:2;19724:47;;;8852:2;19695:18;;;27625:19;-1:-1;;;27665:14;;;8868:38;8925:12;;;19681:245::o;19933:416::-;20133:2;20147:47;;;9176:2;20118:18;;;27625:19;9212:34;27665:14;;;9192:55;-1:-1;;;9267:12;;;9260:30;9309:12;;;20104:245::o;20356:416::-;20556:2;20570:47;;;9560:2;20541:18;;;27625:19;-1:-1;;;27665:14;;;9576:37;9632:12;;;20527:245::o;20779:416::-;20979:2;20993:47;;;9883:2;20964:18;;;27625:19;9919:34;27665:14;;;9899:55;-1:-1;;;9974:12;;;9967:40;10026:12;;;20950:245::o;21202:416::-;21402:2;21416:47;;;21387:18;;;27625:19;10313:34;27665:14;;;10293:55;10367:12;;;21373:245::o;21625:416::-;21825:2;21839:47;;;10618:2;21810:18;;;27625:19;-1:-1;;;27665:14;;;10634:35;10688:12;;;21796:245::o;22048:416::-;22248:2;22262:47;;;10939:1;22233:18;;;27625:19;-1:-1;;;27665:14;;;10954:27;11000:12;;;22219:245::o;22471:416::-;22671:2;22685:47;;;11251:2;22656:18;;;27625:19;11287:34;27665:14;;;11267:55;11356:30;11342:12;;;11335:52;11406:12;;;22642:245::o;22894:416::-;23094:2;23108:47;;;11657:2;23079:18;;;27625:19;-1:-1;;;27665:14;;;11673:36;11728:12;;;23065:245::o;23317:416::-;23517:2;23531:47;;;11979:2;23502:18;;;27625:19;12015:34;27665:14;;;11995:55;12084:31;12070:12;;;12063:53;12135:12;;;23488:245::o;23740:416::-;23940:2;23954:47;;;12386:2;23925:18;;;27625:19;12422:31;27665:14;;;12402:52;12473:12;;;23911:245::o;24163:416::-;24363:2;24377:47;;;12724:2;24348:18;;;27625:19;12760:34;27665:14;;;12740:55;-1:-1;;;12815:12;;;12808:34;12861:12;;;24334:245::o;24586:416::-;24786:2;24800:47;;;13112:2;24771:18;;;27625:19;13148:33;27665:14;;;13128:54;13201:12;;;24757:245::o;25009:416::-;25209:2;25223:47;;;13452:2;25194:18;;;27625:19;13488:34;27665:14;;;13468:55;-1:-1;;;13543:12;;;13536:46;13601:12;;;25180:245::o;25432:222::-;13698:37;;;25559:2;25544:18;;25530:124::o;25661:321::-;13698:37;;;28182:13;28175:21;25968:2;25953:18;;4786:34;25810:2;25795:18;;25781:201::o;28844:268::-;28909:1;28916:101;28930:6;28927:1;28924:13;28916:101;;;28997:11;;;28991:18;28978:11;;;28971:39;28952:2;28945:10;28916:101;;;29032:6;29029:1;29026:13;29023:2;;;-1:-1;;28909:1;29079:16;;29072:27;28893:219::o;29305:117::-;-1:-1;;;;;28421:54;;29364:35;;29354:2;;29413:1;;29403:12;29429:111;29510:5;28182:13;28175:21;29488:5;29485:32;29475:2;;29531:1;;29521:12

ipfs://00519438a71e079141ef860fd19321062b993a8310266aca47fbff209b62aa3e