Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• 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 _functionCallWithValue(addre ...
• 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 IFestakeRewardManager
•    - function addReward(uint256 rewardAmou ...
•    - function withdrawRewards()
•    - function addMarginalReward()
•    - function rewardToken()
•    - function rewardsTotal()
•    - function rewardOf(address addr)
• interface IFestakeWithdrawer
•    - function withdraw(uint256 amount)
• interface IFestaked
•    - function stake (uint256 amount)
•    - function stakeFor (address staker, ui ...
•    - function stakeOf(address account)
•    - function getToken()
•    - function stakedTotal()
•    - function stakedBalance()
•    - function stakingStarts()
•    - function stakingEnds()
•  contract Festaked is IFestaked
•    - function stakeOf(address account)
•    - function getToken()
•    - function stakeFor(address staker, uin ...
•    - function stake(uint256 amount)
•    - function _stake(address payer, addres ...
•    - function _payMe(address payer, uint25 ...
•    - function _payTo(address allower, addr ...
•  contract OpenEndedRewardManager is
•    - function addMarginalReward()
•    - function _addMarginalReward()
•    - function addReward(uint256 rewardAmou ...
•    - function fakeRewardOf(address staker)
•    - function rewardOf(address staker)
•    - function _calcRewardOf(address staker ...
•    - function withdrawRewards()
•    - function withdraw(uint256 amount)
•    - function _withdraw(address _staker, u ...
•    - function _withdrawOnlyUpdateState(add ...
•    - function _stake(address payer, addres ...
•    - function _stakeNoPreAction(address pa ...
•    - function _stakeUpdateStateOnly(addres ...
•    - function _calculateFakeRewardAmount(
•    - function _withdrawRewards(address _st ...
•    - function _calcWithdrawRewards(
•    - function _calcReward(uint256 total, u ...
• interface IUniswapV2Factory
•    - function feeTo()
•    - function feeToSetter()
•    - function getPair(address tokenA, addr ...
•    - function allPairs(uint)
•    - function allPairsLength()
•    - function createPair(address tokenA, a ...
•    - function setFeeTo(address)
•    - function setFeeToSetter(address)
• interface IUniswapV2Router01
•    - function factory()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function removeLiquidity(
•    - function removeLiquidityETH(
•    - function removeLiquidityWithPermit(
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokens(
•    - function swapTokensForExactTokens(
•    - function swapExactETHForTokens(uint a ...
•    - function swapTokensForExactETH(uint a ...
•    - function swapExactTokensForETH(uint a ...
•    - function swapETHForExactTokens(uint a ...
•    - function quote(uint amountA, uint res ...
•    - function getAmountOut(uint amountIn, ...
•    - function getAmountIn(uint amountOut, ...
•    - function getAmountsOut(uint amountIn, ...
•    - function getAmountsIn(uint amountOut, ...
• interface IUniswapV2Router02 is IUnis ...
•    - function removeLiquidityETHSupporting ...
•    - function removeLiquidityETHWithPermit ...
•    - function swapExactTokensForTokensSupp ...
•    - function swapExactETHForTokensSupport ...
•    - function swapExactTokensForETHSupport ...
• library Constants
•  contract FestakedRewardContinuatio ...
•    - function initialize()
•    - function rewardOf(address staker)
•    - function _stake(address, address, uin ...
•    - function withdraw(uint256)
•    - function _addMarginalReward()
•    - function withdrawRewardsFor(address s ...
•    - function withdrawRewards()
•    - function _withdrawRewardsForRemote(ad ...
•    - function _withdraw(address _staker, u ...
•    - function _remoteStake(address staker)
•  contract FestakedRewardContinuatio ... *
•    - function initialize()
•    - function sweepToOwner()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-25
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, 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.
     */
    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.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        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.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @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 in 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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;




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

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

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

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

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

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

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

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

// File: contracts/staking/IFestakeRewardManager.sol

pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Ferrum Staking interface for adding reward
 */
interface IFestakeRewardManager {
    /**
     * @dev legacy add reward. To be used by contract support time limitted rewards.
     */
    function addReward(uint256 rewardAmount, uint256 withdrawableAmount) external returns (bool);

    /**
     * @dev withdraw rewards for the user.
     * The only option is to withdraw all rewards is one go.
     */
    function withdrawRewards() external returns (uint256);

    /**
     * @dev marginal rewards is to be used by contracts supporting ongoing rewards.
     * Send the reward to the contract address first.
     */
    function addMarginalReward() external returns (bool);

    function rewardToken() external view returns (IERC20);

    function rewardsTotal() external view returns (uint256);

    /**
     * @dev returns current rewards for an address
     */
    function rewardOf(address addr) external view returns (uint256);
}

// File: contracts/staking/IFestakeWithdrawer.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Ferrum Staking interface for adding reward
 */
interface IFestakeWithdrawer {

    event PaidOut(address indexed token, address indexed rewardToken, address indexed staker_, uint256 amount_, uint256 reward_);

    /**
     * @dev withdraws a certain amount and distributes rewards.
     */
    function withdraw(uint256 amount) external returns (bool);
}

// File: contracts/staking/IFestaked.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Ferrum Staking interface
 */
interface IFestaked {
    
    event Staked(address indexed token, address indexed staker_, uint256 requestedAmount_, uint256 stakedAmount_);

    function stake (uint256 amount) external returns (bool);

    function stakeFor (address staker, uint256 amount) external returns (bool);

    function stakeOf(address account) external view returns (uint256);

    function getToken() external view returns (address);

    function stakedTotal() external view returns (uint256);

    function stakedBalance() external view returns (uint256);

    function stakingStarts() external view returns (uint256);

    function stakingEnds() external view returns (uint256);
}

// File: contracts/staking/Festaked.sol

pragma solidity >=0.6.0 <0.8.0;




/**
 * A staking contract distributes rewards.
 * One can create several TraditionalFestaking over one
 * staking and give different rewards for a single
 * staking contract.
 */
contract Festaked is IFestaked {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    mapping (address => uint256) internal _stakes;

    string public name;
    address  public tokenAddress;
    uint public override stakingStarts;
    uint public override stakingEnds;
    uint public withdrawStarts;
    uint public withdrawEnds;
    uint256 public override stakedTotal;
    uint256 public stakingCap;
    uint256 public override stakedBalance;

    event Staked(address indexed token, address indexed staker_, uint256 requestedAmount_, uint256 stakedAmount_);

    /**
     * Fixed periods. For an open ended contract use end dates from very distant future.
     */
    constructor (
        string memory name_,
        address tokenAddress_,
        uint stakingStarts_,
        uint stakingEnds_,
        uint withdrawStarts_,
        uint withdrawEnds_,
        uint256 stakingCap_) public {
        name = name_;
        require(tokenAddress_ != address(0), "Festaking: 0 address");
        tokenAddress = tokenAddress_;

        require(stakingStarts_ > 0, "Festaking: zero staking start time");
        if (stakingStarts_ < now) {
            stakingStarts = now;
        } else {
            stakingStarts = stakingStarts_;
        }

        require(stakingEnds_ >= stakingStarts, "Festaking: staking end must be after staking starts");
        stakingEnds = stakingEnds_;

        require(withdrawStarts_ >= stakingEnds, "Festaking: withdrawStarts must be after staking ends");
        withdrawStarts = withdrawStarts_;

        require(withdrawEnds_ >= withdrawStarts, "Festaking: withdrawEnds must be after withdraw starts");
        withdrawEnds = withdrawEnds_;

        require(stakingCap_ >= 0, "Festaking: stakingCap cannot be negative");
        stakingCap = stakingCap_;
    }

    function stakeOf(address account) external override view returns (uint256) {
        return _stakes[account];
    }

    function getToken() external override view returns (address) {
        return tokenAddress;
    }

    function stakeFor(address staker, uint256 amount)
    external
    override
    _positive(amount)
    _realAddress(staker)
    _realAddress(msg.sender)
    returns (bool) {
        return _stake(msg.sender, staker, amount);
    }

    /**
    * Requirements:
    * - `amount` Amount to be staked
    */
    function stake(uint256 amount)
    external
    override
    _positive(amount)
    _realAddress(msg.sender)
    returns (bool) {
        address from = msg.sender;
        return _stake(from, from, amount);
    }

    function _stake(address payer, address staker, uint256 amount)
    virtual
    internal
    _after(stakingStarts)
    _before(stakingEnds)
    _positive(amount)
    returns (bool) {
        // check the remaining amount to be staked
        uint256 remaining = amount;
        if (stakingCap > 0 && remaining > (stakingCap.sub(stakedBalance))) {
            remaining = stakingCap.sub(stakedBalance);
        }
        // These requires are not necessary, because it will never happen, but won't hurt to double check
        // this is because stakedTotal and stakedBalance are only modified in this method during the staking period
        require(remaining > 0, "Festaking: Staking cap is filled");
        require((remaining + stakedTotal) <= stakingCap, "Festaking: this will increase staking amount pass the cap");
        if (!_payMe(payer, remaining, tokenAddress)) {
            return false;
        }
        emit Staked(tokenAddress, staker, amount, remaining);

        // Transfer is completed
        stakedBalance = stakedBalance.add(remaining);
        stakedTotal = stakedTotal.add(remaining);
        _stakes[staker] = _stakes[staker].add(remaining);
        return true;
    }

    function _payMe(address payer, uint256 amount, address token)
    internal
    returns (bool) {
        return _payTo(payer, address(this), amount, token);
    }

    function _payTo(address allower, address receiver, uint256 amount, address token)
    internal
    returns (bool) {
        // Request to transfer amount from the contract to receiver.
        // contract does not own the funds, so the allower must have added allowance to the contract
        // Allower is the original owner.
        IERC20(token).safeTransferFrom(allower, receiver, amount);
        return true;
    }

    modifier _realAddress(address addr) {
        require(addr != address(0), "Festaking: zero address");
        _;
    }

    modifier _positive(uint256 amount) {
        require(amount >= 0, "Festaking: negative amount");
        _;
    }

    modifier _after(uint eventTime) {
        require(now >= eventTime, "Festaking: bad timing for the request");
        _;
    }

    modifier _before(uint eventTime) {
        require(now < eventTime, "Festaking: bad timing for the request");
        _;
    }
}

// File: contracts/staking/OpenEndedRewardManager.sol

pragma solidity >=0.6.0 <0.8.0;







/**
 * Allows stake, unstake, and add reward at any time.
 * stake and reward token can be different.
 */
contract OpenEndedRewardManager is 
        Festaked,
        IFestakeRewardManager, IFestakeWithdrawer {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    IERC20 public override rewardToken;
    uint256 public override rewardsTotal;
    uint256 public fakeRewardsTotal;
    mapping (address=>uint256) fakeRewards;

    constructor(
        string memory name_,
        address tokenAddress_,
        address rewardTokenAddress_,
        uint stakingStarts_,
        uint stakingEnds_,
        uint withdrawStarts_,
        uint withdrawEnds_,
        uint256 stakingCap_) Festaked(name_, tokenAddress_, stakingStarts_, stakingEnds_,
            withdrawStarts_, withdrawEnds_, stakingCap_) public {
            rewardToken = IERC20(rewardTokenAddress_);
    }

    /**
     * First send the rewards to this contract, then call this method.
     * Designed to be called by smart contracts.
     */
    function addMarginalReward()
    external override returns (bool) {
        return _addMarginalReward();
    }

    function _addMarginalReward()
    internal virtual returns (bool) {
        address me = address(this);
        IERC20 _rewardToken = rewardToken;
        uint256 amount = _rewardToken.balanceOf(me).sub(rewardsTotal);
        if (address(_rewardToken) == tokenAddress) {
            amount = amount.sub(stakedBalance);
        }
        if (amount == 0) {
            return true; // No reward to add. Its ok. No need to fail callers.
        }
        rewardsTotal = rewardsTotal.add(amount);
        fakeRewardsTotal = fakeRewardsTotal.add(amount);
    }

    function addReward(uint256 rewardAmount, uint256 withdrawableAmount)
    external override returns (bool) {
        require(withdrawableAmount == 0, "OERM: withdrawableAmount > 0 not supported");
        require(rewardAmount != 0, "OERM: rewardAmount not supported");
        rewardToken.safeTransferFrom(msg.sender, address(this), rewardAmount);
        _addMarginalReward();
    }

    function fakeRewardOf(address staker) external view returns (uint256) {
        return fakeRewards[staker];
    }

    function rewardOf(address staker)
    external override virtual view returns (uint256) {
        uint256 stake = Festaked._stakes[staker];
        return _calcRewardOf(staker, stakedBalance, stake);
    }

    function _calcRewardOf(address staker, uint256 totalStaked_, uint256 stake)
    internal view returns (uint256) {
        if (stake == 0) {
            return 0;
        }
        uint256 fr = fakeRewards[staker];
        uint256 rew = _calcReward(totalStaked_, fakeRewardsTotal, stake);
        return rew > fr ? rew.sub(fr) : 0; // Ignoring the overflow problem
    }

    function withdrawRewards() external override virtual returns (uint256) {
        require(msg.sender != address(0), "OERM: Bad address");
        return _withdrawRewards(msg.sender);
    }

    /**
     * First withdraw all rewards, than withdarw it all, then stake back the remaining.
     */
    function withdraw(uint256 amount) external override virtual returns (bool) {
        address _staker = msg.sender;
        return _withdraw(_staker, amount);
    }

    function _withdraw(address _staker, uint256 amount)
    internal virtual returns (bool) {
        if (amount == 0) {
            return true;
        }
        uint256 actualPay = _withdrawOnlyUpdateState(_staker, amount);
        IERC20(tokenAddress).safeTransfer(_staker, amount);
        if (actualPay != 0) {
            rewardToken.safeTransfer(_staker, actualPay);
        }
        emit PaidOut(tokenAddress, address(rewardToken), _staker, amount, actualPay);
        return true;
    }

    function _withdrawOnlyUpdateState(address _staker, uint256 amount)
    internal virtual returns (uint256) {
        uint256 userStake = _stakes[_staker];
        require(amount <= userStake, "OERM: Not enough balance");
        uint256 userFake = fakeRewards[_staker];
        uint256 fakeTotal = fakeRewardsTotal;
        uint256 _stakedBalance = stakedBalance;
        uint256 actualPay = _calcWithdrawRewards(userStake, userFake, _stakedBalance, fakeTotal);

        uint256 fakeRewAmount = _calculateFakeRewardAmount(amount, fakeTotal, _stakedBalance);

        fakeRewardsTotal = fakeRewardsTotal.sub(fakeRewAmount);
        fakeRewards[_staker] = userFake.add(actualPay).sub(fakeRewAmount);
        rewardsTotal = rewardsTotal.sub(actualPay);
        stakedBalance = _stakedBalance.sub(amount);
        _stakes[_staker] = userStake.sub(amount);
        return actualPay;
    }

    function _stake(address payer, address staker, uint256 amount)
    virtual
    override
    internal
    _after(stakingStarts)
    _before(withdrawEnds)
    _positive(amount)
    _realAddress(payer)
    _realAddress(staker)
    returns (bool) {
        return _stakeNoPreAction(payer, staker, amount);
    }

    function _stakeNoPreAction(address payer, address staker, uint256 amount)
    internal
    returns (bool) {
        uint256 remaining = amount;
        uint256 _stakingCap = stakingCap;
        uint256 _stakedBalance = stakedBalance;
        if (_stakingCap != 0 && remaining > (_stakingCap.sub(_stakedBalance))) {
            remaining = _stakingCap.sub(_stakedBalance);
        }
        // These requires are not necessary, because it will never happen, but won't hurt to double check
        // this is because stakedTotal and stakedBalance are only modified in this method during the staking period
        require(remaining != 0, "OERM: Staking cap is filled");
        require(remaining.add(stakedBalance) <= stakingCap, "OERM: this will increase staking amount pass the cap");
        if (!_payMe(payer, remaining, tokenAddress)) {
            return false;
        }
        require(_stakeUpdateStateOnly(staker, remaining), "OERM: Error staking");
        // To ensure total is only updated here. Not when simulating the stake.
        stakedTotal = stakedTotal.add(remaining);
        emit Staked(tokenAddress, staker, amount, remaining);
    }

    function _stakeUpdateStateOnly(address staker, uint256 amount)
    internal returns (bool) {
        uint256 _stakedBalance = stakedBalance;
        uint256 _fakeTotal = fakeRewardsTotal;
        bool isNotNew = _stakedBalance != 0;
        uint256 curRew = isNotNew ?
            _calculateFakeRewardAmount(amount, _fakeTotal, _stakedBalance) :
            _fakeTotal;

        _stakedBalance = _stakedBalance.add(amount);
        _stakes[staker] = _stakes[staker].add(amount);
        fakeRewards[staker] = fakeRewards[staker].add(curRew);

        stakedBalance = _stakedBalance;
        if (isNotNew) {
            fakeRewardsTotal = _fakeTotal.add(curRew);
        }
        return true;
    }

    function _calculateFakeRewardAmount(
        uint256 amount, uint256 baseFakeTotal, uint256 baseStakeTotal
    ) internal pure returns (uint256) {
        return amount.mul(baseFakeTotal).div(baseStakeTotal);
    }

    function _withdrawRewards(address _staker) internal returns (uint256) {
        uint256 userStake = _stakes[_staker];
        uint256 _stakedBalance = stakedBalance;
        uint256 totalFake = fakeRewardsTotal;
        uint256 userFake = fakeRewards[_staker];
        uint256 actualPay = _calcWithdrawRewards(userStake, userFake, _stakedBalance, totalFake);
        rewardsTotal = rewardsTotal.sub(actualPay);
        fakeRewards[_staker] = fakeRewards[_staker].add(actualPay);
        if (actualPay != 0) {
            rewardToken.safeTransfer(_staker, actualPay);
        }
        emit PaidOut(tokenAddress, address(rewardToken), _staker, 0, actualPay);
        return actualPay;
    }

    function _calcWithdrawRewards(
        uint256 _stakedAmount,
        uint256 _userFakeRewards,
        uint256 _totalStaked,
        uint256 _totalFakeRewards)
    internal pure returns (uint256) {
        uint256 toPay = _calcReward(_totalStaked, _totalFakeRewards, _stakedAmount);
        return toPay > _userFakeRewards ? toPay.sub(_userFakeRewards) : 0; // Ignore rounding issue
    }

    function _calcReward(uint256 total, uint256 fakeTotal, uint256 staked)
    internal pure returns (uint256) {
        return fakeTotal.mul(staked).div(total);
    }
}

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol

pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol

pragma solidity >=0.6.2;


interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// File: contracts/common/Constants.sol

pragma solidity >=0.6.0 <0.8.0;



library Constants {
    address constant uniV2FactoryAddress = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
    IUniswapV2Factory constant uniV2Factory = IUniswapV2Factory(uniV2FactoryAddress);

    address constant uniV2Router02Address = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapV2Router02 constant uniV2Router02 = IUniswapV2Router02(uniV2Router02Address);

    uint32 constant Future2100 = 4102448400;
}

// File: contracts/staking/FestakedRewardContinuation.sol

pragma solidity >=0.6.0 <0.8.0;








/**
 * Reward continuation can be used to add reward to any staking.
 * We cannot withdraw or stake from here, but we can withdrawRewards.
 * Key is to do a shaddow management of stakes on this contract.
 */
contract FestakedRewardContinuation is OpenEndedRewardManager {
    IFestaked public targetStake;
    bool initialSync = false;
    constructor(
        address targetStake_,
        address tokenAddress_,
        address rewardTokenAddress_) OpenEndedRewardManager(
            "RewardContinuation", tokenAddress_, rewardTokenAddress_, now, Constants.Future2100,
            Constants.Future2100+1, Constants.Future2100+2, 2**128) public {
            targetStake = IFestaked(targetStake_);
    }

    function initialize() public virtual returns (bool) {
        require(!initialSync, "FRC: Already initialized");
        require(now >= targetStake.stakingEnds(), 
            "FRC: Bad timing. Cannot initialize before target stake contribution is closed");
        uint256 stakedBalance_ = targetStake.stakedBalance();
        stakedTotal = stakedBalance_;
        stakedBalance = stakedBalance_;
        initialSync = true;
        return true;
    }

    /**
     * @dev Checks the current stake against the original.
     * runs a dummy withdraw or stake then calculates the rewards accordingly.
     * TODO: Test scenario: Add reward, remote withdraw, then withdraw here.
     */
    function rewardOf(address staker)
    external override view returns (uint256) {
        require(initialSync, "FRC: Run initialSync");
        if (_stakes[staker] == 0) {
            uint256 remoteStake = _remoteStake(staker);
            return _calcRewardOf(staker, stakedBalance, remoteStake);
        }
        return _calcRewardOf(staker, stakedBalance, _stakes[staker]);
    }

    function _stake(address, address, uint256)
    override
    virtual
    internal
    returns (bool)
    {
        require(false, "RewardContinuation: Stake not supported");
    }

    function withdraw(uint256) external override virtual returns (bool) {
        require(false, "RewardContinuation: Withdraw not supported");
    }

    function _addMarginalReward()
    internal override virtual returns (bool) {
        address me = address(this);
        IERC20 _rewardToken = rewardToken;
        uint256 amount = _rewardToken.balanceOf(me).sub(rewardsTotal);
        // We don't carry stakes here
        // if (address(_rewardToken) == tokenAddress) {
        //     amount = amount.sub(...);
        // }
        if (amount == 0) {
            return true; // No reward to add. Its ok. No need to fail callers.
        }
        rewardsTotal = rewardsTotal.add(amount);
        fakeRewardsTotal = fakeRewardsTotal.add(amount);
    }

    function withdrawRewardsFor(address staker) external returns (uint256) {
        require(msg.sender != address(0), "OERM: Bad address");
        return _withdrawRewardsForRemote(staker);
    }

    function withdrawRewards() external override returns (uint256) {
        require(msg.sender != address(0), "OERM: Bad address");
        return _withdrawRewardsForRemote(msg.sender);
    }

    /**
     * @dev it is important to know there will be no more stake on the remote side
     */
    function _withdrawRewardsForRemote(address staker) internal returns(uint256) {
        require(initialSync, "FRC: Run initialSync");
        uint256 currentStake = Festaked._stakes[staker];
        uint256 remoteStake = _remoteStake(staker);
        uint256 stakedBalance_ = targetStake.stakedBalance();
        // Make sure total staked hasnt gone up on the other side.
        require(stakedBalance_ <= stakedTotal, "FRC: Remote side staked total has increased!");
        require(currentStake == 0 || remoteStake <= currentStake, "FRC: Cannot stake more on the remote side");
        if (currentStake == 0) {
            // First time. Replicate the stake.
            _stakes[staker] = remoteStake;
            _withdrawRewards(staker);
        } else if (remoteStake < currentStake) {
            // This means user has withdrawn remotely! Run the withdraw here to match remote.
            uint256 amount = currentStake.sub(remoteStake);
            _withdraw(staker, amount);
            require(_stakes[staker] == remoteStake, "FRC: Wirhdraw simulation didn't happen correctly!");
        } else {
            _withdrawRewards(staker);
        }
    }

    function _withdraw(address _staker, uint256 amount)
    internal override virtual returns (bool) {
        uint256 actualPay = _withdrawOnlyUpdateState(_staker, amount);
        // We do not have main token to pay. This is just a simulation of withdraw
        // IERC20(tokenAddress).safeTransfer(_staker, amount);
        if (actualPay != 0) {
            rewardToken.safeTransfer(_staker, actualPay);
        }
        emit PaidOut(tokenAddress, address(rewardToken), _staker, 0, actualPay);
        return true;
    }

    function _remoteStake(address staker) internal view returns (uint256){
        return targetStake.stakeOf(staker);
    }
}

// File: contracts/staking/beta/FestakedRewardContinuationBeta.sol

pragma solidity >=0.6.0 <0.8.0;



/**
 * A beta version of FestakedRewardContinuation with ability of sweeping the rewards
 * in case something went wrong.
 * NOTE: Once you sweep rewards to owner, do NOT use the contract any more.
 */
contract FestakedRewardContinuationBeta is FestakedRewardContinuation, Ownable {
    constructor(
        address targetStake_,
        address tokenAddress_,
        address rewardTokenAddress_) FestakedRewardContinuation(
            targetStake_, tokenAddress_, rewardTokenAddress_) public {}
    bool nuked = false;

    function initialize() public override returns (bool) {
        require(!nuked, "FRCB: Already nuked");
        return FestakedRewardContinuation.initialize();
    }

    function sweepToOwner() onlyOwner() external {
        uint256 balance = rewardToken.balanceOf(address(this));
        rewardToken.safeTransfer(owner(), balance);
        initialSync = false; // Make sure contract cannot be used any more.
        nuked = true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"targetStake_","type":"address"},{"internalType":"address","name":"tokenAddress_","type":"address"},{"internalType":"address","name":"rewardTokenAddress_","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":"token","type":"address"},{"indexed":true,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":true,"internalType":"address","name":"staker_","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount_","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward_","type":"uint256"}],"name":"PaidOut","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"staker_","type":"address"},{"indexed":false,"internalType":"uint256","name":"requestedAmount_","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"stakedAmount_","type":"uint256"}],"name":"Staked","type":"event"},{"inputs":[],"name":"addMarginalReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"rewardAmount","type":"uint256"},{"internalType":"uint256","name":"withdrawableAmount","type":"uint256"}],"name":"addReward","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"fakeRewardOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fakeRewardsTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"rewardOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stakeFor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"stakeOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakedTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingEnds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingStarts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sweepToOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"targetStake","outputs":[{"internalType":"contract IFestaked","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenAddress","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":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawEnds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"}],"name":"withdrawRewardsFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawStarts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000de432d6877e158f95aea5786aa94ea04cf2ae6df00000000000000000000000007597255910a51509ca469568b048f2597e7250400000000000000000000000007597255910a51509ca469568b048f2597e72504

-----Decoded View---------------
Arg [0] : targetStake_ (address): 0xDe432d6877E158f95AeA5786aa94ea04cf2AE6DF
Arg [1] : tokenAddress_ (address): 0x07597255910a51509CA469568B048F2597E72504
Arg [2] : rewardTokenAddress_ (address): 0x07597255910a51509CA469568B048F2597E72504

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000de432d6877e158f95aea5786aa94ea04cf2ae6df
Arg [1] : 00000000000000000000000007597255910a51509ca469568b048f2597e72504
Arg [2] : 00000000000000000000000007597255910a51509ca469568b048f2597e72504

49613:782:0:-:0;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49613:782:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24201:18;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;24201:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46938:195;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46938:195:0;-1:-1:-1;;;;;46938:195:0;;:::i;:::-;;;;;;;;;;;;;;;;30221:113;;;:::i;:::-;;;;;;;;;;;;;;;;;;45568:390;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45568:390:0;-1:-1:-1;;;;;45568:390:0;;:::i;24341:26::-;;;:::i;26039:99::-;;;:::i;:::-;;;;-1:-1:-1;;;;;26039:99:0;;;;;;;;;;;;;;46159:147;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46159:147:0;;:::i;26146:237::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;26146:237:0;;;;;;;;:::i;25914:117::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25914:117:0;-1:-1:-1;;;;;25914:117:0;;:::i;24447:25::-;;;:::i;44417:28::-;;;:::i;24479:37::-;;;:::i;24261:34::-;;;:::i;2778:148::-;;;:::i;:::-;;30919:388;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;30919:388:0;;;;;;;:::i;49946:167::-;;;:::i;2136:79::-;;;:::i;24226:28::-;;;:::i;29537:31::-;;;:::i;26467:220::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;26467:220:0;;:::i;31315:115::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;31315:115:0;-1:-1:-1;;;;;31315:115:0;;:::i;24302:32::-;;;:::i;29494:36::-;;;:::i;47141:191::-;;;:::i;24405:35::-;;;:::i;50121:271::-;;;:::i;24374:24::-;;;:::i;3081:244::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3081:244:0;-1:-1:-1;;;;;3081:244:0;;:::i;29453:34::-;;;:::i;24201:18::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;46938:195::-;47000:7;47028:10;47020:54;;;;;-1:-1:-1;;;47020:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47092:33;47118:6;47092:25;:33::i;:::-;47085:40;;46938:195;;;;:::o;30221:113::-;30282:4;30306:20;:18;:20::i;:::-;30299:27;;30221:113;;:::o;45568:390::-;45667:11;;45639:7;;-1:-1:-1;;;45667:11:0;;;;45659:44;;;;;-1:-1:-1;;;45659:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45718:15:0;;:7;:15;;;;;;;;;;;45714:166;;45755:19;45777:20;45790:6;45777:12;:20::i;:::-;45755:42;;45819:49;45833:6;45841:13;;45856:11;45819:13;:49::i;:::-;45812:56;;;;;45714:166;45919:13;;-1:-1:-1;;;;;45934:15:0;;:7;:15;;;;;;;;;;;45897:53;;45911:6;;45897:13;:53::i;24341:26::-;;;;:::o;26039:99::-;26118:12;;-1:-1:-1;;;;;26118:12:0;26039:99;:::o;46159:147::-;46221:4;46238:60;;-1:-1:-1;;;46238:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26146:237;26317:4;26239:6;26265;-1:-1:-1;;;;;28589:18:0;::::1;28581:54;;;::::0;;-1:-1:-1;;;28581:54:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;26291:10:::2;28589:18:::0;28581:54:::2;;;::::0;;-1:-1:-1;;;28581:54:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;26341:34:::3;26348:10;26360:6;26368;26341;:34::i;:::-;26334:41:::0;26146:237;-1:-1:-1;;;;;;26146:237:0:o;25914:117::-;-1:-1:-1;;;;;26007:16:0;25980:7;26007:16;;;;;;;;;;;;25914:117::o;24447:25::-;;;;:::o;44417:28::-;;;-1:-1:-1;;;;;44417:28:0;;:::o;24479:37::-;;;;:::o;24261:34::-;;;;:::o;2778:148::-;2358:12;:10;:12::i;:::-;2348:6;;-1:-1:-1;;;;;2348:6:0;;;:22;;;2340:67;;;;;-1:-1:-1;;;2340:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2869:6:::1;::::0;2848:40:::1;::::0;2885:1:::1;::::0;-1:-1:-1;;;;;2869:6:0::1;::::0;2848:40:::1;::::0;2885:1;;2848:40:::1;2899:6;:19:::0;;;::::1;::::0;;2778:148::o;30919:388::-;31020:4;31045:23;;31037:78;;;;-1:-1:-1;;;31037:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31134:17;31126:62;;;;;-1:-1:-1;;;31126:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31199:11;;:69;;-1:-1:-1;;;;;31199:11:0;31228:10;31248:4;31255:12;31199:69;:28;:69;:::i;:::-;31279:20;:18;:20::i;:::-;;30919:388;;;;:::o;49946:167::-;50019:5;;49993:4;;-1:-1:-1;;;50019:5:0;;;;50018:6;50010:38;;;;;-1:-1:-1;;;50010:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;50066:39;:37;:39::i;2136:79::-;2201:6;;-1:-1:-1;;;;;2201:6:0;2136:79;:::o;24226:28::-;;;-1:-1:-1;;;;;24226:28:0;;:::o;29537:31::-;;;;:::o;26467:220::-;26593:4;26541:6;26567:10:::1;28589:18:::0;28581:54:::1;;;::::0;;-1:-1:-1;;;28581:54:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;26625:10:::2;26653:26;26625:10:::0;;26672:6;26653::::2;:26::i;:::-;26646:33:::0;26467:220;-1:-1:-1;;;;;26467:220:0:o;31315:115::-;-1:-1:-1;;;;;31403:19:0;31376:7;31403:19;;;:11;:19;;;;;;;31315:115::o;24302:32::-;;;;:::o;29494:36::-;;;;:::o;47141:191::-;47195:7;47223:10;47215:54;;;;;-1:-1:-1;;;47215:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47287:37;47313:10;47287:25;:37::i;24405:35::-;;;;:::o;50121:271::-;2358:12;:10;:12::i;:::-;2348:6;;-1:-1:-1;;;;;2348:6:0;;;:22;;;2340:67;;;;;-1:-1:-1;;;2340:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50195:11:::1;::::0;:36:::1;::::0;;;;;50225:4:::1;50195:36;::::0;::::1;::::0;;;50177:15:::1;::::0;-1:-1:-1;;;;;50195:11:0::1;::::0;:21:::1;::::0;:36;;;;;::::1;::::0;;;;;;;;:11;:36;::::1;;5:2:-1::0;::::1;;;30:1;27::::0;20:12:::1;5:2;50195:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;50195:36:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26::::0;19:12:::1;2:2;-1:-1:::0;50195:36:0;;-1:-1:-1;50242:42:0::1;50267:7;:5;:7::i;:::-;50242:11;::::0;-1:-1:-1;;;;;50242:11:0::1;::::0;50276:7;50242:42:::1;:24;:42;:::i;:::-;-1:-1:-1::0;50295:11:0::1;:19:::0;;;;;::::1;::::0;;;50372:5:::1;:12:::0;;;;::::1;-1:-1:-1::0;;;50372:12:0::1;::::0;;50121:271::o;24374:24::-;;;;:::o;3081:244::-;2358:12;:10;:12::i;:::-;2348:6;;-1:-1:-1;;;;;2348:6:0;;;:22;;;2340:67;;;;;-1:-1:-1;;;2340:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3170:22:0;::::1;3162:73;;;;-1:-1:-1::0;;;3162:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3272:6;::::0;3251:38:::1;::::0;-1:-1:-1;;;;;3251:38:0;;::::1;::::0;3272:6:::1;::::0;3251:38:::1;::::0;3272:6:::1;::::0;3251:38:::1;3300:6;:17:::0;;;::::1;-1:-1:-1::0;;;;;3300:17:0;;;::::1;::::0;;;::::1;::::0;;3081:244::o;29453:34::-;;;-1:-1:-1;;;;;29453:34:0;;:::o;47442:1179::-;47538:11;;47510:7;;-1:-1:-1;;;47538:11:0;;;;47530:44;;;;;-1:-1:-1;;;47530:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47608:24:0;;47585:20;47608:24;;;;;;;;;;;;47665:20;47625:6;47665:12;:20::i;:::-;47643:42;;47696:22;47721:11;;;;;;;;;-1:-1:-1;;;;;47721:11:0;-1:-1:-1;;;;;47721:25:0;;:27;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47721:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47721:27:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47721:27:0;47853:11;;47721:27;;-1:-1:-1;47835:29:0;;;47827:86;;;;-1:-1:-1;;;47827:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47932:17;;;:48;;;47968:12;47953:11;:27;;47932:48;47924:102;;;;-1:-1:-1;;;47924:102:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48041:17;48037:577;;-1:-1:-1;;;;;48124:15:0;;:7;:15;;;;;;;;;;:29;;;48168:24;48132:6;48168:16;:24::i;:::-;;48037:577;;;48228:12;48214:11;:26;48210:404;;;48352:14;48369:29;:12;48386:11;48369:29;:16;:29;:::i;:::-;48352:46;;48413:25;48423:6;48431;48413:9;:25::i;:::-;-1:-1:-1;;;;;;48461:15:0;;:7;:15;;;;;;;;;;;:30;;48453:92;;;;-1:-1:-1;;;48453:92:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48210:404;48578:24;48595:6;48578:16;:24::i;:::-;;48210:404;47442:1179;;;;;;:::o;46314:616::-;46460:11;;46530:12;;46499:26;;;;;;46422:4;46499:26;;;;;;;;46384:4;;46422;;-1:-1:-1;;;;;46460:11:0;;;;46384:4;;46499:44;;46460:11;;46499:22;;:26;;;;;;;;;;;;;;46460:11;46499:26;;;5:2:-1;;;;30:1;27;20:12;5:2;46499:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46499:26:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46499:26:0;;:44;:30;:44;:::i;:::-;46482:61;-1:-1:-1;46710:11:0;46706:109;;46745:4;46738:11;;;;;;;46706:109;46840:12;;:24;;46857:6;46840:24;:16;:24;:::i;:::-;46825:12;:39;46894:16;;:28;;46915:6;46894:28;:20;:28;:::i;:::-;46875:16;:47;-1:-1:-1;;;46314:616:0;:::o;49168:122::-;49255:11;;:27;;;;;;-1:-1:-1;;;;;49255:27:0;;;;;;;;;49229:7;;49255:11;;;;;:19;;:27;;;;;;;;;;;;;;;:11;:27;;;5:2:-1;;;;30:1;27;20:12;5:2;49255:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49255:27:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49255:27:0;;49168:122;-1:-1:-1;;49168:122:0:o;31654:377::-;31758:7;31782:10;31778:51;;-1:-1:-1;31816:1:0;31809:8;;31778:51;-1:-1:-1;;;;;31852:19:0;;31839:10;31852:19;;;:11;:19;;;;;;31922:16;;31852:19;;31839:10;31896:50;;31908:12;;31940:5;31896:11;:50::i;:::-;31882:64;;31970:2;31964:3;:8;:26;;31989:1;31964:26;;;31975:11;:3;31983:2;31975:11;:7;:11;:::i;:::-;31957:33;;;;31654:377;;;;;;:::o;45966:185::-;46064:4;46086:57;;-1:-1:-1;;;46086:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;657:106;745:10;657:106;:::o;18534:205::-;18662:68;;;-1:-1:-1;;;;;18662:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18662:68:0;;;;;;;;25:18:-1;;61:17;;18662:68:0;182:15:-1;18685:27:0;179:29:-1;160:49;;18635:96:0;;18655:5;;18635:19;:96::i;:::-;18534:205;;;;:::o;44863:461::-;44935:11;;44909:4;;-1:-1:-1;;;44935:11:0;;;;44934:12;44926:49;;;;;-1:-1:-1;;;44926:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;45001:11;;;;;;;;;-1:-1:-1;;;;;45001:11:0;-1:-1:-1;;;;;45001:23:0;;:25;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45001:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45001:25:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45001:25:0;44994:3;:32;;44986:136;;;;-1:-1:-1;;;44986:136:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45158:11;;:27;;;;;;;;45133:22;;-1:-1:-1;;;;;45158:11:0;;:25;;:27;;;;;;;;;;;;;;:11;:27;;;5:2:-1;;;;30:1;27;20:12;5:2;45158:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45158:27:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45158:27:0;45196:11;:28;;;45235:13;:30;-1:-1:-1;;45276:11:0;:18;;;;-1:-1:-1;;;45276:18:0;;;45290:4;44863:461;:::o;18349:177::-;18459:58;;;-1:-1:-1;;;;;18459:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18459:58:0;;;;;;;;25:18:-1;;61:17;;18459:58:0;182:15:-1;18482:23:0;179:29:-1;160:49;;18432:86:0;;18452:5;;18432:19;:86::i;:::-;18349:177;;;:::o;36397:702::-;-1:-1:-1;;;;;36498:16:0;;36458:7;36498:16;;;;;;;;;;;;36550:13;;36594:16;;36640:11;:20;;;;;;;36498:16;;36594;36458:7;36691:68;36498:16;36640:20;36550:13;36594:16;36691:20;:68::i;:::-;36785:12;;36671:88;;-1:-1:-1;36785:27:0;;36671:88;36785:27;:16;:27;:::i;:::-;36770:12;:42;-1:-1:-1;;;;;36846:20:0;;;;;;:11;:20;;;;;;:35;;36871:9;36846:35;:24;:35;:::i;:::-;-1:-1:-1;;;;;36823:20:0;;;;;;:11;:20;;;;;:58;36896:14;;36892:91;;36927:11;;:44;;-1:-1:-1;;;;;36927:11:0;36952:7;36961:9;36927:44;:24;:44;:::i;:::-;37028:11;;37006:12;;36998:66;;;37028:11;36998:66;;;;;;;;;;-1:-1:-1;;;;;36998:66:0;;;;37028:11;;;37006:12;;36998:66;;;;;;;;37082:9;36397:702;-1:-1:-1;;;;;;36397:702:0:o;4752:136::-;4810:7;4837:43;4841:1;4844;4837:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4830:50;;4752:136;;;;;:::o;48629:531::-;48721:4;48738:17;48758:41;48783:7;48792:6;48758:24;:41::i;:::-;48738:61;-1:-1:-1;48962:14:0;;48958:91;;48993:11;;:44;;-1:-1:-1;;;;;48993:11:0;49018:7;49027:9;48993:44;:24;:44;:::i;:::-;49094:11;;49072:12;;49064:66;;;49094:11;49064:66;;;;;;;;;;-1:-1:-1;;;;;49064:66:0;;;;49094:11;;;49072:12;;49064:66;;;;;;;;-1:-1:-1;49148:4:0;;48629:531;-1:-1:-1;;;48629:531:0:o;4288:181::-;4346:7;4378:5;;;4402:6;;;;4394:46;;;;;-1:-1:-1;;;4394:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;37512:166;37611:7;37638:32;37664:5;37638:21;:9;37652:6;37638:21;:13;:21;:::i;:::-;:25;:32;:25;:32;:::i;:::-;37631:39;37512:166;-1:-1:-1;;;;37512:166:0:o;20654:761::-;21078:23;21104:69;21132:4;21104:69;;;;;;;;;;;;;;;;;21112:5;-1:-1:-1;;;;;21104:27:0;;;:69;;;;;:::i;:::-;21188:17;;21078:95;;-1:-1:-1;21188:21:0;21184:224;;21330:10;21319:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21319:30:0;21311:85;;;;-1:-1:-1;;;21311:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37107:397;37300:7;37320:13;37336:59;37348:12;37362:17;37381:13;37336:11;:59::i;:::-;37320:75;;37421:16;37413:5;:24;:58;;37470:1;37413:58;;;37440:27;:5;37450:16;37440:27;:9;:27;:::i;5191:192::-;5277:7;5313:12;5305:6;;;;5297:29;;;;-1:-1:-1;;;5297:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;5297:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5349:5:0;;;5191:192::o;33031:899::-;-1:-1:-1;;;;;33169:16:0;;33129:7;33169:16;;;;;;;;;;;33204:19;;;;33196:56;;;;;-1:-1:-1;;;33196:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;33282:20:0;;33263:16;33282:20;;;:11;:20;;;;;;33333:16;;33385:13;;33282:20;;33333:16;;33385:13;33429:68;33450:9;33282:20;33385:13;33333:16;33429:20;:68::i;:::-;33409:88;;33510:21;33534:61;33561:6;33569:9;33580:14;33534:26;:61::i;:::-;33627:16;;33510:85;;-1:-1:-1;33627:35:0;;33510:85;33627:35;:20;:35;:::i;:::-;33608:16;:54;33696:42;33724:13;33696:23;:8;33709:9;33696:23;:12;:23;:::i;:::-;:27;:42;:27;:42;:::i;:::-;-1:-1:-1;;;;;33673:20:0;;;;;;:11;:20;;;;;:65;33764:12;;:27;;33781:9;33764:27;:16;:27;:::i;:::-;33749:12;:42;33818:26;:14;33837:6;33818:26;:18;:26;:::i;:::-;33802:13;:42;33874:21;:9;33888:6;33874:21;:13;:21;:::i;:::-;-1:-1:-1;;;;;33855:16:0;;:7;:16;;;;;;;;;;:40;-1:-1:-1;33913:9:0;-1:-1:-1;;;;;33031:899:0;;;;:::o;5642:471::-;5700:7;5945:6;5941:47;;-1:-1:-1;5975:1:0;5968:8;;5941:47;6012:5;;;6016:1;6012;:5;:1;6036:5;;;;;:10;6028:56;;;;-1:-1:-1;;;6028:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6589:132;6647:7;6674:39;6678:1;6681;6674:39;;;;;;;;;;;;;;;;;:3;:39::i;15297:196::-;15400:12;15432:53;15455:6;15463:4;15469:1;15472:12;15432:22;:53::i;36171:218::-;36309:7;36336:45;36366:14;36336:25;:6;36347:13;36336:25;:10;:25;:::i;7217:278::-;7303:7;7338:12;7331:5;7323:28;;;;-1:-1:-1;;;7323:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;7323:28:0;;7362:9;7378:1;7374;:5;;;;;;;7217:278;-1:-1:-1;;;;;7217:278:0:o;16674:979::-;16804:12;16837:18;16848:6;16837:10;:18::i;:::-;16829:60;;;;;-1:-1:-1;;;16829:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16963:12;16977:23;17004:6;-1:-1:-1;;;;;17004:11:0;17024:8;17035:4;17004:36;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;139:12;;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;17004:36:0;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;16962:78:0;;;;17055:7;17051:595;;;17086:10;-1:-1:-1;17079:17:0;;-1:-1:-1;17079:17:0;17051:595;17200:17;;:21;17196:439;;17463:10;17457:17;17524:15;17511:10;17507:2;17503:19;17496:44;17411:148;17599:20;;-1:-1:-1;;;17599:20:0;;;;;;;;;;;;;;;;;17606:12;;17599:20;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;12379:422:0;12746:20;12785:8;;;12379:422::o

ipfs://4682f5aac5f39d8fec1c3f77a9b1a6aa01798a26846dbf97a5c2a28032045cbd