Contract 0x8751bad77aeecabae571ddb6a1f24d2a56961a44

/**
 *Submitted for verification at polygonscan.com on 2021-08-02
*/

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

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

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

    function setJar(address _jar) external override onlyOwner {
        require(jar == address(0), "jar already set");
        require(_jar != address(0));
        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);
}
interface IMiniChef {
    function harvest(uint256 _pid, address to) external;
    function deposit(uint256 _pid, uint256 _amount, address to) external;
    function withdraw(uint256 _pid, uint256 _amount, address to) external;
    function emergencyWithdraw(uint256 _pid, address to) external;
    function withdrawAndHarvest(uint256 pid, uint256 amount, address to) external;

    function userInfo(uint256 _pid, address _user) external view returns(uint256, int256);
    function poolInfo(uint256 _pid) external view returns(uint128, uint64, uint64);
    function pendingSushi(uint256 _pid, address _user) external view returns (uint256);

    function totalAllocPoint() external view returns (uint256);
    function sushiPerSecond() external view returns (uint256);
}


// Base contract for the new version of MasterChef that Sushi uses on Matic
abstract contract BaseStrategyMiniChef is BaseStrategy {

    uint256 public poolId;

    constructor(
        address _rewards,
        address _want,
        address _strategist,
        uint256 _poolId,
        address _harvestedToken,
        address _currentRouter
    )
        public
        BaseStrategy(_want, _strategist, _harvestedToken, _currentRouter, _rewards)
    {
        poolId = _poolId;
        IERC20(_want).safeApprove(_rewards, uint256(-1));
    }

    // **** Getters ****
    function balanceOfPool() public override view returns (uint256) {
        (uint256 amount, ) = IMiniChef(rewards).userInfo(poolId, address(this));
        return amount;
    }

    function getHarvestable() external override view returns (uint256) {
        return IMiniChef(rewards).pendingSushi(poolId, address(this));
    }

    // **** Setters ****

    function deposit() public override {
        uint256 _want = IERC20(want).balanceOf(address(this));
        if (_want > 0) {
            IMiniChef(rewards).deposit(poolId, _want, address(this));
        }
    }

    function _withdrawSome(uint256 _amount)
        internal
        override
        returns (uint256)
    {
        IMiniChef(rewards).withdraw(poolId, _amount, address(this));
        return _amount;
    }
    
    /* **** Other Mutative functions **** */

    function _getReward() internal {
        IMiniChef(rewards).harvest(poolId, address(this));
    }

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

    function salvage(address token) public onlyOwner {
        require(token != want && token != harvestedToken, "cannot salvage");

        uint256 _token = IERC20(token).balanceOf(address(this));
        if (_token > 0) {
            IERC20(token).safeTransfer(msg.sender, _token);
        }
    }

    function emergencyWithdraw() public onlyOwner {
        IMiniChef(rewards).emergencyWithdraw(poolId, address(this));

        uint256 _want = IERC20(want).balanceOf(address(this));
        if (_want > 0) {
            IERC20(want).safeTransfer(jar, _want);
        }
    }
}

interface IERCFund {
    function feeShareEnabled() external view returns (bool);

    function depositToFeeDistributor(address token, uint256 amount) external;

    function notifyFeeDistribution(address token) external;

    function getFee() external view returns (uint256);

    function recover(address token) 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);
}

//Vaults are jars that emit ADDY rewards.
interface IVault is IJar {

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

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

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

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

    function totalShares() external view returns (uint256);

    function getRewardMultiplier() external view returns (uint256);   

    function rewardAllocation() external view returns (uint256);   

    function totalPendingReward() external view returns (uint256);   

    function withdrawPenaltyTime() external view returns (uint256);  

    function withdrawPenalty() external view returns (uint256);   
    
    function increaseRewardAllocation(uint256 _newReward) external;

    function setWithdrawPenaltyTime(uint256 _withdrawPenaltyTime) external;

    function setWithdrawPenalty(uint256 _withdrawPenalty) external;

    function setRewardMultiplier(uint256 _rewardMultiplier) external;
}

//A normal vault is a vault where the strategy contract notifies the vault contract about the profit it generated when harvesting. 
interface IGenericVault is IVault {
    
    //Strategy calls notifyReward to let the vault know that it earned a certain amount of profit (the performance fee) for gov token stakers
    function notifyReward(address _reward, uint256 _amount) external;
}

//For A/B token pairs, where I have to convert the harvested token to A (ETH/MATIC/USDC/etc) and then sell 1/2 of A for B
contract StrategySushi is BaseStrategyMiniChef {

    address public WMATIC = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
    address public sushi = 0x0b3F868E0BE5597D5DB7fEB59E1CADBb0fdDa50a;
    address public tokenA;
    address public tokenB;
    address public sushiRouter = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
    address public miniChef = 0x0769fd68dFb93167989C6f7254cd0D766Fb2841F;

    uint256 public constant keepMax = 10000;

    // Uniswap swap paths
    address[] public sushi_matic_path;
    address[] public reward_a_path;
    address[] public a_b_path;

    constructor(
        address _want,
        address _tokenA,
        address _tokenB,
        uint256 _poolId,
        address _strategist
    )
        public
        BaseStrategyMiniChef(
            miniChef,
            _want,
            _strategist,
            _poolId,
            WMATIC,
            sushiRouter
        )
    {
        sushi_matic_path = new address[](2);
        sushi_matic_path[0] = sushi;
        sushi_matic_path[1] = WMATIC;

        tokenA = _tokenA;
        tokenB = _tokenB;

        reward_a_path = new address[](2);
        reward_a_path[0] = WMATIC;
        reward_a_path[1] = _tokenA;

        a_b_path = new address[](2);
        a_b_path[0] = _tokenA;
        a_b_path[1] = _tokenB;

        IERC20(harvestedToken).safeApprove(currentRouter, uint256(-1));
        IERC20(sushi).safeApprove(currentRouter, uint256(-1));

        if(harvestedToken != _tokenA) IERC20(_tokenA).safeApprove(currentRouter, uint256(-1));
        if(harvestedToken != _tokenB) IERC20(_tokenB).safeApprove(currentRouter, uint256(-1));
    }

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

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

    function harvest() public override onlyHumanOrWhitelisted nonReentrant {
        //Transfer any harvestedToken (WMATIC) that may already be in the contract to the fee dist fund
        IERC20(harvestedToken).safeTransfer(strategist, IERC20(harvestedToken).balanceOf(address(this)));
        //Transfer any sushi that may already be in the contract to the fee dist fund
        IERC20(sushi).safeTransfer(strategist, IERC20(sushi).balanceOf(address(this)));

        //Claims Sushi and some WMATIC
        _getReward();

        //Swap Sushi for WMATIC, because WMATIC is used to calculate profit
        uint256 _sushi_balance = IERC20(sushi).balanceOf(address(this));
        if (_sushi_balance > 0) {
            _swapUniswapWithPathPreapproved(sushi_matic_path, _sushi_balance);
        }

        //Distribute fee
        uint256 _harvested_balance = IERC20(harvestedToken).balanceOf(address(this));
        if (_harvested_balance > 0) {
            uint256 feeAmount = _harvested_balance.mul(IERCFund(strategist).getFee()).div(keepMax);
            uint256 afterFeeAmount = _harvested_balance.sub(feeAmount);
            _notifyJar(feeAmount);

            IERC20(harvestedToken).safeTransfer(strategist, feeAmount);

            //Swap WMATIC for tokenA if it isn't WMATIC
            //make sure token A has a high liquidity pair with WMATIC, like WETH and USDC
            if(tokenA != WMATIC) {
                _swapUniswapWithPathPreapproved(reward_a_path, afterFeeAmount);
            }
        }

        //Swap 1/2 of tokenA for tokenB
        uint256 _balanceA = IERC20(tokenA).balanceOf(address(this));
        if (_balanceA > 0) {
            _swapUniswapWithPathPreapproved(a_b_path, _balanceA.div(2));
        }

        //Add liquidity
        uint256 aBalance = IERC20(tokenA).balanceOf(address(this));
        uint256 bBalance = IERC20(tokenB).balanceOf(address(this));
        if (aBalance > 0 && bBalance > 0) {
            IUniswapRouterV2(currentRouter).addLiquidity(
                tokenA, tokenB,
                aBalance, bBalance,
                0, 0,
                address(this),
                now + 60
            );
        }

        // Stake the LP tokens
        _distributePerformanceFeesAndDeposit();
    }

    function _notifyJar(uint256 _amount) internal {
        IGenericVault(jar).notifyReward(getFeeDistToken(), _amount);
    }
}

interface IBoostHandler {

  //Returns ADDY earning boost based on user's veADDY, boost should be divided by 1e18
  function getBoost(address _user, address _vaultAddress) external view returns (uint256);

  //Returns ADDY earning boost based on user's veADDY if the user was to stake in vaultAddress, boost is divided by 1e18
  function getBoostForValueStaked(address _user, address _vaultAddress, uint256 valueStaked) external view returns (uint256);

  //Returns the value in USD for which a user's ADDY earnings are doubled
  function getDoubleLimit(address _user) external view returns (uint256 doubleLimit);

  //Returns the total VeAddy from all sources
  function getTotalVeAddy(address _user) external view returns (uint256);

  //Returns the total VeAddy from locking ADDY in the locked ADDY staking contract
  function getVeAddyFromLockedStaking(address _user) external view returns (uint256);

  function setFeeDist(address _feeDist) external;
}
interface IMinter {
    function isMinter(address) view external returns(bool);
    function amountAddyToMint(uint256 ethProfit) view external returns(uint256);
    function mintFor(address user, address asset, uint256 amount) external;

    function addyPerProfitEth() view external returns(uint256);

    function setMinter(address minter, bool canMint) external;
}// Based on https://github.com/iearn-finance/vaults/blob/master/contracts/vaults/yVault.sol


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

    // Info of each user
    struct UserInfo {
        uint256 shares; // User shares
        uint256 rewardDebt; // Reward debt (in terms of WMATIC)
        uint256 lastDepositTime;
        uint256 tokensStaked; // Number of tokens staked, only used to calculate profit on the frontend (different than shares)
    }

    uint256 public constant keepMax = 10000;

    /* ========== STATE VARIABLES ========== */

    // Info of each user
    mapping (address => UserInfo) public userInfo;

    // The total amount of pending rewards available for stakers to claim
    uint256 public override totalPendingReward;
    // Accumulated rewards per share, times 1e12.
    uint256 public accRewardPerShare;
    // The total # of shares issued
    uint256 public override totalShares;
    // Withdrawing before this much time has passed will have a withdrawal penalty
    uint256 public override withdrawPenaltyTime = 3 days;
    // Withdrawal penalty, 100 = 1%
    uint256 public override withdrawPenalty = 50;
    // For vaults that are farming pools with a deposit fee
    uint256 public depositFee = 0;
    //Allowed amount of the token sent to the fee dist each vault can mint ADDY rewards for, default 1000 (1000 WMATIC = roughly 0.65 ETH = 312 ADDY)
    uint256 public override rewardAllocation = 1e18 * 1000;

    // Certain vaults will give up to 10x ADDY rewards
    // Additional usecase for ADDY: lock it to boost the yield of a certain vault
    uint256 private rewardMultiplier = 1000;
    uint256 private constant MULTIPLIER_BASE = 1000;
    uint256 private constant MULTIPLIER_MAX = 10000;
    uint256 private constant BOOST_BASE = 10 ** 18;

    IERC20 public override token;
    address public override strategy;
    IMinter internal minter;
    address public ercFund;
    address public boostHandler;

    constructor(IStrategy _strategy, address _minter, address _ercFund)
        public
    {
        require(address(_strategy) != address(0));
        token = IERC20(_strategy.want());
        strategy = address(_strategy);
        minter = IMinter(_minter);
        ercFund = _ercFund;
    }

    /* ========== VIEW FUNCTIONS ========== */

    // 1000 = 1x multiplier
    function getRewardMultiplier() public override view returns (uint256) {
        return rewardMultiplier;
    }

    function applyRewardMultiplier(uint256 _amount) internal view returns (uint256) {
        return _amount.mul(rewardMultiplier).div(MULTIPLIER_BASE);
    }

    function getBoost(address _user) public override view returns (uint256) {
        if (boostHandler != address(0)) {
            return IBoostHandler(boostHandler).getBoost(_user, address(this));
        }
        return 0;
    }

    //Returns base amount + amount from boost
    function applyBoost(address _user, uint256 _amount) internal view returns (uint256) {
        if (boostHandler != address(0)) {
            return _amount.add(_amount.mul(getBoost(_user)).div(BOOST_BASE));
        }
        return _amount;
    }

    function getRatio() public override view returns (uint256) {
        return balance().mul(1e18).div(totalShares);
    }

    function balance() public override view returns (uint256) {
        return
            token.balanceOf(address(this)).add(
                IStrategy(strategy).balanceOf()
            );
    }

    function balanceOf(address _user) public override view returns (uint256) {
        return userInfo[_user].shares;
    }

    function getPendingReward(address _user) public override view returns (uint256) {
        return userInfo[_user].shares.mul(accRewardPerShare).div(1e12).sub(userInfo[_user].rewardDebt);
    }

    function getLastDepositTime(address _user) public override view returns (uint256) {
        return userInfo[_user].lastDepositTime;
    }

    function getTokensStaked(address _user) public override view returns (uint256) {
        return userInfo[_user].tokensStaked;
    }

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

    function depositAll() external override {
        deposit(token.balanceOf(msg.sender));
    }

    function deposit(uint256 _amount) public override nonReentrant {
        require(msg.sender == tx.origin, "no contracts");
        _claimReward(msg.sender);

        uint256 _pool = balance();
        uint256 _before = token.balanceOf(address(this));
        token.safeTransferFrom(msg.sender, address(this), _amount);
        uint256 _after = token.balanceOf(address(this));
        _amount = _after.sub(_before); // Additional check for deflationary tokens
        uint256 shares = 0;
        if (totalShares == 0) {
            shares = _amount;
        } else {
            shares = (_amount.mul(totalShares)).div(_pool);
        }

        //when farming pools with a deposit fee
        if(depositFee > 0) {
            uint256 fee = shares.mul(depositFee).div(keepMax);
            shares = shares.sub(fee);
        }

        totalShares = totalShares.add(shares);

        UserInfo storage user = userInfo[msg.sender];
        user.shares = user.shares.add(shares);
        user.rewardDebt = user.shares.mul(accRewardPerShare).div(1e12);
        user.lastDepositTime = now;
        user.tokensStaked = user.tokensStaked.add(_amount);

        earn(); 
        emit Deposited(msg.sender, _amount);
    }
 
    function earn() internal {
        uint256 _bal = token.balanceOf(address(this));
        token.safeTransfer(strategy, _bal);
        IStrategy(strategy).deposit();
    }

    // Withdraw all tokens and claim rewards.
    function withdrawAll() external override nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        uint256 _shares = user.shares;
        uint256 r = (balance().mul(_shares)).div(totalShares);

        _claimReward(msg.sender);

        // Check balance
        uint256 b = token.balanceOf(address(this));
        if (b < r) {
            uint256 _withdraw = r.sub(b);
            IStrategy(strategy).withdraw(_withdraw);
            uint256 _after = token.balanceOf(address(this));
            uint256 _diff = _after.sub(b);
            if (_diff < _withdraw) {
                r = b.add(_diff);
            }
        }

        totalShares = totalShares.sub(_shares);

        user.shares = user.shares.sub(_shares);
        user.rewardDebt = user.shares.mul(accRewardPerShare).div(1e12);
        user.tokensStaked = 0;
        // Deduct early withdrawal fee if applicable
        if(user.lastDepositTime.add(withdrawPenaltyTime) >= now) {
            uint256 earlyWithdrawalFee = r.mul(withdrawPenalty).div(keepMax);
            r = r.sub(earlyWithdrawalFee);
            token.safeTransfer(ercFund, earlyWithdrawalFee);
        }

        token.safeTransfer(msg.sender, r);
        emit Withdrawn(msg.sender, r);
    }

    // Withdraw all tokens without caring about rewards in the event that the reward mechanism breaks. 
    // Normal early withdrawal penalties will apply.
    function emergencyWithdraw() public nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        uint256 _shares = user.shares;
        uint256 r = (balance().mul(_shares)).div(totalShares);

        // Check balance
        uint256 b = token.balanceOf(address(this));
        if (b < r) {
            uint256 _withdraw = r.sub(b);
            IStrategy(strategy).withdraw(_withdraw);
            uint256 _after = token.balanceOf(address(this));
            uint256 _diff = _after.sub(b);
            if (_diff < _withdraw) {
                r = b.add(_diff);
            }
        }

        if(_shares <= totalShares) {
            totalShares = totalShares.sub(_shares);
        }
        else {
            totalShares = 0;
        }
        user.shares = 0;
        user.rewardDebt = 0;
        user.tokensStaked = 0;
        // Deduct early withdrawal fee if applicable
        if(user.lastDepositTime.add(withdrawPenaltyTime) >= now) {
            uint256 earlyWithdrawalFee = r.mul(withdrawPenalty).div(keepMax);
            r = r.sub(earlyWithdrawalFee);
            token.safeTransfer(ercFund, earlyWithdrawalFee);
        }

        token.safeTransfer(msg.sender, r);
        emit Withdrawn(msg.sender, r);
    }
    
    function claim() public nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        require(user.shares > 0, "no stake");

        _claimReward(msg.sender);

        user.rewardDebt = user.shares.mul(accRewardPerShare).div(1e12);
    }

    /* ========== INTERNAL FUNCTIONS ========== */

    // Handles claiming the user's pending rewards
    function _claimReward(address _user) internal virtual;

    /* ========== RESTRICTED FUNCTIONS ========== */

    //Vault deployer also needs to register the vault with the new minter
    function setMinter(address newMinter) public onlyOwner {
        require(newMinter != address(0));
        minter = IMinter(newMinter);
    }
    
    //Sets a new boost handler
    //Set boost handler to the zero address in order to disable it
    function setBoostHandler(address _handler) public onlyOwner {
        boostHandler = _handler;
    }

    function setWithdrawPenaltyTime(uint256 _withdrawPenaltyTime) public override onlyOwner {
        require(_withdrawPenaltyTime <= 30 days, "delay too high");
        withdrawPenaltyTime = _withdrawPenaltyTime;
    }

    function setWithdrawPenalty(uint256 _withdrawPenalty) public override onlyOwner {
        require(_withdrawPenalty <= 50, "penalty too high");
        withdrawPenalty = _withdrawPenalty;
    }

    function setRewardMultiplier(uint256 _rewardMultiplier) public override onlyOwner {
        require(_rewardMultiplier <= MULTIPLIER_MAX, "multiplier too high");
        rewardMultiplier = _rewardMultiplier;
    }

    //shouldn't be farming things with a high deposit fee in the first place
    function setPoolDepositFee(uint256 _depositFee) public onlyOwner {
        require(_depositFee <= 1000, "?");
        depositFee = _depositFee;
    }

    //Increase the amount of the token sent to the fee dist the vault is allowed to mint ADDY for
    function increaseRewardAllocation(uint256 _newReward) public override onlyOwner {
        rewardAllocation = rewardAllocation.add(_newReward);
        emit RewardAllocated(_newReward, rewardAllocation);
    }

    /* ========== EVENTS ========== */

    event Deposited(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardAdded(address reward, uint256 amount);
    event Claimed(address indexed user, uint256 amount);
    event RewardAllocated(uint256 newReward, uint256 totalAllocation);
}


contract GenericVault is VaultBase {

    constructor(IStrategy _strategy, address _minter, address _ercFund) 
        public
        VaultBase(_strategy, _minter, _ercFund)
    {
        
    }

    // Handles claiming the user's pending rewards
    function _claimReward(address _user) internal override {
        UserInfo storage user = userInfo[_user];
        if (user.shares > 0) {
            uint256 pendingReward = user.shares.mul(accRewardPerShare).div(1e12).sub(user.rewardDebt);
            if (pendingReward > 0) {
                totalPendingReward = totalPendingReward.sub(pendingReward);
                //Hard cap of 3x rewards after all multipliers
                uint256 rewardCap = pendingReward.mul(3);

                //Apply reward multiplier to the pendingReward that the minter will mint for
                pendingReward = applyRewardMultiplier(pendingReward);

                //Apply boost from locked ADDY 
                pendingReward = applyBoost(_user, pendingReward);

                //If pending reward > the 3x hard cap, then set the pending reward to the 3x hard cap
                if(pendingReward > rewardCap) {
                    pendingReward = rewardCap;
                }
                
                //Make sure the amount of the fee dist token the vault is allowed to mint for is above the amount we're trying to mint for
                //Require statement is there for end users
                require(rewardAllocation >= pendingReward, "Not enough rewards allocated");
                rewardAllocation = rewardAllocation.sub(pendingReward);

                //Minter will mint to MultiFeeDistribution and then stake the minted tokens for the user
                minter.mintFor(_user, IStrategy(strategy).getFeeDistToken(), pendingReward);
                emit Claimed(_user, pendingReward);
            }
        }
    }

    //Strategy calls notifyReward to let the vault know that it earned a certain amount of profit (the performance fee) for gov token stakers
    function notifyReward(address _reward, uint256 _amount) public {
        require(msg.sender == strategy);
        if(_amount == 0) {
            return;
        }

        totalPendingReward = totalPendingReward.add(_amount);
        accRewardPerShare = accRewardPerShare.add(_amount.mul(1e12).div(totalShares)); //shouldn't be adding reward if totalShares == 0 anyway

        emit RewardAdded(_reward, _amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_want","type":"address"},{"internalType":"address","name":"_tokenA","type":"address"},{"internalType":"address","name":"_tokenB","type":"address"},{"internalType":"uint256","name":"_poolId","type":"uint256"},{"internalType":"address","name":"_strategist","type":"address"}],"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":true,"internalType":"address","name":"jar","type":"address"}],"name":"SetJar","type":"event"},{"inputs":[],"name":"WMATIC","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"a_b_path","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":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","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":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"jar","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keepMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastHarvestTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"miniChef","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"poolId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"reward_a_path","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"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":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sushi","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sushiRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sushi_matic_path","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenA","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenB","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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

56276:4285:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51828:147;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56688:39;;;:::i;56405:65::-;;;:::i;:::-;;;;;;;:::i;56477:21::-;;;:::i;51642:178::-;;;:::i;44785:73::-;;;:::i;56803:30::-;;;;;;:::i;:::-;;:::i;57975:106::-;;;:::i;44152:28::-;;;:::i;44581:25::-;;;:::i;46671:378::-;;;;;;:::i;:::-;;:::i;:::-;;51185:21;;;:::i;44236:73::-;;;:::i;56611:68::-;;;:::i;58125:2301::-;;;:::i;56332:66::-;;;:::i;44658:27::-;;;:::i;56505:21::-;;;:::i;56533:71::-;;;:::i;2672:148::-;;;:::i;45983:122::-;;;:::i;52648:302::-;;;;;;:::i;:::-;;:::i;2021:87::-;;;:::i;46361:146::-;;;;;;:::i;:::-;;:::i;56763:33::-;;;;;;:::i;:::-;;:::i;44501:31::-;;;:::i;44721:18::-;;;:::i;45786:118::-;;;:::i;47200:307::-;;;;;;:::i;:::-;;:::i;44085:43::-;;;:::i;52011:215::-;;;:::i;52958:279::-;;;:::i;2975:244::-;;;;;;:::i;:::-;;:::i;46144:209::-;;;;;;:::i;:::-;;:::i;56840:25::-;;;;;;:::i;:::-;;:::i;51828:147::-;51923:7;;51945:6;;51913:54;;-1:-1:-1;;;51913:54:0;;51886:7;;-1:-1:-1;;;;;51923:7:0;;51913:31;;:54;;51945:6;51961:4;;51913:54;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51906:61;;51828:147;:::o;56688:39::-;56722:5;56688:39;:::o;56405:65::-;;;-1:-1:-1;;;;;56405:65:0;;:::o;56477:21::-;;;-1:-1:-1;;;;;56477:21:0;;:::o;51642:178::-;51748:7;;51766:6;;51738:50;;-1:-1:-1;;;51738:50:0;;51697:7;;;;-1:-1:-1;;;;;51748:7:0;;;;51738:27;;:50;;51782:4;;51738:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;51717:71:0;-1:-1:-1;;51642:178:0;:::o;44785:73::-;;;-1:-1:-1;;;;;44785:73:0;;:::o;56803:30::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56803:30:0;;-1:-1:-1;56803:30:0;:::o;57975:106::-;58059:14;;-1:-1:-1;;;;;58059:14:0;57975:106;:::o;44152:28::-;;;-1:-1:-1;;;;;44152:28:0;;:::o;44581:25::-;;;-1:-1:-1;;;;;44581:25:0;;:::o;46671:378::-;46757:3;;-1:-1:-1;;;;;46757:3:0;46743:10;:17;46735:34;;;;-1:-1:-1;;;46735:34:0;;;;;;;:::i;:::-;;;;;;;;;46806:4;;46799:37;;-1:-1:-1;;;46799:37:0;;46780:16;;-1:-1:-1;;;;;46806:4:0;;46799:22;;:37;;46830:4;;46799:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46780:56;;46862:7;46851:8;:18;46847:143;;;46896:36;46910:21;:7;46922:8;46910:11;:21::i;:::-;46896:13;:36::i;:::-;46886:46;-1:-1:-1;46957:21:0;46886:46;46969:8;46957:11;:21::i;:::-;46947:31;;46847:143;47028:3;;47009:4;;47002:39;;-1:-1:-1;;;;;47009:4:0;;;;47028:3;47033:7;47002:25;:39::i;:::-;46671:378;;:::o;51185:21::-;;;;:::o;44236:73::-;44267:42;44236:73;:::o;56611:68::-;;;-1:-1:-1;;;;;56611:68:0;;:::o;58125:2301::-;45632:10;45646:9;45632:23;;:48;;;45673:7;:5;:7::i;:::-;-1:-1:-1;;;;;45659:21:0;:10;-1:-1:-1;;;;;45659:21:0;;45632:48;:78;;;-1:-1:-1;45698:12:0;;-1:-1:-1;;;;;45698:12:0;45684:10;:26;45632:78;45624:105;;;;-1:-1:-1;;;45624: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;58348:10:::2;::::0;58367:14:::2;::::0;;58360:47:::2;::::0;-1:-1:-1;;;58360:47:0;;58312:96:::2;::::0;-1:-1:-1;;;;;58348:10:0;;::::2;::::0;58367:14;::::2;::::0;58360:32:::2;::::0;:47:::2;::::0;58401:4:::2;::::0;58360:47:::2;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58319:14;::::0;-1:-1:-1;;;;;58319:14:0::2;::::0;58312:96;:35:::2;:96::i;:::-;58533:10;::::0;58552:5:::2;::::0;58545:38:::2;::::0;-1:-1:-1;;;58545:38:0;;58506:78:::2;::::0;-1:-1:-1;;;;;58533:10:0;;::::2;::::0;58552:5:::2;::::0;58545:23:::2;::::0;:38:::2;::::0;58577:4:::2;::::0;58545:38:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58513:5;::::0;-1:-1:-1;;;;;58513:5:0::2;::::0;58506:78;:26:::2;:78::i;:::-;58637:12;:10;:12::i;:::-;58771:5;::::0;58764:38:::2;::::0;-1:-1:-1;;;58764:38:0;;58739:22:::2;::::0;-1:-1:-1;;;;;58771:5:0::2;::::0;58764:23:::2;::::0;:38:::2;::::0;58796:4:::2;::::0;58764:38:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58739:63:::0;-1:-1:-1;58817:18:0;;58813:116:::2;;58852:65;58884:16;58852:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;58852:65:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;;58902:14;58852:31;:65::i;:::-;59003:14;::::0;;58996:47:::2;::::0;-1:-1:-1;;;58996:47:0;;58967:26:::2;::::0;-1:-1:-1;;;;;59003:14:0;;::::2;::::0;58996:32:::2;::::0;:47:::2;::::0;59037:4:::2;::::0;58996:47:::2;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58967:76:::0;-1:-1:-1;59058:22:0;;59054:607:::2;;59097:17;59117:66;56722:5;59117:53;59149:10;;;;;;;;;-1:-1:-1::0;;;;;59149:10:0::2;-1:-1:-1::0;;;;;59140:27:0::2;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59117:18:::0;;:22:::2;:53::i;:::-;:57:::0;::::2;:66::i;:::-;59097:86:::0;-1:-1:-1;59198:22:0::2;59223:33;:18:::0;59097:86;59223:22:::2;:33::i;:::-;59198:58;;59271:21;59282:9;59271:10;:21::i;:::-;59345:10;::::0;59316:14:::2;::::0;59309:58:::2;::::0;-1:-1:-1;;;;;59316:14:0;;::::2;::::0;59345:10:::2;59357:9:::0;59309:35:::2;:58::i;:::-;59545:6;::::0;59535::::2;::::0;-1:-1:-1;;;;;59535:6:0;;::::2;59545::::0;::::2;59535:16;59532:118;;59572:62;59604:13;59572:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;59572:62:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;59619:14;59572:31;:62::i;:::-;59054:607;;;59741:6;::::0;59734:39:::2;::::0;-1:-1:-1;;;59734:39:0;;59714:17:::2;::::0;-1:-1:-1;;;;;59741:6:0::2;::::0;59734:24:::2;::::0;:39:::2;::::0;59767:4:::2;::::0;59734:39:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59714:59:::0;-1:-1:-1;59788:13:0;;59784:105:::2;;59818:59;59850:8;59818:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;59818:59:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;;59860:16;59874:1;59860:9;:13;;:16;;;;:::i;:::-;59818:31;:59::i;:::-;59952:6;::::0;59945:39:::2;::::0;-1:-1:-1;;;59945:39:0;;59926:16:::2;::::0;-1:-1:-1;;;;;59952:6:0::2;::::0;59945:24:::2;::::0;:39:::2;::::0;59978:4:::2;::::0;59945:39:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60021:6;::::0;60014:39:::2;::::0;-1:-1:-1;;;60014:39:0;;59926:58;;-1:-1:-1;59995:16:0::2;::::0;-1:-1:-1;;;;;60021:6:0;;::::2;::::0;60014:24:::2;::::0;:39:::2;::::0;60047:4:::2;::::0;60014:39:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59995:58;;60079:1;60068:8;:12;:28;;;;;60095:1;60084:8;:12;60068:28;60064:272;;;60130:13;::::0;60176:6:::2;::::0;60184::::2;::::0;60113:211:::2;::::0;-1:-1:-1;;;60113:211:0;;-1:-1:-1;;;;;60130:13:0;;::::2;::::0;60113:44:::2;::::0;:211:::2;::::0;60176:6;;::::2;::::0;60184;::::2;::::0;60209:8;;60219;;60130:13:::2;::::0;;;60277:4:::2;::::0;60307:2:::2;60301:3;:8;::::0;60113:211:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;60064:272;60380:38;:36;:38::i;:::-;-1:-1:-1::0;;37443:1:0::1;38405:22:::0;;-1:-1:-1;;;58125:2301:0:o;56332:66::-;;;-1:-1:-1;;;;;56332:66:0;;:::o;44658:27::-;;;-1:-1:-1;;;;;44658:27:0;;:::o;56505:21::-;;;-1:-1:-1;;;;;56505:21:0;;:::o;56533:71::-;;;-1:-1:-1;;;;;56533:71:0;;:::o;2672:148::-;2252:12;:10;:12::i;:::-;-1:-1:-1;;;;;2241:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2241:23:0;;2233:68;;;;-1:-1:-1;;;2233:68:0;;;;;;;:::i;:::-;2779:1:::1;2763:6:::0;;2742:40:::1;::::0;-1:-1:-1;;;;;2763:6:0;;::::1;::::0;2742:40:::1;::::0;2779:1;;2742:40:::1;2810:1;2793:19:::0;;-1:-1:-1;;;;;;2793:19:0::1;::::0;;2672:148::o;45983:122::-;46034:7;46061:36;46081:15;:13;:15::i;:::-;46061;:13;:15::i;:::-;:19;;:36::i;52648:302::-;2252:12;:10;:12::i;:::-;-1:-1:-1;;;;;2241:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2241:23:0;;2233:68;;;;-1:-1:-1;;;2233:68:0;;;;;;;:::i;:::-;52725:4:::1;::::0;-1:-1:-1;;;;;52716:13:0;;::::1;52725:4:::0;::::1;52716:13;::::0;::::1;::::0;:40:::1;;-1:-1:-1::0;52742:14:0::1;::::0;-1:-1:-1;;;;;52733:23:0;;::::1;52742:14:::0;::::1;52733:23;;52716:40;52708:67;;;;-1:-1:-1::0;;;52708:67:0::1;;;;;;;:::i;:::-;52805:38;::::0;-1:-1:-1;;;52805:38:0;;52788:14:::1;::::0;-1:-1:-1;;;;;52805:23:0;::::1;::::0;::::1;::::0;:38:::1;::::0;52837:4:::1;::::0;52805:38:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52788:55:::0;-1:-1:-1;52858:10:0;;52854:89:::1;;52885:46;-1:-1:-1::0;;;;;52885:26:0;::::1;52912:10;52924:6:::0;52885:26:::1;:46::i;2021:87::-:0;2067:7;2094:6;-1:-1:-1;;;;;2094:6:0;2021:87;:::o;46361:146::-;2252:12;:10;:12::i;:::-;-1:-1:-1;;;;;2241:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2241:23:0;;2233:68;;;;-1:-1:-1;;;2233:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46442:22:0;::::1;46434:31;;;::::0;::::1;;46476:12;:23:::0;;-1:-1:-1;;;;;;46476:23:0::1;-1:-1:-1::0;;;;;46476:23:0;;;::::1;::::0;;;::::1;::::0;;46361:146::o;56763:33::-;;;;;;;;;;44501:31;;;-1:-1:-1;;;;;44501:31:0;;:::o;44721:18::-;;;-1:-1:-1;;;;;44721:18:0;;:::o;45786:118::-;45866:4;;45859:37;;-1:-1:-1;;;45859:37:0;;45832:7;;-1:-1:-1;;;;;45866:4:0;;45859:22;;:37;;45890:4;;45859:37;;;:::i;47200:307::-;47342:3;;47287:15;;-1:-1:-1;;;;;47342:3:0;47328:10;:17;47320:34;;;;-1:-1:-1;;;47320:34:0;;;;;;;:::i;:::-;47365:22;47379:7;47365:13;:22::i;:::-;-1:-1:-1;47417:4:0;;47410:37;;-1:-1:-1;;;47410:37:0;;-1:-1:-1;;;;;47417:4:0;;;;47410:22;;:37;;47441:4;;47410:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47486:3;;47467:4;;47400:47;;-1:-1:-1;47460:39:0;;-1:-1:-1;;;;;47467:4:0;;;;47486:3;47400:47;47460:25;:39::i;:::-;47200:307;;;:::o;44085:43::-;;;;:::o;52011:215::-;52080:4;;52073:37;;-1:-1:-1;;;52073:37:0;;52057:13;;-1:-1:-1;;;;;52080:4:0;;52073:22;;:37;;52104:4;;52073:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52057:53;-1:-1:-1;52125:9:0;;52121:98;;52161:7;;52178:6;;52151:56;;-1:-1:-1;;;52151:56:0;;-1:-1:-1;;;;;52161:7:0;;;;52151:26;;:56;;52186:5;;52201:4;;52151:56;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52121:98;52011:215;:::o;52958:279::-;2252:12;:10;:12::i;:::-;-1:-1:-1;;;;;2241:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2241:23:0;;2233:68;;;;-1:-1:-1;;;2233:68:0;;;;;;;:::i;:::-;53025:7:::1;::::0;53052:6:::1;::::0;53015:59:::1;::::0;-1:-1:-1;;;53015:59:0;;-1:-1:-1;;;;;53025:7:0;;::::1;::::0;53015:36:::1;::::0;:59:::1;::::0;53068:4:::1;::::0;53015:59:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;53110:4:0::1;::::0;53103:37:::1;::::0;-1:-1:-1;;;53103:37:0;;53087:13:::1;::::0;-1:-1:-1;;;;;;53110:4:0;;::::1;::::0;-1:-1:-1;53103:22:0::1;::::0;:37:::1;::::0;53134:4:::1;::::0;53103:37:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53087:53:::0;-1:-1:-1;53155:9:0;;53151:79:::1;;53207:3;::::0;53188:4:::1;::::0;53181:37:::1;::::0;-1:-1:-1;;;;;53188:4:0;;::::1;::::0;53207:3:::1;53212:5:::0;53181:25:::1;:37::i;2975:244::-:0;2252:12;:10;:12::i;:::-;-1:-1:-1;;;;;2241:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2241:23:0;;2233:68;;;;-1:-1:-1;;;2233:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3064:22:0;::::1;3056:73;;;;-1:-1:-1::0;;;3056:73:0::1;;;;;;;:::i;:::-;3166:6;::::0;;3145:38:::1;::::0;-1:-1:-1;;;;;3145:38:0;;::::1;::::0;3166:6;::::1;::::0;3145:38:::1;::::0;::::1;3194:6;:17:::0;;-1:-1:-1;;;;;;3194:17:0::1;-1:-1:-1::0;;;;;3194:17:0;;;::::1;::::0;;;::::1;::::0;;2975:244::o;46144:209::-;2252:12;:10;:12::i;:::-;-1:-1:-1;;;;;2241:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2241:23:0;;2233:68;;;;-1:-1:-1;;;2233:68:0;;;;;;;:::i;:::-;46221:3:::1;::::0;-1:-1:-1;;;;;46221:3:0::1;:17:::0;46213:45:::1;;;;-1:-1:-1::0;;;46213:45:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;46277:18:0;::::1;46269:27;;;::::0;::::1;;46307:3;:10:::0;;-1:-1:-1;;;;;;46307:10:0::1;-1:-1:-1::0;;;;;46307:10:0;::::1;::::0;;::::1;::::0;;;46333:12:::1;::::0;::::1;::::0;-1:-1:-1;;46333:12:0::1;46144:209:::0;:::o;56840:25::-;;;;;;;;;;33420:622;33790:10;;;33789:62;;-1:-1:-1;33806:39:0;;-1:-1:-1;;;33806:39:0;;-1:-1:-1;;;;;33806:15:0;;;;;:39;;33830:4;;33837:7;;33806:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;33789:62;33781:152;;;;-1:-1:-1;;;33781:152:0;;;;;;;:::i;:::-;33944:90;33964:5;33994:22;;;34018:7;34027:5;33971:62;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;33971:62:0;;;;;;;;;;;;;;-1:-1:-1;;;;;33971:62:0;-1:-1:-1;;;;;;33971:62:0;;;;;;;;;;33944:19;:90::i;:::-;33420:622;;;:::o;27857:195::-;27960:12;27992:52;28014:6;28022:4;28028:1;28031:12;27992:21;:52::i;:::-;27985:59;;27857:195;;;;;;:::o;9109:158::-;9167:7;9200:1;9195;:6;;9187:49;;;;-1:-1:-1;;;9187:49:0;;;;;;;:::i;:::-;-1:-1:-1;9254:5:0;;;9109:158;;;;;:::o;52234:211::-;52363:7;;52381:6;;52353:59;;-1:-1:-1;;;52353:59:0;;52328:7;;-1:-1:-1;;;;;52363:7:0;;52353:27;;:59;;52381:6;52389:7;;52406:4;;52353:59;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52430:7:0;;52234:211;-1:-1:-1;;;;52234:211:0:o;8647:179::-;8705:7;8737:5;;;8761:6;;;;8753:46;;;;-1:-1:-1;;;8753:46:0;;;;;;;:::i;32761:177::-;32844:86;32864:5;32894:23;;;32919:2;32923:5;32871:58;;;;;;;;;:::i;52505:99::-;52557:7;;52574:6;;52547:49;;-1:-1:-1;;;52547:49:0;;-1:-1:-1;;;;;52557:7:0;;;;52547:26;;:49;;52590:4;;52547:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52505:99::o;48181:195::-;48354:13;;48307:61;;48339:4;;48345:7;;-1:-1:-1;;;;;48354:13:0;48307:31;:61::i;9526:220::-;9584:7;9608:6;9604:20;;-1:-1:-1;9623:1:0;9616:8;;9604:20;9647:5;;;9651:1;9647;:5;:1;9671:5;;;;;:10;9663:56;;;;-1:-1:-1;;;9663:56:0;;;;;;;:::i;10224:153::-;10282:7;10314:1;10310;:5;10302:44;;;;-1:-1:-1;;;10302:44:0;;;;;;;:::i;:::-;10368:1;10364;:5;;;;;;;10224:153;-1:-1:-1;;;10224:153:0:o;60434:124::-;60505:3;;-1:-1:-1;;;;;60505:3:0;60491:31;60523:17;:15;:17::i;:::-;60542:7;60491:59;;;;;;;;;;;;;;;;:::i;49955:224::-;50046:4;;50039:37;;-1:-1:-1;;;50039:37:0;;50023:13;;-1:-1:-1;;;;;50046:4:0;;50039:22;;:37;;50070:4;;50039:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50023:53;-1:-1:-1;50093:9:0;;50089:51;;50119:9;:7;:9::i;:::-;-1:-1:-1;50168:3:0;50150:15;:21;49955:224::o;648:106::-;736:10;648:106;:::o;35066:761::-;35490:23;35516:69;35544:4;35516:69;;;;;;;;;;;;;;;;;35524:5;-1:-1:-1;;;;;35516:27:0;;;:69;;;;;:::i;:::-;35600:17;;35490:95;;-1:-1:-1;35600:21:0;35596:224;;35742:10;35731:30;;;;;;;;;;;;:::i;:::-;35723:85;;;;-1:-1:-1;;;35723:85:0;;;;;;;:::i;28909:530::-;29036:12;29094:5;29069:21;:30;;29061:81;;;;-1:-1:-1;;;29061:81:0;;;;;;;:::i;:::-;29161:18;29172:6;29161:10;:18::i;:::-;29153:60;;;;-1:-1:-1;;;29153:60:0;;;;;;;:::i;:::-;29287:12;29301:23;29328:6;-1:-1:-1;;;;;29328:11:0;29348:5;29356:4;29328:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29286:75;;;;29379:52;29397:7;29406:10;29418:12;29379:17;:52::i;:::-;29372:59;28909:530;-1:-1:-1;;;;;;;28909:530:0:o;47798:375::-;47977:1;-1:-1:-1;;;;;47958:21:0;:4;47963:1;47958:7;;;;;;;;;;;;;;-1:-1:-1;;;;;47958:21:0;;;47950:30;;;;;;-1:-1:-1;;;;;47993:50:0;;;48058:7;48080:1;48096:4;48123;48143:11;:3;48151:2;48143:7;:11::i;:::-;47993:172;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47993:172:0;;;;;;;;;;;;:::i;24939:422::-;25306:20;25345:8;;;24939:422::o;31449:742::-;31564:12;31593:7;31589:595;;;-1:-1:-1;31624:10:0;31617:17;;31589:595;31738:17;;:21;31734:439;;32001:10;31995:17;32062:15;32049:10;32045:2;32041:19;32034:44;31949:148;32144:12;32137:20;;-1:-1:-1;;;32137:20:0;;;;;;;;:::i;1442:241:-1:-;;1546:2;1534:9;1525:7;1521:23;1517:32;1514:2;;;-1:-1;;1552:12;1514:2;72:20;;-1:-1;;;;;24031:54;;24740:35;;24730:2;;-1:-1;;24779:12;1690:392;;1830:2;;1818:9;1809:7;1805:23;1801:32;1798:2;;;-1:-1;;1836:12;1798:2;1887:17;1881:24;1925:18;1917:6;1914:30;1911:2;;;-1:-1;;1947:12;1911:2;2034:22;;281:4;269:17;;265:27;-1:-1;255:2;;-1:-1;;296:12;255:2;336:6;330:13;358:80;373:64;430:6;373:64;:::i;:::-;358:80;:::i;:::-;466:21;;;523:14;;;;498:17;;;612;;;603:27;;;;600:36;-1:-1;597:2;;;-1:-1;;639:12;597:2;-1:-1;665:10;;659:217;684:6;681:1;678:13;659:217;;;1379:13;;752:61;;706:1;699:9;;;;;827:14;;;;855;;659:217;;;-1:-1;1967:99;1792:290;-1:-1;;;;;;;1792:290::o;2089:257::-;;2201:2;2189:9;2180:7;2176:23;2172:32;2169:2;;;-1:-1;;2207:12;2169:2;971:6;965:13;24886:5;23865:13;23858:21;24864:5;24861:32;24851:2;;-1:-1;;24897:12;2353:241;;2457:2;2445:9;2436:7;2432:23;2428:32;2425:2;;;-1:-1;;2463:12;2425:2;-1:-1;1231:20;;2419:175;-1:-1;2419:175::o;2601:263::-;;2716:2;2704:9;2695:7;2691:23;2687:32;2684:2;;;-1:-1;;2722:12;2684:2;-1:-1;1379:13;;2678:186;-1:-1;2678:186::o;2871:397::-;;;3002:2;2990:9;2981:7;2977:23;2973:32;2970:2;;;-1:-1;;3008:12;2970:2;-1:-1;;1379:13;;3171:2;3220:22;;;1102:13;1379;;1102;;-1:-1;2964:304::o;3275:535::-;;;;3424:2;3412:9;3403:7;3399:23;3395:32;3392:2;;;-1:-1;;3430:12;3392:2;1385:6;1379:13;3482:74;;3593:2;3647:9;3643:22;1379:13;3601:74;;3712:2;3766:9;3762:22;1379:13;3720:74;;3386:424;;;;;:::o;11190:271::-;;5118:5;22776:12;5229:52;5274:6;5269:3;5262:4;5255:5;5251:16;5229:52;:::i;:::-;5293:16;;;;;11324:137;-1:-1;;11324:137::o;11468:222::-;-1:-1;;;;;24031:54;;;;4060:37;;11595:2;11580:18;;11566:124::o;11697:333::-;-1:-1;;;;;24031:54;;;4060:37;;24031:54;;12016:2;12001:18;;4060:37;11852:2;11837:18;;11823:207::o;12037:1036::-;-1:-1;;;;;24031:54;;;4060:37;;24031:54;;;12541:2;12526:18;;4060:37;12624:2;12609:18;;11141:37;;;;12707:2;12692:18;;11141:37;;;;12798:3;12783:19;;5400:58;;;;24042:42;12875:19;;5400:58;24031:54;;;12974:3;12959:19;;4060:37;13058:3;13043:19;;11141:37;;;;12376:3;12361:19;;12347:726::o;13080:333::-;-1:-1;;;;;24031:54;;;;4060:37;;13399:2;13384:18;;11141:37;13235:2;13220:18;;13206:207::o;13420:310::-;;13567:2;13588:17;13581:47;5615:5;22776:12;23320:6;13567:2;13556:9;13552:18;23308:19;5709:52;5754:6;23348:14;13556:9;23348:14;13567:2;5735:5;5731:16;5709:52;:::i;:::-;24660:7;24644:14;-1:-1;;24640:28;5773:39;;;;23348:14;5773:39;;13538:192;-1:-1;;13538:192::o;13737:416::-;13937:2;13951:47;;;6049:2;13922:18;;;23308:19;6085:34;23348:14;;;6065:55;-1:-1;;;6140:12;;;6133:30;6182:12;;;13908:245::o;14160:416::-;14360:2;14374:47;;;6433:2;14345:18;;;23308:19;6469:29;23348:14;;;6449:50;6518:12;;;14331:245::o;14583:416::-;14783:2;14797:47;;;6769:2;14768:18;;;23308:19;-1:-1;;;23348:14;;;6785:37;6841:12;;;14754:245::o;15006:416::-;15206:2;15220:47;;;7092:2;15191:18;;;23308:19;7128:32;23348:14;;;7108:53;7180:12;;;15177:245::o;15429:416::-;15629:2;15643:47;;;7431:2;15614:18;;;23308:19;-1:-1;;;23348:14;;;7447:38;7504:12;;;15600:245::o;15852:416::-;16052:2;16066:47;;;7755:2;16037:18;;;23308:19;7791:34;23348:14;;;7771:55;-1:-1;;;7846:12;;;7839:30;7888:12;;;16023:245::o;16275:416::-;16475:2;16489:47;;;8139:2;16460:18;;;23308:19;8175:28;23348:14;;;8155:49;8223:12;;;16446:245::o;16698:416::-;16898:2;16912:47;;;8474:2;16883:18;;;23308:19;-1:-1;;;23348:14;;;8490:37;8546:12;;;16869:245::o;17121:416::-;17321:2;17335:47;;;8797:2;17306:18;;;23308:19;8833:34;23348:14;;;8813:55;-1:-1;;;8888:12;;;8881:25;8925:12;;;17292:245::o;17544:416::-;17744:2;17758:47;;;17729:18;;;23308:19;9212:34;23348:14;;;9192:55;9266:12;;;17715:245::o;17967:416::-;18167:2;18181:47;;;9517:1;18152:18;;;23308:19;-1:-1;;;23348:14;;;9532:27;9578:12;;;18138:245::o;18390:416::-;18590:2;18604:47;;;9829:2;18575:18;;;23308:19;9865:31;23348:14;;;9845:52;9916:12;;;18561:245::o;18813:416::-;19013:2;19027:47;;;10167:2;18998:18;;;23308:19;10203:34;23348:14;;;10183:55;-1:-1;;;10258:12;;;10251:34;10304:12;;;18984:245::o;19236:416::-;19436:2;19450:47;;;10555:2;19421:18;;;23308:19;10591:33;23348:14;;;10571:54;10644:12;;;19407:245::o;19659:416::-;19859:2;19873:47;;;10895:2;19844:18;;;23308:19;10931:34;23348:14;;;10911:55;-1:-1;;;10986:12;;;10979:46;11044:12;;;19830:245::o;20082:222::-;11141:37;;;20209:2;20194:18;;20180:124::o;20311:333::-;11141:37;;;-1:-1;;;;;24031:54;20630:2;20615:18;;4060:37;20466:2;20451:18;;20437:207::o;20651:832::-;;20948:3;20937:9;20933:19;11171:5;11148:3;11141:37;21121:2;24263:24;21121:2;21110:9;21106:18;5400:58;20948:3;21158:2;21147:9;21143:18;21136:48;21198:108;4453:5;22776:12;23320:6;23315:3;23308:19;23348:14;20937:9;23348:14;4465:93;;21121:2;4629:5;22630:14;4641:21;;-1:-1;4668:260;4693:6;4690:1;4687:13;4668:260;;;4754:13;;-1:-1;;;;;24031:54;4060:37;;23163:14;;;;3971;;;;24042:42;4708:9;4668:260;;;-1:-1;;;;;;;24031:54;;;;21385:2;21370:18;;4060:37;-1:-1;;;21468:3;21453:19;11141:37;21190:116;20919:564;-1:-1;;;20919:564::o;21490:444::-;11141:37;;;21837:2;21822:18;;11141:37;;;;-1:-1;;;;;24031:54;21920:2;21905:18;;4060:37;21673:2;21658:18;;21644:290::o;21941:256::-;22003:2;21997:9;22029:17;;;22104:18;22089:34;;22125:22;;;22086:62;22083:2;;;22161:1;;22151:12;22083:2;22003;22170:22;21981:216;;-1:-1;21981:216::o;22204:304::-;;22363:18;22355:6;22352:30;22349:2;;;-1:-1;;22385:12;22349:2;-1:-1;22430:4;22418:17;;;22483:15;;22286:222::o;24300:268::-;24365:1;24372:101;24386:6;24383:1;24380:13;24372:101;;;24453:11;;;24447:18;24434:11;;;24427:39;24408:2;24401:10;24372:101;;;24488:6;24485:1;24482:13;24479:2;;;-1:-1;;24365:1;24535:16;;24528:27;24349:219::o

ipfs://16d25f432d60074f19006cff370e0401e4bc4820118790d740cebe29275b7a99