Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
•  contract ERC20 is Context, IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _burnFrom(address account, u ...
•    - function _beforeTokenTransfer(address ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• interface IveFPIS
•    - function commit_transfer_ownership ( ...
•    - function apply_transfer_ownership ( ...
•    - function commit_smart_wallet_checker ...
•    - function apply_smart_wallet_checker ( ...
•    - function recoverERC20 ( address token ...
•    - function get_last_user_slope ( addres ...
•    - function get_last_user_bias ( address ...
•    - function get_last_user_point ( addres ...
•    - function user_point_history__ts ( add ...
•    - function get_last_point ( )
•    - function locked__end ( address _addr ...
•    - function locked__amount ( address _ad ...
•    - function curr_period_start ( )
•    - function next_period_start ( )
•    - function checkpoint ( )
•    - function create_lock ( uint256 _value ...
•    - function increase_amount ( uint256 _v ...
•    - function app_increase_amount_for ( ad ...
•    - function increase_unlock_time ( uint2 ...
•    - function proxy_add ( address _staker_ ...
•    - function proxy_slash ( address _stake ...
•    - function withdraw ( )
•    - function transfer_from_app ( address ...
•    - function transfer_to_app ( address _s ...
•    - function balanceOf ( address addr )
•    - function balanceOf ( address addr, ui ...
•    - function balanceOfAt ( address addr, ...
•    - function totalSupply ( )
•    - function totalSupply ( uint256 t )
•    - function totalSupplyAt ( uint256 _blo ...
•    - function totalFPISSupply ( )
•    - function totalFPISSupplyAt ( uint256 ...
•    - function toggleEmergencyUnlock ( )
•    - function toggleAppIncreaseAmountFors ...
•    - function toggleTransferFromApp ( )
•    - function toggleTransferToApp ( )
•    - function toggleProxyAdds ( )
•    - function toggleProxySlashes ( )
•    - function adminSetProxy ( address _pro ...
•    - function adminToggleHistoricalProxy ( ...
•    - function stakerSetProxy ( address _pr ...
•    - function token ( )
•    - function supply ( )
•    - function locked ( address arg0 )
•    - function epoch ( )
•    - function point_history ( uint256 arg0 ...
•    - function user_point_history ( address ...
•    - function user_point_epoch ( address a ...
•    - function slope_changes ( uint256 arg0 ...
•    - function appIncreaseAmountForsEnabled ...
•    - function appTransferFromsEnabled ( )
•    - function appTransferTosEnabled ( )
•    - function proxyAddsEnabled ( )
•    - function proxySlashesEnabled ( )
•    - function emergencyUnlockActive ( )
•    - function current_proxy ( )
•    - function historical_proxies ( address ...
•    - function staker_whitelisted_proxy ( a ...
•    - function user_proxy_balance ( address ...
•    - function name ( )
•    - function symbol ( )
•    - function version ( )
•    - function decimals ( )
•    - function future_smart_wallet_checker ...
•    - function smart_wallet_checker ( )
•    - function admin ( )
•    - function future_admin ( )
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function sqrt(uint y)
•  contract Owned
•    - function nominateNewOwner(address _ow ...
•    - function acceptOwnership()
• library TransferHelper
•    - function safeApprove(address token, a ...
•    - function safeTransfer(address token, ...
•    - function safeTransferFrom(address tok ...
•    - function safeTransferETH(address to, ...
•  contract veFPISYieldDistributorV5 ... *
•    - function fractionParticipating()
•    - function eligibleCurrentVeFPIS(addres ...
•    - function lastTimeYieldApplicable()
•    - function yieldPerVeFPIS()
•    - function earned(address account)
•    - function getYieldForDuration()
•    - function _checkpointUser(address acco ...
•    - function _syncEarned(address account)
•    - function checkpointOtherUser(address ...
•    - function checkpoint()
•    - function getYield()
•    - function sync()
•    - function notifyRewardAmount(uint256 a ...
•    - function recoverERC20(address tokenAd ...
•    - function setYieldDuration(uint256 _yi ...
•    - function greylistAddress(address _add ...
•    - function toggleRewardNotifier(address ...
•    - function setPauses(bool _yieldCollect ...
•    - function setYieldRate(uint256 _new_ra ...
•    - function setTimelock(address _new_tim ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-02-15
*/

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;

// Sources flattened with hardhat v2.12.5 https://hardhat.org

// File contracts/Common/Context.sol


/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with 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 payable(msg.sender);
    }

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


// File contracts/Math/SafeMath.sol


/**
 * @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, 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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// File contracts/ERC20/IERC20.sol



/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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


// File contracts/Utils/Address.sol


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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File contracts/ERC20/ERC20.sol





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20Mintable}.
 *
 * 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 returns (string memory) {
        return _name;
    }

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

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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.approve(address spender, uint256 amount)
     */
    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 the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

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

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


    /**
     * @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 is 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 Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal virtual {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }

    /**
     * @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:using-hooks.adoc[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}


// File contracts/ERC20/SafeERC20.sol




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File contracts/Curve/IveFPIS.sol

pragma abicoder v2;

interface IveFPIS {

    struct Point {
        int128 bias;
        int128 slope;
        uint256 ts;
        uint256 blk;
        uint256 fpis_amt;
    }

    struct LockedBalance {
        int128 amount;
        uint256 end;
    }

  function commit_transfer_ownership ( address addr ) external;
  function apply_transfer_ownership (  ) external;
  function commit_smart_wallet_checker ( address addr ) external;
  function apply_smart_wallet_checker (  ) external;
  function recoverERC20 ( address token_addr, uint256 amount ) external;
  function get_last_user_slope ( address addr ) external view returns ( int128 );
  function get_last_user_bias ( address addr ) external view returns ( int128 );
  function get_last_user_point ( address addr ) external view returns ( Point memory);
  function user_point_history__ts ( address _addr, uint256 _idx ) external view returns ( uint256 );
  function get_last_point (  ) external view returns ( Point memory);
  function locked__end ( address _addr ) external view returns ( uint256 );
  function locked__amount ( address _addr ) external view returns ( int128 );
  function curr_period_start (  ) external view returns ( uint256 );
  function next_period_start (  ) external view returns ( uint256 );
  function checkpoint (  ) external;
  function create_lock ( uint256 _value, uint256 _unlock_time ) external;
  function increase_amount ( uint256 _value ) external;
  function app_increase_amount_for ( address _staker_addr, address _app_addr, uint256 _value ) external;
  function increase_unlock_time ( uint256 _unlock_time ) external;
  function proxy_add ( address _staker_addr, uint256 _add_amt ) external;
  function proxy_slash ( address _staker_addr, uint256 _slash_amt ) external;
  function withdraw (  ) external;
  function transfer_from_app ( address _staker_addr, address _app_addr, int128 _transfer_amt ) external;
  function transfer_to_app ( address _staker_addr, address _app_addr, int128 _transfer_amt ) external;
  function balanceOf ( address addr ) external view returns ( uint256 );
  function balanceOf ( address addr, uint256 _t ) external view returns ( uint256 );
  function balanceOfAt ( address addr, uint256 _block ) external view returns ( uint256 );
  function totalSupply (  ) external view returns ( uint256 );
  function totalSupply ( uint256 t ) external view returns ( uint256 );
  function totalSupplyAt ( uint256 _block ) external view returns ( uint256 );
  function totalFPISSupply (  ) external view returns ( uint256 );
  function totalFPISSupplyAt ( uint256 _block ) external view returns ( uint256 );
  function toggleEmergencyUnlock (  ) external;
  function toggleAppIncreaseAmountFors (  ) external;
  function toggleTransferFromApp (  ) external;
  function toggleTransferToApp (  ) external;
  function toggleProxyAdds (  ) external;
  function toggleProxySlashes (  ) external;
  function adminSetProxy ( address _proxy ) external;
  function adminToggleHistoricalProxy ( address _proxy ) external;
  function stakerSetProxy ( address _proxy ) external;
  function token (  ) external view returns ( address );
  function supply (  ) external view returns ( uint256 );
  function locked ( address arg0 ) external view returns ( LockedBalance memory );
  function epoch (  ) external view returns ( uint256 );
  function point_history ( uint256 arg0 ) external view returns ( Point memory );
  function user_point_history ( address arg0, uint256 arg1 ) external view returns ( Point memory );
  function user_point_epoch ( address arg0 ) external view returns ( uint256 );
  function slope_changes ( uint256 arg0 ) external view returns ( int128 );
  function appIncreaseAmountForsEnabled (  ) external view returns ( bool );
  function appTransferFromsEnabled (  ) external view returns ( bool );
  function appTransferTosEnabled (  ) external view returns ( bool );
  function proxyAddsEnabled (  ) external view returns ( bool );
  function proxySlashesEnabled (  ) external view returns ( bool );
  function emergencyUnlockActive (  ) external view returns ( bool );
  function current_proxy (  ) external view returns ( address );
  function historical_proxies ( address arg0 ) external view returns ( bool );
  function staker_whitelisted_proxy ( address arg0 ) external view returns ( address );
  function user_proxy_balance ( address arg0 ) external view returns ( uint256 );
  function name (  ) external view returns ( string memory);
  function symbol (  ) external view returns ( string memory);
  function version (  ) external view returns ( string memory);
  function decimals (  ) external view returns ( uint256 );
  function future_smart_wallet_checker (  ) external view returns ( address );
  function smart_wallet_checker (  ) external view returns ( address );
  function admin (  ) external view returns ( address );
  function future_admin (  ) external view returns ( address );
}


// File contracts/Math/Math.sol


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

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

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

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}


// File contracts/Staking/Owned.sol


// https://docs.synthetix.io/contracts/Owned
contract Owned {
    address public owner;
    address public nominatedOwner;

    constructor (address _owner) public {
        require(_owner != address(0), "Owner address cannot be 0");
        owner = _owner;
        emit OwnerChanged(address(0), _owner);
    }

    function nominateNewOwner(address _owner) external onlyOwner {
        nominatedOwner = _owner;
        emit OwnerNominated(_owner);
    }

    function acceptOwnership() external {
        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
        emit OwnerChanged(owner, nominatedOwner);
        owner = nominatedOwner;
        nominatedOwner = address(0);
    }

    modifier onlyOwner {
        require(msg.sender == owner, "Only the contract owner may perform this action");
        _;
    }

    event OwnerNominated(address newOwner);
    event OwnerChanged(address oldOwner, address newOwner);
}


// File contracts/Uniswap/TransferHelper.sol


// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
    }

    function safeTransfer(address token, address to, uint value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
    }

    function safeTransferFrom(address token, address from, address to, uint value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
    }

    function safeTransferETH(address to, uint value) internal {
        (bool success,) = to.call{value:value}(new bytes(0));
        require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
    }
}


// File contracts/Utils/ReentrancyGuard.sol


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


// File contracts/Staking/veFPISYieldDistributorV5.sol


// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ======================veFPISYieldDistributorV5=======================
// ====================================================================
// Distributes Frax protocol yield based on the claimer's veFPIS balance
// V3: Yield will now not accrue for unlocked veFPIS

// Frax Finance: https://github.com/FraxFinance

// Primary Author(s)
// Travis Moore: https://github.com/FortisFortuna

// Reviewer(s) / Contributor(s)
// Jason Huan: https://github.com/jasonhuan
// Sam Kazemian: https://github.com/samkazemian
// Dennis: https://github.com/denett

// Originally inspired by Synthetix.io, but heavily modified by the Frax team (veFPIS portion)
// https://github.com/Synthetixio/synthetix/blob/develop/contracts/StakingRewards.sol








contract veFPISYieldDistributorV5 is Owned, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for ERC20;

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

    // Instances
    IveFPIS private veFPIS;
    ERC20 public emittedToken;

    // Addresses
    address public emitted_token_address;

    // Admin addresses
    address public timelock_address;

    // Constant for price precision
    uint256 private constant PRICE_PRECISION = 1e6;

    // Yield and period related
    uint256 public periodFinish;
    uint256 public lastUpdateTime;
    uint256 public yieldRate;
    uint256 public yieldDuration = 604800; // 7 * 86400  (7 days)
    mapping(address => bool) public reward_notifiers;

    // Yield tracking
    uint256 public yieldPerVeFPISStored = 0;
    mapping(address => uint256) public userYieldPerTokenPaid;
    mapping(address => uint256) public yields;

    // veFPIS tracking
    uint256 public totalVeFPISParticipating = 0;
    uint256 public totalVeFPISSupplyStored = 0;
    mapping(address => bool) public userIsInitialized;
    mapping(address => uint256) public userVeFPISCheckpointed;
    mapping(address => uint256) public userVeFPISEndpointCheckpointed;
    mapping(address => uint256) private lastRewardClaimTime; // staker addr -> timestamp

    // Greylists
    mapping(address => bool) public greylist;

    // Admin booleans for emergencies
    bool public yieldCollectionPaused = false; // For emergencies

    struct LockedBalance {
        int128 amount;
        uint256 end;
    }

    /* ========== MODIFIERS ========== */

    modifier onlyByOwnGov() {
        require( msg.sender == owner || msg.sender == timelock_address, "Not owner or timelock");
        _;
    }

    modifier notYieldCollectionPaused() {
        require(yieldCollectionPaused == false, "Yield collection is paused");
        _;
    }

    modifier checkpointUser(address account) {
        _checkpointUser(account);
        _;
    }

    /* ========== CONSTRUCTOR ========== */

    constructor (
        address _owner,
        address _emittedToken,
        address _timelock_address,
        address _veFPIS_address
    ) Owned(_owner) {
        emitted_token_address = _emittedToken;
        emittedToken = ERC20(_emittedToken);

        veFPIS = IveFPIS(_veFPIS_address);
        lastUpdateTime = block.timestamp;
        timelock_address = _timelock_address;

        reward_notifiers[_owner] = true;
    }

    /* ========== VIEWS ========== */

    function fractionParticipating() external view returns (uint256) {
        return totalVeFPISParticipating.mul(PRICE_PRECISION).div(totalVeFPISSupplyStored);
    }

    // Only positions with locked veFPIS can accrue yield. Otherwise, expired-locked veFPIS
    // is de-facto rewards for FPIS.
    function eligibleCurrentVeFPIS(address account) public view returns (uint256 eligible_vefpis_bal, uint256 stored_ending_timestamp) {
        uint256 curr_vefpis_bal = veFPIS.balanceOf(account);
        
        // Stored is used to prevent abuse
        stored_ending_timestamp = userVeFPISEndpointCheckpointed[account];

        // Only unexpired veFPIS should be eligible
        if (stored_ending_timestamp != 0 && (block.timestamp >= stored_ending_timestamp)){
            eligible_vefpis_bal = 0;
        }
        else if (block.timestamp >= stored_ending_timestamp){
            eligible_vefpis_bal = 0;
        }
        else {
            eligible_vefpis_bal = curr_vefpis_bal;
        }
    }

    function lastTimeYieldApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function yieldPerVeFPIS() public view returns (uint256) {
        if (totalVeFPISSupplyStored == 0) {
            return yieldPerVeFPISStored;
        } else {
            return (
                yieldPerVeFPISStored.add(
                    lastTimeYieldApplicable()
                        .sub(lastUpdateTime)
                        .mul(yieldRate)
                        .mul(1e18)
                        .div(totalVeFPISSupplyStored)
                )
            );
        }
    }

    function earned(address account) public view returns (uint256) {
        // Uninitialized users should not earn anything yet
        if (!userIsInitialized[account]) return 0;

        // Get eligible veFPIS balances
        (uint256 eligible_current_vefpis, uint256 ending_timestamp) = eligibleCurrentVeFPIS(account);

        // If your veFPIS is unlocked
        uint256 eligible_time_fraction = PRICE_PRECISION;
        if (eligible_current_vefpis == 0){
            // And you already claimed after expiration
            if (lastRewardClaimTime[account] >= ending_timestamp) {
                // You get NOTHING. You LOSE. Good DAY ser!
                return 0;
            }
            // You haven't claimed yet
            else {
                // Slow rewards decay
                uint256 eligible_time = (ending_timestamp).sub(lastRewardClaimTime[account]);
                uint256 total_time = (block.timestamp).sub(lastRewardClaimTime[account]);
                eligible_time_fraction = PRICE_PRECISION.mul(eligible_time).div(total_time);
            }
        }

        // If the amount of veFPIS increased, only pay off based on the old balance to prevent people from staking little,
        // waiting, staking a lot, then claiming.
        // Otherwise, take the midpoint
        uint256 vefpis_balance_to_use;
        {
            uint256 old_vefpis_balance = userVeFPISCheckpointed[account];
            if (eligible_current_vefpis > old_vefpis_balance){
                vefpis_balance_to_use = old_vefpis_balance;
            }
            else if (eligible_current_vefpis == 0) {
                // Will get multiplied by eligible_time_fraction anyways.
                vefpis_balance_to_use = old_vefpis_balance.add(uint256(uint128(veFPIS.locked(account).amount))).div(2);
            }
            else {
                // Average the two veFPIS balances
                vefpis_balance_to_use = ((eligible_current_vefpis).add(old_vefpis_balance)).div(2); 
            }
        }

        return (
            vefpis_balance_to_use
                .mul(yieldPerVeFPIS().sub(userYieldPerTokenPaid[account]))
                .mul(eligible_time_fraction)
                .div(1e18 * PRICE_PRECISION)
                .add(yields[account])
        );
    }

    function getYieldForDuration() external view returns (uint256) {
        return (yieldRate.mul(yieldDuration));
    }

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

    function _checkpointUser(address account) internal {
        // Need to retro-adjust some things if the period hasn't been renewed, then start a new one
        sync();

        // Calculate the earnings first
        _syncEarned(account);

        // Get the old and the new veFPIS balances
        uint256 old_vefpis_balance = userVeFPISCheckpointed[account];
        uint256 new_vefpis_balance = veFPIS.balanceOf(account);

        // Update the user's stored veFPIS balance
        userVeFPISCheckpointed[account] = new_vefpis_balance;

        // Update the user's stored ending timestamp
        IveFPIS.LockedBalance memory curr_locked_bal_pack = veFPIS.locked(account);
        userVeFPISEndpointCheckpointed[account] = curr_locked_bal_pack.end;

        // Update the total amount participating
        if (new_vefpis_balance >= old_vefpis_balance) {
            uint256 weight_diff = new_vefpis_balance.sub(old_vefpis_balance);
            totalVeFPISParticipating = totalVeFPISParticipating.add(weight_diff);
        } else {
            uint256 weight_diff = old_vefpis_balance.sub(new_vefpis_balance);
            totalVeFPISParticipating = totalVeFPISParticipating.sub(weight_diff);
        }

        // Mark the user as initialized
        if (!userIsInitialized[account]) {
            userIsInitialized[account] = true;
            lastRewardClaimTime[account] = block.timestamp;
        }
    }

    function _syncEarned(address account) internal {
        if (account != address(0)) {
            uint256 earned0 = earned(account);
            yields[account] = earned0;
            userYieldPerTokenPaid[account] = yieldPerVeFPISStored;
        }
    }

    // Anyone can checkpoint another user
    function checkpointOtherUser(address user_addr) external {
        _checkpointUser(user_addr);
    }

    // Checkpoints the user
    function checkpoint() external {
        _checkpointUser(msg.sender);
    }

    function getYield() external nonReentrant notYieldCollectionPaused checkpointUser(msg.sender) returns (uint256 yield0) {
        require(greylist[msg.sender] == false, "Address has been greylisted");

        yield0 = yields[msg.sender];
        if (yield0 > 0) {
            yields[msg.sender] = 0;
            TransferHelper.safeTransfer(
                emitted_token_address,
                msg.sender,
                yield0
            );
            emit YieldCollected(msg.sender, yield0, emitted_token_address);
        }

        lastRewardClaimTime[msg.sender] = block.timestamp;
    }


    function sync() public {
        // Update the total veFPIS supply
        yieldPerVeFPISStored = yieldPerVeFPIS();
        totalVeFPISSupplyStored = veFPIS.totalSupply();
        lastUpdateTime = lastTimeYieldApplicable();
    }

    function notifyRewardAmount(uint256 amount) external {
        // Only whitelisted addresses can notify rewards
        require(reward_notifiers[msg.sender], "Sender not whitelisted");

        // Handle the transfer of emission tokens via `transferFrom` to reduce the number
        // of transactions required and ensure correctness of the smission amount
        emittedToken.safeTransferFrom(msg.sender, address(this), amount);

        // Update some values beforehand
        sync();

        // Update the new yieldRate
        if (block.timestamp >= periodFinish) {
            yieldRate = amount.div(yieldDuration);
        } else {
            uint256 remaining = periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(yieldRate);
            yieldRate = amount.add(leftover).div(yieldDuration);
        }
        
        // Update duration-related info
        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp.add(yieldDuration);

        emit RewardAdded(amount, yieldRate);
    }

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

    // Added to support recovering LP Yield and other mistaken tokens from other systems to be distributed to holders
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyByOwnGov {
        // Only the owner address can ever receive the recovery withdrawal
        TransferHelper.safeTransfer(tokenAddress, owner, tokenAmount);
        emit RecoveredERC20(tokenAddress, tokenAmount);
    }

    function setYieldDuration(uint256 _yieldDuration) external onlyByOwnGov {
        require( periodFinish == 0 || block.timestamp > periodFinish, "Previous yield period must be complete before changing the duration for the new period");
        yieldDuration = _yieldDuration;
        emit YieldDurationUpdated(yieldDuration);
    }

    function greylistAddress(address _address) external onlyByOwnGov {
        greylist[_address] = !(greylist[_address]);
    }

    function toggleRewardNotifier(address notifier_addr) external onlyByOwnGov {
        reward_notifiers[notifier_addr] = !reward_notifiers[notifier_addr];
    }

    function setPauses(bool _yieldCollectionPaused) external onlyByOwnGov {
        yieldCollectionPaused = _yieldCollectionPaused;
    }

    function setYieldRate(uint256 _new_rate0, bool sync_too) external onlyByOwnGov {
        yieldRate = _new_rate0;

        if (sync_too) {
            sync();
        }
    }

    function setTimelock(address _new_timelock) external onlyByOwnGov {
        timelock_address = _new_timelock;
    }

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

    event RewardAdded(uint256 reward, uint256 yieldRate);
    event OldYieldCollected(address indexed user, uint256 yield, address token_address);
    event YieldCollected(address indexed user, uint256 yield, address token_address);
    event YieldDurationUpdated(uint256 newDuration);
    event RecoveredERC20(address token, uint256 amount);
    event YieldPeriodRenewed(address token, uint256 yieldRate);
    event DefaultInitialization();

    /* ========== A CHICKEN ========== */
    //
    //         ,~.
    //      ,-'__ `-,
    //     {,-'  `. }              ,')
    //    ,( a )   `-.__         ,',')~,
    //   <=.) (         `-.__,==' ' ' '}
    //     (   )                      /)
    //      `-'\   ,                    )
    //          |  \        `~.        /
    //          \   `._        \      /
    //           \     `._____,'    ,'
    //            `-.             ,'
    //               `-._     _,-'
    //                   77jj'
    //                  //_||
    //               __//--'/`
    //             ,--'/`  '
    //
    // [hjw] https://textart.io/art/vw6Sa3iwqIRGkZsN1BC2vweF/chicken
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_emittedToken","type":"address"},{"internalType":"address","name":"_timelock_address","type":"address"},{"internalType":"address","name":"_veFPIS_address","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[],"name":"DefaultInitialization","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"yield","type":"uint256"},{"indexed":false,"internalType":"address","name":"token_address","type":"address"}],"name":"OldYieldCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoveredERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"yieldRate","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"yield","type":"uint256"},{"indexed":false,"internalType":"address","name":"token_address","type":"address"}],"name":"YieldCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"YieldDurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"yieldRate","type":"uint256"}],"name":"YieldPeriodRenewed","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"checkpoint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user_addr","type":"address"}],"name":"checkpointOtherUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"eligibleCurrentVeFPIS","outputs":[{"internalType":"uint256","name":"eligible_vefpis_bal","type":"uint256"},{"internalType":"uint256","name":"stored_ending_timestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emittedToken","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emitted_token_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fractionParticipating","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getYield","outputs":[{"internalType":"uint256","name":"yield0","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getYieldForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"greylist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"greylistAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastTimeYieldApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"reward_notifiers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_yieldCollectionPaused","type":"bool"}],"name":"setPauses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_new_timelock","type":"address"}],"name":"setTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_yieldDuration","type":"uint256"}],"name":"setYieldDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_new_rate0","type":"uint256"},{"internalType":"bool","name":"sync_too","type":"bool"}],"name":"setYieldRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sync","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timelock_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"notifier_addr","type":"address"}],"name":"toggleRewardNotifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalVeFPISParticipating","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalVeFPISSupplyStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userIsInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userVeFPISCheckpointed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userVeFPISEndpointCheckpointed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userYieldPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldCollectionPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldPerVeFPIS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldPerVeFPISStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"yields","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000ff5b4bcbf765fe363269114e1c765229a29edefd000000000000000000000000c2544a32872a91f4a553b404c6950e89de901fdb0000000000000000000000008412ebf45bac1b340bbe8f318b928c466c4e39ca000000000000000000000000574c154c83432b0a45ba3ad2429c3fa242ed7359

-----Decoded View---------------
Arg [0] : _owner (address): 0xfF5B4BCbf765FE363269114e1c765229a29eDeFD
Arg [1] : _emittedToken (address): 0xc2544A32872A91F4A553b404C6950e89De901fdb
Arg [2] : _timelock_address (address): 0x8412ebf45bAC1B340BbE8F318b928C466c4E39CA
Arg [3] : _veFPIS_address (address): 0x574C154C83432B0A45BA3ad2429C3fA242eD7359

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000ff5b4bcbf765fe363269114e1c765229a29edefd
Arg [1] : 000000000000000000000000c2544a32872a91f4a553b404c6950e89de901fdb
Arg [2] : 0000000000000000000000008412ebf45bac1b340bbe8f318b928c466c4e39ca
Arg [3] : 000000000000000000000000574c154c83432b0a45ba3ad2429c3fa242ed7359

45779:13476:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50033:2331;;;;;;:::i;:::-;;:::i;:::-;;;552:25:1;;;540:2;525:18;50033:2331:0;;;;;;;;46827:49;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;753:14:1;;746:22;728:41;;716:2;701:18;46827:49:0;588:187:1;39494:141:0;;;;;;:::i;:::-;;:::i;:::-;;52372:119;;;:::i;46728:43::-;;;;;;47129:40;;;;;;:::i;:::-;;;;;;;;;;;;;;;;46063:36;;;;;;;;;;;;956:42:1;944:55;;;926:74;;914:2;899:18;46063:36:0;780:226:1;46545:39:0;;;;;;55405:1067;;;;;;:::i;:::-;;:::i;46883:57::-;;;;;;:::i;:::-;;;;;;;;;;;;;;57439:160;;;;;;:::i;:::-;;:::i;46654:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;39262:29;;;;;;;;;49382:130;;;:::i;46947:65::-;;;;;;:::i;:::-;;;;;;;;;;;;;;46367:24;;;;;;56963:334;;;;;;:::i;:::-;;:::i;39643:271::-;;;:::i;54541:612::-;;;:::i;49520:505::-;;;:::i;56655:300::-;;;;;;:::i;:::-;;:::i;48656:718::-;;;;;;:::i;:::-;;:::i;:::-;;;;1629:25:1;;;1685:2;1670:18;;1663:34;;;;1602:18;48656:718:0;1455:248:1;39235:20:0;;;;;;;;;57750:179;;;;;;:::i;:::-;;:::i;57305:126::-;;;;;;:::i;:::-;;:::i;57607:135::-;;;;;;:::i;:::-;;:::i;54317:102::-;;;;;;:::i;:::-;;:::i;46465:48::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;46591:56;;;;;;:::i;:::-;;;;;;;;;;;;;;47217:41;;;;;;;;;57937:117;;;;;;:::i;:::-;;:::i;54456:77::-;;;:::i;46331:29::-;;;;;;46132:31;;;;;;;;;46398:37;;;;;;46778:42;;;;;;46011:25;;;;;;;;;46297:27;;;;;;48352:165;;;:::i;55163:234::-;;;:::i;50033:2331::-;50173:26;;;50087:7;50173:26;;;:17;:26;;;;;;;;50168:41;;-1:-1:-1;50208:1:0;;50033:2331;-1:-1:-1;50033:2331:0:o;50168:41::-;50264:31;50297:24;50325:30;50347:7;50325:21;:30::i;:::-;50263:92;;-1:-1:-1;50263:92:0;-1:-1:-1;46252:3:0;50407:30;50470:28;;;50466:668;;50575:28;;;;;;;:19;:28;;;;;;:48;-1:-1:-1;50571:552:0;;-1:-1:-1;50712:1:0;;50033:2331;-1:-1:-1;;;;50033:2331:0:o;50571:552::-;50893:28;;;50846:21;50893:28;;;:19;:28;;;;;;50870:52;;50871:16;;50870:22;:52::i;:::-;50984:28;;;50941:18;50984:28;;;:19;:28;;;;;;50846:76;;-1:-1:-1;50941:18:0;50962:51;;50963:15;;50962:21;:51::i;:::-;50941:72;-1:-1:-1;51057:50:0;50941:72;51057:34;46252:3;51077:13;51057:19;:34::i;:::-;:38;;:50::i;:::-;51032:75;;50788:335;;50571:552;51446:31;;;51362:29;51446:31;;;:22;:31;;;;;;51496:44;;;51492:580;;;51584:18;51560:42;;51492:580;;;51641:23;51668:1;51641:28;51637:435;;51828:6;;:22;;;;;:6;944:55:1;;;51828:22:0;;;926:74:1;51789:78:0;;51865:1;;51789:71;;51828:6;;;;:13;;899:18:1;;51828:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:29;51789:18;;51812:47;;51789:22;:71::i;:78::-;51765:102;;51637:435;;;51997:58;52053:1;51998:49;51999:23;52028:18;51998:29;:49::i;51997:58::-;51973:82;;51637:435;-1:-1:-1;52329:15:0;;;;;;;:6;:15;;;;;;52117:228;;:189;52283:22;46252:3;52283:4;:22;:::i;:::-;52182:30;;;;;;;:21;:30;;;;;;52117:143;;52237:22;;52117:97;;52161:52;;:16;:14;:16::i;:::-;:20;;:52::i;:::-;52117:21;;:43;:97::i;:::-;:119;;:143::i;:189::-;:211;;:228::i;:::-;52095:261;50033:2331;-1:-1:-1;;;;;;50033:2331:0:o;39494:141::-;39974:5;;;;39960:10;:19;39952:79;;;;;;;3962:2:1;39952:79:0;;;3944:21:1;4001:2;3981:18;;;3974:30;4040:34;4020:18;;;4013:62;4111:17;4091:18;;;4084:45;4146:19;;39952:79:0;;;;;;;;;39566:14:::1;:23:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;39605:22:::1;::::0;926:74:1;;;39605:22:0::1;::::0;914:2:1;899:18;39605:22:0::1;;;;;;;;39494:141:::0;:::o;52372:119::-;52426:7;52454:28;52468:13;;52454:9;;:13;;:28;;;;:::i;:::-;52446:37;;52372:119;:::o;55405:1067::-;55552:10;55535:28;;;;:16;:28;;;;;;;;55527:63;;;;;;;4378:2:1;55527:63:0;;;4360:21:1;4417:2;4397:18;;;4390:30;4456:24;4436:18;;;4429:52;4498:18;;55527:63:0;4176:346:1;55527:63:0;55777:12;;:64;;:12;;55807:10;55827:4;55834:6;55777:29;:64::i;:::-;55896:6;:4;:6::i;:::-;55975:12;;55956:15;:31;55952:311;;56027:13;;56016:25;;:6;;:10;:25::i;:::-;56004:9;:37;55952:311;;;56094:12;;56074:17;;56094:33;;56111:15;56094:16;:33::i;:::-;56074:53;;56142:16;56161:24;56175:9;;56161;:13;;:24;;;;:::i;:::-;56237:13;;56142:43;;-1:-1:-1;56212:39:0;;:20;:6;56142:43;56212:10;:20::i;:39::-;56200:9;:51;-1:-1:-1;;55952:311:0;56341:15;56324:14;:32;;;56402:13;;56382:34;;56341:15;56382:19;:34::i;:::-;56367:12;:49;56454:9;;56434:30;;;1629:25:1;;;1685:2;1670:18;;1663:34;;;;56434:30:0;;1602:18:1;56434:30:0;1455:248:1;57439:160:0;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;57560:31:::1;;;::::0;;;:16:::1;:31;::::0;;;;;;57525:66;;::::1;57560:31;::::0;;::::1;57559:32;57525:66;::::0;;57439:160::o;49382:130::-;49438:7;49465:39;49474:15;49491:12;;49465:8;:39::i;56963:334::-;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;57055:12:::1;::::0;:17;;:51:::1;;;57094:12;;57076:15;:30;57055:51;57046:151;;;::::0;::::1;::::0;;5079:2:1;57046:151:0::1;::::0;::::1;5061:21:1::0;5118:2;5098:18;;;5091:30;5157:34;5137:18;;;5130:62;5228:34;5208:18;;;5201:62;5300:24;5279:19;;;5272:53;5342:19;;57046:151:0::1;4877:490:1::0;57046:151:0::1;57208:13;:30:::0;;;57254:35:::1;::::0;552:25:1;;;57254:35:0::1;::::0;540:2:1;525:18;57254:35:0::1;406:177:1::0;39643:271:0;39712:14;;;;39698:10;:28;39690:94;;;;;;;5574:2:1;39690:94:0;;;5556:21:1;5613:2;5593:18;;;5586:30;5652:34;5632:18;;;5625:62;5723:23;5703:18;;;5696:51;5764:19;;39690:94:0;5372:417:1;39690:94:0;39813:5;;;39820:14;39800:35;;;39813:5;;;;6029:34:1;;39820:14:0;;;;6094:2:1;6079:18;;6072:43;39800:35:0;;5941:18:1;39800:35:0;;;;;;;39854:14;;;;39846:22;;;;;;39854:14;;;39846:22;;;;39879:27;;;39643:271::o;54541:612::-;54644:14;43409:1;44015:7;;:19;44007:63;;;;;;;6328:2:1;44007:63:0;;;6310:21:1;6367:2;6347:18;;;6340:30;6406:33;6386:18;;;6379:61;6457:18;;44007:63:0;6126:355:1;44007:63:0;43409:1;44148:18;;47620:21:::1;::::0;::::1;;:30;47612:69;;;::::0;::::1;::::0;;6688:2:1;47612:69:0::1;::::0;::::1;6670:21:1::0;6727:2;6707:18;;;6700:30;6766:28;6746:18;;;6739:56;6812:18;;47612:69:0::1;6486:350:1::0;47612:69:0::1;54623:10:::2;47761:24;47777:7;47761:15;:24::i;:::-;54688:10:::3;54679:20;::::0;;;:8:::3;:20;::::0;;;;;::::3;;:29;54671:69;;;::::0;::::3;::::0;;7043:2:1;54671:69:0::3;::::0;::::3;7025:21:1::0;7082:2;7062:18;;;7055:30;7121:29;7101:18;;;7094:57;7168:18;;54671:69:0::3;6841:351:1::0;54671:69:0::3;54769:10;54762:18;::::0;;;:6:::3;:18;::::0;;;;;;-1:-1:-1;54795:10:0;;54791:293:::3;;54829:10;54843:1;54822:18:::0;;;:6:::3;:18;::::0;;;;:22;54905:21:::3;::::0;54859:136:::3;::::0;54822:18:::3;54905:21:::0;;::::3;::::0;54974:6;54859:27:::3;:136::i;:::-;55050:21;::::0;55015:57:::3;::::0;;7371:25:1;;;55015:57:0::3;55050:21:::0;;::::3;7427:2:1::0;7412:18;;7405:83;55030:10:0::3;::::0;55015:57:::3;::::0;7344:18:1;55015:57:0::3;;;;;;;54791:293;-1:-1:-1::0;55116:10:0::3;55096:31;::::0;;;:19:::3;:31;::::0;;;;55130:15:::3;55096:49:::0;;43365:1;44327:7;:22;54541:612;:::o;49520:505::-;49567:7;49591:23;;49618:1;49591:28;49587:431;;-1:-1:-1;49643:20:0;;;49520:505::o;49587:431::-;49722:269;49769:203;49948:23;;49769:148;49912:4;49769:112;49871:9;;49769:71;49825:14;;49769:25;:23;:25::i;:203::-;49722:20;;;:24;:269::i;56655:300::-;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;56871:5:::1;::::0;56829:61:::1;::::0;56857:12;;56871:5:::1;;56878:11:::0;56829:27:::1;:61::i;:::-;56906:41;::::0;;7703:42:1;7691:55;;7673:74;;7778:2;7763:18;;7756:34;;;56906:41:0::1;::::0;7646:18:1;56906:41:0::1;;;;;;;56655:300:::0;;:::o;48656:718::-;48824:6;;:25;;;;;:6;944:55:1;;;48824:25:0;;;926:74:1;48725:27:0;;;;;;48824:6;;;;:16;;899:18:1;;48824:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48940:39;;;;;;;:30;:39;;;;;;;-1:-1:-1;48798:51:0;-1:-1:-1;49049:28:0;;;;;:76;;;49101:23;49082:15;:42;;49049:76;49045:322;;;49163:1;49141:23;;49045:322;;;49214:23;49195:15;:42;49191:176;;49275:1;49253:23;;49191:176;;;49340:15;49318:37;;49191:176;48787:587;48656:718;;;:::o;57750:179::-;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;57840:9:::1;:22:::0;;;57875:47;::::1;;;57904:6;:4;:6::i;:::-;57750:179:::0;;:::o;57305:126::-;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;57404:18:::1;;;::::0;;;:8:::1;:18;::::0;;;;;;57381:42;;::::1;57404:18;::::0;;::::1;57402:21;57381:42;::::0;;57305:126::o;57607:135::-;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;57688:21:::1;:46:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;57607:135::o;54317:102::-;54385:26;54401:9;54385:15;:26::i;:::-;54317:102;:::o;57937:117::-;47472:5;;;;47458:10;:19;;:53;;-1:-1:-1;47495:16:0;;;;47481:10;:30;47458:53;47449:88;;;;;;;4729:2:1;47449:88:0;;;4711:21:1;4768:2;4748:18;;;4741:30;4807:23;4787:18;;;4780:51;4848:18;;47449:88:0;4527:345:1;47449:88:0;58014:16:::1;:32:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;57937:117::o;54456:77::-;54498:27;54514:10;54498:15;:27::i;:::-;54456:77::o;48352:165::-;48408:7;48435:74;48485:23;;48435:45;46252:3;48435:24;;:28;;:45;;;;:::i;55163:234::-;55263:16;:14;:16::i;:::-;55240:20;:39;55316:6;;:20;;;;;;;;:6;;;;;:18;;:20;;;;;;;;;;;;;;;:6;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55290:23;:46;55364:25;:23;:25::i;:::-;55347:14;:42;55163:234::o;2418:136::-;2476:7;2503:43;2507:1;2510;2503:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;2496:50;;2418:136;;;;;:::o;3334:471::-;3392:7;3637:1;3642;3637:6;3633:47;;-1:-1:-1;3667:1:0;3660:8;;3633:47;3692:9;3704:5;3708:1;3704;:5;:::i;:::-;3692:17;-1:-1:-1;3737:1:0;3728:5;3732:1;3692:17;3728:5;:::i;:::-;:10;3720:56;;;;;;;8471:2:1;3720:56:0;;;8453:21:1;8510:2;8490:18;;;8483:30;8549:34;8529:18;;;8522:62;8620:3;8600:18;;;8593:31;8641:19;;3720:56:0;8269:397:1;4273:132:0;4331:7;4358:39;4362:1;4365;4358:39;;;;;;;;;;;;;;;;;:3;:39::i;1962:181::-;2020:7;;2052:5;2056:1;2052;:5;:::i;:::-;2040:17;;2081:1;2076;:6;;2068:46;;;;;;;9003:2:1;2068:46:0;;;8985:21:1;9042:2;9022:18;;;9015:30;9081:29;9061:18;;;9054:57;9128:18;;2068:46:0;8801:351:1;29942:205:0;30070:68;;;9369:42:1;9438:15;;;30070:68:0;;;9420:34:1;9490:15;;9470:18;;;9463:43;9522:18;;;;9515:34;;;30070:68:0;;;;;;;;;;9332:18:1;;;;30070:68:0;;;;;;;;;;30093:27;30070:68;;;30043:96;;30063:5;;30043:19;:96::i;:::-;29942:205;;;;:::o;38278:106::-;38336:7;38367:1;38363;:5;:13;;38375:1;38363:13;;;-1:-1:-1;38371:1:0;;38278:106;-1:-1:-1;38278:106:0:o;52553:1445::-;52716:6;:4;:6::i;:::-;52776:20;52788:7;52776:11;:20::i;:::-;52890:31;;;;52861:26;52890:31;;;:22;:31;;;;;;;52961:6;;:25;;;;;;;;926:74:1;;;;52890:31:0;52861:26;;52961:6;;;:16;;899:18:1;;52961:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53051:31;;;;;;;;:22;:31;;;;;;:52;;;53222:6;;:22;;;;;;;;926:74:1;;;;53051:52:0;;-1:-1:-1;53051:31:0;53222:6;;;;:13;;899:18:1;;53222:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53297:24;;;;;53255:39;;;;;;;:30;:39;;;;;;;:66;53170:74;-1:-1:-1;53388:40:0;;;53384:400;;53445:19;53467:42;:18;53490;53467:22;:42::i;:::-;53551:24;;53445:64;;-1:-1:-1;53551:41:0;;53445:64;53551:28;:41::i;:::-;53524:24;:68;-1:-1:-1;53384:400:0;;;53625:19;53647:42;:18;53670;53647:22;:42::i;:::-;53731:24;;53625:64;;-1:-1:-1;53731:41:0;;53625:64;53731:28;:41::i;:::-;53704:24;:68;-1:-1:-1;53384:400:0;53842:26;;;;;;;:17;:26;;;;;;;;53837:154;;53885:26;;;;;;;:17;:26;;;;;;;;:33;;;;53914:4;53885:33;;;53933:19;:28;;;;;53964:15;53933:46;;52604:1394;;;52553:1445;:::o;40726:361::-;40921:45;;;40910:10;7691:55:1;;;40921:45:0;;;7673:74:1;7763:18;;;;7756:34;;;40921:45:0;;;;;;;;;;7646:18:1;;;;40921:45:0;;;;;;;;;;;;;40910:57;;-1:-1:-1;;;;40910:10:0;;;;:57;;40921:45;40910:57;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40874:93;;;;40986:7;:57;;;;-1:-1:-1;40998:11:0;;:16;;:44;;;41029:4;41018:24;;;;;;;;;;;;:::i;:::-;40978:101;;;;;;;10559:2:1;40978:101:0;;;10541:21:1;10598:2;10578:18;;;10571:30;10637:33;10617:18;;;10610:61;10688:18;;40978:101:0;10357:355:1;40978:101:0;40796:291;;40726:361;;;:::o;2891:192::-;2977:7;3013:12;3005:6;;;;2997:29;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;3037:9:0;3049:5;3053:1;3049;:5;:::i;:::-;3037:17;-1:-1:-1;;2891:192:0;;;;;;:::o;4935:345::-;5021:7;5123:12;5116:5;5108:28;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;5147:9:0;5159:5;5163:1;5159;:5;:::i;32062:761::-;32486:23;32512:69;32540:4;32512:69;;;;;;;;;;;;;;;;;32520:5;32512:27;;;;:69;;;;;:::i;:::-;32596:17;;32486:95;;-1:-1:-1;32596:21:0;32592:224;;32738:10;32727:30;;;;;;;;;;;;:::i;:::-;32719:85;;;;;;;11512:2:1;32719:85:0;;;11494:21:1;11551:2;11531:18;;;11524:30;11590:34;11570:18;;;11563:62;11661:12;11641:18;;;11634:40;11691:19;;32719:85:0;11310:406:1;32719:85:0;32132:691;32062:761;;:::o;54006:260::-;54068:21;;;;54064:195;;54106:15;54124;54131:7;54124:6;:15::i;:::-;54154;;;;;;;:6;:15;;;;;;;;:25;;;;54227:20;;54194:21;:30;;;;;;:53;-1:-1:-1;54006:260:0;:::o;13039:195::-;13142:12;13174:52;13196:6;13204:4;13210:1;13213:12;13174:21;:52::i;:::-;13167:59;13039:195;-1:-1:-1;;;;13039:195:0:o;14091:530::-;14218:12;14276:5;14251:21;:30;;14243:81;;;;;;;11923:2:1;14243:81:0;;;11905:21:1;11962:2;11942:18;;;11935:30;12001:34;11981:18;;;11974:62;12072:8;12052:18;;;12045:36;12098:19;;14243:81:0;11721:402:1;14243:81:0;10488:20;;14335:60;;;;;;;12330:2:1;14335:60:0;;;12312:21:1;12369:2;12349:18;;;12342:30;12408:31;12388:18;;;12381:59;12457:18;;14335:60:0;12128:353:1;14335:60:0;14469:12;14483:23;14510:6;:11;;14530:5;14538:4;14510:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14468:75;;;;14561:52;14579:7;14588:10;14600:12;14561:17;:52::i;:::-;14554:59;14091:530;-1:-1:-1;;;;;;;14091:530:0:o;16631:742::-;16746:12;16775:7;16771:595;;;-1:-1:-1;16806:10:0;16799:17;;16771:595;16920:17;;:21;16916:439;;17183:10;17177:17;17244:15;17231:10;17227:2;17223:19;17216:44;16916:439;17326:12;17319:20;;;;;;;;;;;:::i;14:196:1:-;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:52;;;343:1;340;333:12;295:52;366:29;385:9;366:29;:::i;1011:180::-;1070:6;1123:2;1111:9;1102:7;1098:23;1094:32;1091:52;;;1139:1;1136;1129:12;1091:52;-1:-1:-1;1162:23:1;;1011:180;-1:-1:-1;1011:180:1:o;1196:254::-;1264:6;1272;1325:2;1313:9;1304:7;1300:23;1296:32;1293:52;;;1341:1;1338;1331:12;1293:52;1364:29;1383:9;1364:29;:::i;:::-;1354:39;1440:2;1425:18;;;;1412:32;;-1:-1:-1;;;1196:254:1:o;1708:118::-;1794:5;1787:13;1780:21;1773:5;1770:32;1760:60;;1816:1;1813;1806:12;1831:309;1896:6;1904;1957:2;1945:9;1936:7;1932:23;1928:32;1925:52;;;1973:1;1970;1963:12;1925:52;2009:9;1996:23;1986:33;;2069:2;2058:9;2054:18;2041:32;2082:28;2104:5;2082:28;:::i;:::-;2129:5;2119:15;;;1831:309;;;;;:::o;2145:241::-;2201:6;2254:2;2242:9;2233:7;2229:23;2225:32;2222:52;;;2270:1;2267;2260:12;2222:52;2309:9;2296:23;2328:28;2350:5;2328:28;:::i;2636:757::-;2737:6;2790:2;2778:9;2769:7;2765:23;2761:32;2758:52;;;2806:1;2803;2796:12;2758:52;2839:2;2833:9;2881:2;2873:6;2869:15;2950:6;2938:10;2935:22;2914:18;2902:10;2899:34;2896:62;2893:242;;;2991:77;2988:1;2981:88;3092:4;3089:1;3082:15;3120:4;3117:1;3110:15;2893:242;3151:2;3144:22;3188:16;;3244:2;3233:21;;;3223:32;;3213:60;;3269:1;3266;3259:12;3213:60;3282:21;;3357:2;3342:18;;;3336:25;3319:15;;;3312:50;;;;-1:-1:-1;3289:6:1;2636:757;-1:-1:-1;2636:757:1:o;3398:184::-;3450:77;3447:1;3440:88;3547:4;3544:1;3537:15;3571:4;3568:1;3561:15;3587:168;3660:9;;;3691;;3708:15;;;3702:22;;3688:37;3678:71;;3729:18;;:::i;7801:184::-;7871:6;7924:2;7912:9;7903:7;7899:23;7895:32;7892:52;;;7940:1;7937;7930:12;7892:52;-1:-1:-1;7963:16:1;;7801:184;-1:-1:-1;7801:184:1:o;7990:274::-;8030:1;8056;8046:189;;8091:77;8088:1;8081:88;8192:4;8189:1;8182:15;8220:4;8217:1;8210:15;8046:189;-1:-1:-1;8249:9:1;;7990:274::o;8671:125::-;8736:9;;;8757:10;;;8754:36;;;8770:18;;:::i;9560:250::-;9645:1;9655:113;9669:6;9666:1;9663:13;9655:113;;;9745:11;;;9739:18;9726:11;;;9719:39;9691:2;9684:10;9655:113;;;-1:-1:-1;;9802:1:1;9784:16;;9777:27;9560:250::o;9815:287::-;9944:3;9982:6;9976:13;9998:66;10057:6;10052:3;10045:4;10037:6;10033:17;9998:66;:::i;:::-;10080:16;;;;;9815:287;-1:-1:-1;;9815:287:1:o;10107:245::-;10174:6;10227:2;10215:9;10206:7;10202:23;10198:32;10195:52;;;10243:1;10240;10233:12;10195:52;10275:9;10269:16;10294:28;10316:5;10294:28;:::i;10717:455::-;10866:2;10855:9;10848:21;10829:4;10898:6;10892:13;10941:6;10936:2;10925:9;10921:18;10914:34;10957:79;11029:6;11024:2;11013:9;11009:18;11004:2;10996:6;10992:15;10957:79;:::i;:::-;11088:2;11076:15;11093:66;11072:88;11057:104;;;;11163:2;11053:113;;10717:455;-1:-1:-1;;10717:455:1:o;11177:128::-;11244:9;;;11265:11;;;11262:37;;;11279:18;;:::i

ipfs://249dfb9c336532e0b250aa2df14256d66b0af4db803cc599a79b1b3d064cfac9