Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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 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 ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
• 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 ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•  contract Initializable
•    - function isConstructor()
•  contract ContextUpgradeSafe is Ini ...
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
•  contract OwnableUpgradeSafe is Ini ...
•    - function __Ownable_init()
•    - function __Ownable_init_unchained()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• interface IPISBaseToken
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IPISBaseTokenEx is IPISBase ...
•    - function devFundAddress()
•    - function transferCheckerAddress()
•    - function feeDistributor()
• interface IFeeCalculator
•    - function check(
•    - function setFeeMultiplier(uint256 _fe ...
•    - function feePercentX100()
•    - function setTokenUniswapPair(address ...
•    - function setPISTokenAddress(address _ ...
•    - function updateTxState()
•    - function calculateAmountsAfterFee(
•    - function setPaused()
• interface INoFeeSimple
•    - function noFeeList(address)
•  contract TimeLockPISAPool
•    - function computeReleasablePIS(address ...
•  contract PISA is OwnableUpgradeSaf ... *
•    - function averageFeesPerBlockSinceStar ...
•    - function averageFeesPerBlockEpoch()
•    - function getEpochReward(uint256 _epoc ...
•    - function pisDeposit()
•    - function startNewEpoch()
•    - function initialize()
•    - function getDepositTime(address _addr ...
•    - function setEmergencyWithdrawable(boo ...
•    - function setDevFee(uint16 _DEV_FEE)
•    - function pendingPisForPool()
•    - function computeDepositAmount(
•    - function pendingPIS(address _user)
•    - function getLockedReward(address _use ...
•    - function massUpdatePools()
•    - function updatePendingRewards()
•    - function updatePool()
•    - function withdrawNerd()
•    - function claimAndRestake()
•    - function deposit(uint256 _originAmoun ...
•    - function depositFor(address _depositF ...
•    - function quitPool()
•    - function withdraw(uint256 _amount)
•    - function _withdraw(
•    - function updateAndPayOutPending(addre ...
•    - function emergencyWithdraw()
•    - function safePISTransfer(address _to, ...
•    - function transferDevFee()
•    - function setDevFeeReciever(address _d ...
•    - function confirmDevAddress()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-02-16
*/

// File: @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/IERC20.sol

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-ethereum-package/contracts/math/SafeMath.sol

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) {
        // 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.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/utils/Address.sol

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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

// File: @openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol

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 ERC20;` 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));
    }

    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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/utils/EnumerableSet.sol

pragma solidity ^0.6.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

// File: @openzeppelin/contracts-ethereum-package/contracts/Initializable.sol

pragma solidity >=0.4.24 <0.7.0;


/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/GSN/Context.sol

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.
 */
contract ContextUpgradeSafe is Initializable {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {


    }


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

    uint256[50] private __gap;
}

// File: @openzeppelin/contracts-ethereum-package/contracts/access/Ownable.sol

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 OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */

    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {


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

    uint256[49] private __gap;
}

// File: contracts/IPISBaseToken.sol


pragma solidity 0.6.12;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IPISBaseToken {
    /**
     * @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
    );

    event Log(string log);
}

interface IPISBaseTokenEx is IPISBaseToken {
    function devFundAddress() external view returns (address);

    function transferCheckerAddress() external view returns (address);

    function feeDistributor() external view returns (address);
}

// File: contracts/IFeeCalculator.sol


pragma solidity 0.6.12;

interface IFeeCalculator {
    function check(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    function setFeeMultiplier(uint256 _feeMultiplier) external;

    function feePercentX100() external view returns (uint256);

    function setTokenUniswapPair(address _tokenUniswapPair) external;

    function setPISTokenAddress(address _pisTokenAddress) external;

    function updateTxState() external;

    function calculateAmountsAfterFee(
        address sender,
        address recipient,
        uint256 amount
    )
        external
        returns (uint256 transferToAmount, uint256 transferToFeeBearerAmount);

    function setPaused() external;
}

// File: contracts/INoFeeSimple.sol

pragma solidity 0.6.12;

interface INoFeeSimple {
    function noFeeList(address) external view returns (bool);
}

// File: contracts/PISA.sol

pragma solidity 0.6.12;









// Nerd Vault distributes fees equally amongst staked pools
// Have fun reading it. Hopefully it's bug-free. God bless.

contract TimeLockPISAPool {
    using SafeMath for uint256;
    using Address for address;

    uint256 public constant PIS_LOCKED_PERIOD_DAYS = 10; //10 days,
    uint256 public constant PIS_RELEASE_TRUNK = 1 days; //releasable every week,

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many  tokens the user currently has.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 rewardLocked;
        uint256 releaseTime;
        //
        // We do some fancy math here. Basically, any point in time, the amount of NERDs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accNerdPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws  tokens to a pool. Here's what happens:
        //   1. The pool's `accNerdPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.

        uint256 depositTime; //See explanation below.
        //this is a dynamic value. It changes every time user deposit to the pool
        //1. initial deposit X => deposit time is block time
        //2. deposit more at time deposit2 without amount Y =>
        //  => compute current releasable amount R
        //  => compute diffTime = R*lockedPeriod/(X + Y) => this is the duration users can unlock R with new deposit amount
        //  => updated depositTime = (blocktime - diffTime/2)
    }

    // Info of each pool.
    struct PoolInfo {
        uint256 accPISPerShare; // Accumulated NERDs per share, times 1e18. See below.
        uint256 lockedPeriod; // liquidity locked period
        bool emergencyWithdrawable;
        uint256 rewardsInThisEpoch;
        uint256 cumulativeRewardsSinceStart;
        uint256 startBlock;
        // For easy graphing historical epoch rewards
        mapping(uint256 => uint256) epochRewards;
        uint256 epochCalculationStartBlock;
        uint256 totalDeposit;
    }

    // Info of each pool.
    PoolInfo public poolInfo;
    // Info of each user that stakes  tokens.
    mapping(address => UserInfo) public userInfo;

    // The PIS TOKEN!
    IPISBaseTokenEx public pis = IPISBaseTokenEx(
        0x834cE7aD163ab3Be0C5Fd4e0a81E67aC8f51E00C
    );

    function computeReleasablePIS(address _addr) public view returns (uint256) {
        if (
            block.timestamp <
            userInfo[_addr].depositTime.add(poolInfo.lockedPeriod)
        ) {
            return 0;
        }

        return userInfo[_addr].amount;
    }
}

contract PISA is OwnableUpgradeSafe, TimeLockPISAPool {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Dev address.
    address public devaddr;
    address public tentativeDevAddress;

    //// pending rewards awaiting anyone to massUpdate
    uint256 public pendingRewards;

    uint256 public epoch;

    uint256 public constant REWARD_LOCKED_PERIOD = 14 days;
    uint256 public constant REWARD_RELEASE_PERCENTAGE = 40;
    uint256 public contractStartBlock;

    // Sets the dev fee for this contract
    // defaults at 7.24%
    // Note contract owner is meant to be a governance contract allowing NERD governance consensus
    uint16 DEV_FEE;

    uint256 public pending_DEV_rewards;
    uint256 public pisBalance;
    uint256 public pendingDeposit;

    // Returns fees generated since start of this contract
    function averageFeesPerBlockSinceStart()
        external
        view
        returns (uint256 averagePerBlock)
    {
        averagePerBlock = poolInfo
            .cumulativeRewardsSinceStart
            .add(poolInfo.rewardsInThisEpoch)
            .add(pendingPisForPool())
            .div(block.number.sub(poolInfo.startBlock));
    }

    // Returns averge fees in this epoch
    function averageFeesPerBlockEpoch()
        external
        view
        returns (uint256 averagePerBlock)
    {
        averagePerBlock = poolInfo
            .rewardsInThisEpoch
            .add(pendingPisForPool())
            .div(block.number.sub(poolInfo.epochCalculationStartBlock));
    }

    function getEpochReward(uint256 _epoch) public view returns (uint256) {
        return poolInfo.epochRewards[_epoch];
    }

    function pisDeposit() public view returns (uint256) {
        return poolInfo.totalDeposit.add(pendingDeposit);
    }

    //Starts a new calculation epoch
    // Because averge since start will not be accurate
    function startNewEpoch() public {
        require(
            poolInfo.epochCalculationStartBlock + 50000 < block.number,
            "New epoch not ready yet"
        ); // About a week
        poolInfo.epochRewards[epoch] = poolInfo.rewardsInThisEpoch;
        poolInfo.cumulativeRewardsSinceStart = poolInfo
            .cumulativeRewardsSinceStart
            .add(poolInfo.rewardsInThisEpoch);
        poolInfo.rewardsInThisEpoch = 0;
        poolInfo.epochCalculationStartBlock = block.number;
        ++epoch;
    }

    event Deposit(address indexed user, uint256 amount);
    event Restake(address indexed user, uint256 amount);
    event Withdraw(address indexed user, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 amount);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function initialize() public initializer {
        OwnableUpgradeSafe.__Ownable_init();

        require(
            INoFeeSimple(pis.transferCheckerAddress()).noFeeList(address(this)),
            "!Staking pool should not have fee"
        );
        poolInfo.lockedPeriod = PIS_LOCKED_PERIOD_DAYS.mul(PIS_RELEASE_TRUNK);
        DEV_FEE = 724;
        devaddr = pis.devFundAddress();
        tentativeDevAddress = address(0);
        contractStartBlock = block.number;

        poolInfo.emergencyWithdrawable = false;
        poolInfo.accPISPerShare = 0;
        poolInfo.rewardsInThisEpoch = 0;
        poolInfo.cumulativeRewardsSinceStart = 0;
        poolInfo.startBlock = block.number;
        poolInfo.epochCalculationStartBlock = block.number;
        poolInfo.totalDeposit = 0;
    }

    function getDepositTime(address _addr) public view returns (uint256) {
        return userInfo[_addr].depositTime;
    }

    function setEmergencyWithdrawable(bool _withdrawable) public onlyOwner {
        poolInfo.emergencyWithdrawable = _withdrawable;
    }

    function setDevFee(uint16 _DEV_FEE) public onlyOwner {
        require(_DEV_FEE <= 1000, "Dev fee clamped at 10%");
        DEV_FEE = _DEV_FEE;
    }

    function pendingPisForPool() public view returns (uint256) {
        uint256 tokenSupply = poolInfo.totalDeposit;

        if (tokenSupply == 0) return 0;

        uint256 pisRewardWhole = pendingRewards;
        uint256 pisRewardFee = pisRewardWhole.mul(DEV_FEE).div(10000);
        return pisRewardWhole.sub(pisRewardFee);
    }

    function computeDepositAmount(
        address _sender,
        address _recipient,
        uint256 _amount
    ) internal returns (uint256) {
        (uint256 _receiveAmount, ) = IFeeCalculator(
            pis.transferCheckerAddress()
        )
            .calculateAmountsAfterFee(_sender, _recipient, _amount);
        return _receiveAmount;
    }

    // View function to see pending NERDs on frontend.
    function pendingPIS(address _user) public view returns (uint256) {
        UserInfo storage user = userInfo[_user];
        uint256 accPISPerShare = poolInfo.accPISPerShare;
        uint256 amount = user.amount;

        uint256 tokenSupply = poolInfo.totalDeposit;

        if (tokenSupply == 0) return 0;

        uint256 pisRewardFee = pendingRewards.mul(DEV_FEE).div(10000);
        uint256 pisRewardToDistribute = pendingRewards.sub(pisRewardFee);
        uint256 inc = pisRewardToDistribute.mul(1e18).div(tokenSupply);
        accPISPerShare = accPISPerShare.add(inc);

        return amount.mul(accPISPerShare).div(1e18).sub(user.rewardDebt);
    }

    function getLockedReward(address _user) public view returns (uint256) {
        return userInfo[_user].rewardLocked;
    }

    // Update reward vairables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 allRewards = updatePool();
        pendingRewards = pendingRewards.sub(allRewards);
    }

    // ----
    // Function that adds pending rewards, called by the NERD token.
    // ----
    function updatePendingRewards() public {
        uint256 newRewards = pis.balanceOf(address(this)).sub(pisBalance).sub(
            pisDeposit()
        );

        if (newRewards > 0) {
            pisBalance = pis.balanceOf(address(this)).sub(pisDeposit()); // If there is no change the balance didn't change
            pendingRewards = pendingRewards.add(newRewards);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool() internal returns (uint256 pisRewardWhole) {
        uint256 tokenSupply = poolInfo.totalDeposit;
        if (tokenSupply == 0) {
            // avoids division by 0 errors
            return 0;
        }
        pisRewardWhole = pendingRewards;

        uint256 pisRewardFee = pisRewardWhole.mul(DEV_FEE).div(10000);
        uint256 pisRewardToDistribute = pisRewardWhole.sub(pisRewardFee);

        uint256 inc = pisRewardToDistribute.mul(1e18).div(tokenSupply);
        pending_DEV_rewards = pending_DEV_rewards.add(pisRewardFee);

        poolInfo.accPISPerShare = poolInfo.accPISPerShare.add(inc);
        poolInfo.rewardsInThisEpoch = poolInfo.rewardsInThisEpoch.add(
            pisRewardToDistribute
        );
    }

    function withdrawNerd() public {
        withdraw(0);
    }

    function claimAndRestake() public {
        UserInfo storage user = userInfo[msg.sender];
        require(user.amount > 0);
        massUpdatePools();

        if (user.releaseTime == 0) {
            user.releaseTime = block.timestamp.add(REWARD_LOCKED_PERIOD);
        }
        uint256 _rewards = 0;
        if (block.timestamp > user.releaseTime) {
            //compute withdrawnable amount
            uint256 lockedAmount = user.rewardLocked;
            user.rewardLocked = 0;
            user.releaseTime = block.timestamp.add(REWARD_LOCKED_PERIOD);
            _rewards = _rewards.add(lockedAmount);
        }

        uint256 pending = pendingPIS(msg.sender);
        uint256 paid = pending.mul(REWARD_RELEASE_PERCENTAGE).div(100);
        uint256 _lockedReward = pending.sub(paid);
        if (_lockedReward > 0) {
            user.rewardLocked = user.rewardLocked.add(_lockedReward);
        }

        _rewards = _rewards.add(paid);

        uint256 lockedPeriod = poolInfo.lockedPeriod;
        user.depositTime = block.timestamp;
        //reset referenceAmount to start a new lock-release period

        user.amount = user.amount.add(_rewards);
        user.rewardDebt = user.amount.mul(poolInfo.accPISPerShare).div(1e18);
        poolInfo.totalDeposit = poolInfo.totalDeposit.add(_rewards);
        transferDevFee();
        emit Restake(msg.sender, _rewards);
    }

    // Deposit  tokens to NerdVault for NERD allocation.
    function deposit(uint256 _originAmount) public {
        UserInfo storage user = userInfo[msg.sender];

        massUpdatePools();

        // Transfer pending tokens
        // to user
        updateAndPayOutPending(msg.sender);

        pendingDeposit = computeDepositAmount(
            msg.sender,
            address(this),
            _originAmount
        );
        uint256 _actualDepositReceive = pendingDeposit;
        //Transfer in the amounts from user
        // save gas
        if (_actualDepositReceive > 0) {
            pis.transferFrom(address(msg.sender), address(this), _originAmount);
            pendingDeposit = 0;
            user.amount = user.amount.add(_actualDepositReceive);
            user.depositTime = block.timestamp;
        }
        //massUpdatePools();
        user.rewardDebt = user.amount.mul(poolInfo.accPISPerShare).div(1e18);
        poolInfo.totalDeposit = poolInfo.totalDeposit.add(
            _actualDepositReceive
        );
        emit Deposit(msg.sender, _actualDepositReceive);
    }

    // Test coverage
    // [x] Does user get the deposited amounts?
    // [x] Does user that its deposited for update correcty?
    // [x] Does the depositor get their tokens decreased
    function depositFor(address _depositFor, uint256 _originAmount) public {
        // requires no allowances
        UserInfo storage user = userInfo[_depositFor];

        massUpdatePools();

        // Transfer pending tokens
        // to user
        updateAndPayOutPending(_depositFor); // Update the balances of person that amount is being deposited for

        pendingDeposit = computeDepositAmount(
            msg.sender,
            address(this),
            _originAmount
        );
        uint256 _actualDepositReceive = pendingDeposit;
        if (_actualDepositReceive > 0) {
            pis.transferFrom(address(msg.sender), address(this), _originAmount);
            pendingDeposit = 0;
            user.depositTime = block.timestamp;
            user.amount = user.amount.add(_actualDepositReceive); // This is depositedFor address
        }

        user.rewardDebt = user.amount.mul(poolInfo.accPISPerShare).div(1e18); /// This is deposited for address
        poolInfo.totalDeposit = poolInfo.totalDeposit.add(
            _actualDepositReceive
        );
        emit Deposit(_depositFor, _actualDepositReceive);
    }

    function quitPool() public {
        uint256 withdrawnableAmount = computeReleasablePIS(msg.sender);
        withdraw(withdrawnableAmount);
    }

    // Withdraw  tokens from NerdVault.
    function withdraw(uint256 _amount) public {
        _withdraw(_amount, msg.sender, msg.sender);
    }

    // Low level withdraw function
    function _withdraw(
        uint256 _amount,
        address from,
        address to
    ) internal {
        //require(pool.withdrawable, "Withdrawing from this pool is disabled");
        UserInfo storage user = userInfo[from];
        require(computeReleasablePIS(from) >= _amount, "withdraw: not good");

        massUpdatePools();
        updateAndPayOutPending(from); // Update balances of from this is not withdrawal but claiming NERD farmed

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            poolInfo.totalDeposit = poolInfo.totalDeposit.sub(_amount);
            safePISTransfer(address(to), _amount);
        }
        user.rewardDebt = user.amount.mul(poolInfo.accPISPerShare).div(1e18);

        emit Withdraw(to, _amount);
    }

    function updateAndPayOutPending(address from) internal {
        UserInfo storage user = userInfo[from];
        if (user.releaseTime == 0) {
            user.releaseTime = block.timestamp.add(REWARD_LOCKED_PERIOD);
        }
        if (block.timestamp > user.releaseTime) {
            //compute withdrawnable amount
            uint256 lockedAmount = user.rewardLocked;
            user.rewardLocked = 0;
            safePISTransfer(from, lockedAmount);
            user.releaseTime = block.timestamp.add(REWARD_LOCKED_PERIOD);
        }

        uint256 pending = pendingPIS(from);
        uint256 paid = pending.mul(REWARD_RELEASE_PERCENTAGE).div(100);
        uint256 _lockedReward = pending.sub(paid);
        if (_lockedReward > 0) {
            user.rewardLocked = user.rewardLocked.add(_lockedReward);
        }

        if (paid > 0) {
            safePISTransfer(from, paid);
        }
    }

    function emergencyWithdraw() public {
        require(
            poolInfo.emergencyWithdrawable,
            "Withdrawing from this pool is disabled"
        );
        UserInfo storage user = userInfo[msg.sender];
        poolInfo.totalDeposit = poolInfo.totalDeposit.sub(user.amount);
        uint256 withdrawnAmount = user.amount;
        if (withdrawnAmount > pis.balanceOf(address(this))) {
            withdrawnAmount = pis.balanceOf(address(this));
        }
        safePISTransfer(address(msg.sender), withdrawnAmount);
        emit EmergencyWithdraw(msg.sender, withdrawnAmount);
        user.amount = 0;
        user.rewardDebt = 0;
    }

    function safePISTransfer(address _to, uint256 _amount) internal {
        uint256 pisBal = pis.balanceOf(address(this));

        if (_amount > pisBal) {
            pis.transfer(_to, pisBal);
            pisBalance = pis.balanceOf(address(this)).sub(pisDeposit());
        } else {
            pis.transfer(_to, _amount);
            pisBalance = pis.balanceOf(address(this)).sub(pisDeposit());
        }
        transferDevFee();
    }

    function transferDevFee() public {
        if (pending_DEV_rewards == 0) return;

        uint256 pisBal = pis.balanceOf(address(this));
        if (pending_DEV_rewards > pisBal) {
            pis.transfer(devaddr, pisBal);
            pisBalance = pis.balanceOf(address(this)).sub(pisDeposit());
        } else {
            pis.transfer(devaddr, pending_DEV_rewards);
            pisBalance = pis.balanceOf(address(this)).sub(pisDeposit());
        }

        pending_DEV_rewards = 0;
    }

    function setDevFeeReciever(address _devaddr) public onlyOwner {
        require(devaddr == msg.sender, "only dev can change");
        tentativeDevAddress = _devaddr;
    }

    function confirmDevAddress() public {
        require(tentativeDevAddress == msg.sender, "not tentativeDevAddress!");
        devaddr = tentativeDevAddress;
        tentativeDevAddress = address(0);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Restake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"PIS_LOCKED_PERIOD_DAYS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PIS_RELEASE_TRUNK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_LOCKED_PERIOD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_RELEASE_PERCENTAGE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"averageFeesPerBlockEpoch","outputs":[{"internalType":"uint256","name":"averagePerBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"averageFeesPerBlockSinceStart","outputs":[{"internalType":"uint256","name":"averagePerBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimAndRestake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"computeReleasablePIS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"confirmDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractStartBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_originAmount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_depositFor","type":"address"},{"internalType":"uint256","name":"_originAmount","type":"uint256"}],"name":"depositFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devaddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"epoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"getDepositTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_epoch","type":"uint256"}],"name":"getEpochReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getLockedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingPIS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingPisForPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pending_DEV_rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pis","outputs":[{"internalType":"contract IPISBaseTokenEx","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pisBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pisDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolInfo","outputs":[{"internalType":"uint256","name":"accPISPerShare","type":"uint256"},{"internalType":"uint256","name":"lockedPeriod","type":"uint256"},{"internalType":"bool","name":"emergencyWithdrawable","type":"bool"},{"internalType":"uint256","name":"rewardsInThisEpoch","type":"uint256"},{"internalType":"uint256","name":"cumulativeRewardsSinceStart","type":"uint256"},{"internalType":"uint256","name":"startBlock","type":"uint256"},{"internalType":"uint256","name":"epochCalculationStartBlock","type":"uint256"},{"internalType":"uint256","name":"totalDeposit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quitPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_DEV_FEE","type":"uint16"}],"name":"setDevFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"setDevFeeReciever","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_withdrawable","type":"bool"}],"name":"setEmergencyWithdrawable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startNewEpoch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tentativeDevAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transferDevFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"updatePendingRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLocked","type":"uint256"},{"internalType":"uint256","name":"releaseTime","type":"uint256"},{"internalType":"uint256","name":"depositTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawNerd","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

36159:15373:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37432:306;;;:::i;:::-;;;;;;;;;;;;;;;;36504:54;;;:::i;36901:25::-;;;:::i;35678:44::-;;;;;;;;;;;;;;;;-1:-1:-1;35678:44:0;-1:-1:-1;;;;;35678:44:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51321:208;;;:::i;:::-;;51138:175;;;;;;;;;;;;;;;;-1:-1:-1;51138:175:0;-1:-1:-1;;;;;51138:175:0;;:::i;47603:103::-;;;;;;;;;;;;;;;;-1:-1:-1;47603:103:0;;:::i;46230:1168::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;46230:1168:0;;;;;;;;:::i;47406:148::-;;;:::i;38100:535::-;;;:::i;33563:50::-;;;:::i;50625:505::-;;;:::i;36338:34::-;;;:::i;:::-;;;;-1:-1:-1;;;;;36338:34:0;;;;;;;;;;;;;;36626:33;;;:::i;35600:24::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41919:144;;;:::i;40262:338::-;;;:::i;28447:148::-;;;:::i;39958:136::-;;;;;;;;;;;;;;;;-1:-1:-1;39958:136:0;;;;:::i;35867:285::-;;;;;;;;;;;;;;;;-1:-1:-1;35867:285:0;-1:-1:-1;;;;;35867:285:0;;:::i;39006:814::-;;;:::i;39828:122::-;;;;;;;;;;;;;;;;-1:-1:-1;39828:122:0;-1:-1:-1;;;;;39828:122:0;;:::i;27805:79::-;;;:::i;36475:20::-;;;:::i;35754:104::-;;;:::i;36565:54::-;;;:::i;37031:351::-;;;:::i;44965:1066::-;;;;;;;;;;;;;;;;-1:-1:-1;44965:1066:0;;:::i;41712:124::-;;;;;;;;;;;;;;;;-1:-1:-1;41712:124:0;-1:-1:-1;;;;;41712:124:0;;:::i;41034:670::-;;;;;;;;;;;;;;;;-1:-1:-1;41034:670:0;-1:-1:-1;;;;;41034:670:0;;:::i;37879:119::-;;;:::i;43410:61::-;;;:::i;36860:34::-;;;:::i;37746:125::-;;;;;;;;;;;;;;;;-1:-1:-1;37746:125:0;;:::i;36309:22::-;;;:::i;49495:666::-;;;:::i;40102:152::-;;;;;;;;;;;;;;;;-1:-1:-1;40102:152:0;;;;:::i;33494:51::-;;;:::i;36437:29::-;;;:::i;28750:244::-;;;;;;;;;;;;;;;;-1:-1:-1;28750:244:0;-1:-1:-1;;;;;28750:244:0;;:::i;36933:29::-;;;:::i;43479:1420::-;;;:::i;42167:396::-;;;:::i;37432:306::-;37693:35;;37518:23;;37577:153;;37676:53;;:12;;:16;:53::i;:::-;37577:80;37637:19;:17;:19::i;:::-;37577:41;;;:59;:80::i;:::-;:98;;:153::i;:::-;37559:171;;37432:306;:::o;36504:54::-;36551:7;36504:54;:::o;36901:25::-;;;;:::o;35678:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51321:208::-;51376:19;;-1:-1:-1;;;;;51376:19:0;51399:10;51376:33;51368:70;;;;;-1:-1:-1;;;51368:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;51459:19;;;51449:7;:29;;-1:-1:-1;;;;;;51449:29:0;;;-1:-1:-1;;;;;51459:19:0;;51449:29;;;;51489:32;;;51321:208::o;51138:175::-;28027:12;:10;:12::i;:::-;28017:6;;-1:-1:-1;;;;;28017:6:0;;;:22;;;28009:67;;;;;-1:-1:-1;;;28009:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28009:67:0;;;;;;;;;;;;;;;51219:7:::1;::::0;-1:-1:-1;;;;;51219:7:0::1;51230:10;51219:21;51211:53;;;::::0;;-1:-1:-1;;;51211:53:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;51211:53:0;;;;;;;;;;;;;::::1;;51275:19;:30:::0;;-1:-1:-1;;;;;;51275:30:0::1;-1:-1:-1::0;;;;;51275:30:0;;;::::1;::::0;;;::::1;::::0;;51138:175::o;47603:103::-;47656:42;47666:7;47675:10;47687;47656:9;:42::i;:::-;47603:103;:::o;46230:1168::-;-1:-1:-1;;;;;46371:21:0;;46347;46371;;;:8;:21;;;;;46405:17;:15;:17::i;:::-;46491:35;46514:11;46491:22;:35::i;:::-;46624:112;46659:10;46692:4;46712:13;46624:20;:112::i;:::-;46607:14;:129;;;46808:25;;46804:306;;46850:3;;:67;;;-1:-1:-1;;;46850:67:0;;46875:10;46850:67;;;;46896:4;46850:67;;;;;;;;;;;;-1:-1:-1;;;;;46850:3:0;;;;:16;;:67;;;;;;;;;;;;;;;:3;;:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46949:1:0;46932:14;:18;46984:15;46965:16;;;:34;47028:11;;:38;;47044:21;47028:15;:38::i;:::-;47014:52;;46804:306;47156:8;:23;47140:11;;:50;;47185:4;;47140:40;;:15;:40::i;:50::-;47122:15;;;:68;47259:21;;:72;;47299:21;47259:25;:72::i;:::-;47235:21;:96;47347:43;;;;;;;;-1:-1:-1;;;;;47347:43:0;;;;;;;;;;;;;46230:1168;;;;:::o;47406:148::-;47444:27;47474:32;47495:10;47474:20;:32::i;:::-;47444:62;;47517:29;47526:19;47517:8;:29::i;38100:535::-;38211:12;38165:8;:35;;;38203:5;38165:43;:58;38143:131;;;;;-1:-1:-1;;;38143:131:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38332:27;;38323:5;;38301:28;;;;:21;:28;;;;;:58;;;38409:50;;:97;;:68;:97::i;:::-;38370:36;:136;38547:1;38517:27;:31;38597:12;38559:35;:50;38622:5;38620:7;;-1:-1:-1;38620:7:0;;;38100:535::o;33563:50::-;33607:6;33563:50;:::o;50625:505::-;50673:19;;50669:37;;50699:7;;50669:37;50735:3;;:28;;;-1:-1:-1;;;50735:28:0;;50757:4;50735:28;;;;;;50718:14;;-1:-1:-1;;;;;50735:3:0;;:13;;:28;;;;;;;;;;;;;;:3;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50735:28:0;50778:19;;50735:28;;-1:-1:-1;50778:28:0;-1:-1:-1;50774:313:0;;;50823:3;;50836:7;;50823:29;;;-1:-1:-1;;;50823:29:0;;-1:-1:-1;;;;;50836:7:0;;;50823:29;;;;;;;;;;;;:3;;;;;:12;;:29;;;;;;;;;;;;;;:3;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50880:46:0;;-1:-1:-1;50913:12:0;:10;:12::i;:::-;50880:3;;:28;;;-1:-1:-1;;;50880:28:0;;50902:4;50880:28;;;;;;-1:-1:-1;;;;;50880:3:0;;;;:13;;:28;;;;;;;;;;;;;;;:3;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50880:28:0;;:32;:46::i;:::-;50867:10;:59;50774:313;;;50959:3;;50972:7;;50981:19;;50959:42;;;-1:-1:-1;;;50959:42:0;;-1:-1:-1;;;;;50972:7:0;;;50959:42;;;;;;;;;;;;:3;;;;;:12;;:42;;;;;;;;;;;;;;:3;;:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51029:46:0;;-1:-1:-1;51062:12:0;:10;:12::i;51029:46::-;51016:10;:59;50774:313;-1:-1:-1;51121:1:0;51099:19;:23;50625:505;:::o;36338:34::-;;;-1:-1:-1;;;;;36338:34:0;;:::o;36626:33::-;;;;:::o;35600:24::-;;;;;;;;;;;;;;;;;;;;;;;:::o;41919:144::-;41964:18;41985:12;:10;:12::i;:::-;42025:14;;41964:33;;-1:-1:-1;42025:30:0;;41964:33;42025:18;:30::i;:::-;42008:14;:47;-1:-1:-1;41919:144:0:o;40262:338::-;40354:21;;40312:7;;40392:16;40388:30;;40417:1;40410:8;;;;;40388:30;40456:14;;40523:7;;40431:22;;40504:38;;40536:5;;40504:27;;40456:14;;40523:7;;40504:18;:27::i;:38::-;40481:61;-1:-1:-1;40560:32:0;:14;40481:61;40560:18;:32::i;:::-;40553:39;;;;;40262:338;;:::o;28447:148::-;28027:12;:10;:12::i;:::-;28017:6;;-1:-1:-1;;;;;28017:6:0;;;:22;;;28009:67;;;;;-1:-1:-1;;;28009:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28009:67:0;;;;;;;;;;;;;;;28538:6:::1;::::0;28517:40:::1;::::0;28554:1:::1;::::0;-1:-1:-1;;;;;28538:6:0::1;::::0;28517:40:::1;::::0;28554:1;;28517:40:::1;28568:6;:19:::0;;-1:-1:-1;;;;;;28568:19:0::1;::::0;;28447:148::o;39958:136::-;28027:12;:10;:12::i;:::-;28017:6;;-1:-1:-1;;;;;28017:6:0;;;:22;;;28009:67;;;;;-1:-1:-1;;;28009:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28009:67:0;;;;;;;;;;;;;;;40040:30;:46;;-1:-1:-1;;40040:46:0::1;::::0;::::1;;::::0;;;::::1;::::0;;39958:136::o;35867:285::-;36034:21;;-1:-1:-1;;;;;36002:15:0;;35933:7;36002:15;;;:8;:15;;;;;:27;;;35933:7;;36002:54;;:27;:31;:54::i;:::-;35971:15;:85;35953:150;;;-1:-1:-1;36090:1:0;36083:8;;35953:150;-1:-1:-1;;;;;;36122:15:0;;;;;;:8;:15;;;;;:22;35867:285;;;;:::o;39006:814::-;24050:12;;;;;;;;:31;;;24066:15;:13;:15::i;:::-;24050:47;;;-1:-1:-1;24086:11:0;;;;24085:12;24050:47;24042:106;;;;-1:-1:-1;;;24042:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24157:19;24180:12;;;;;;24179:13;24199:83;;;;24228:12;:19;;-1:-1:-1;;;;24228:19:0;;;;;24256:18;24243:4;24256:18;;;24199:83;39058:35:::1;:33;:35::i;:::-;39141:3;;;;;;;;;-1:-1:-1::0;;;;;39141:3:0::1;-1:-1:-1::0;;;;;39141:26:0::1;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;39141:28:0;39128:67:::1;::::0;;-1:-1:-1;;;39128:67:0;;39189:4:::1;39128:67;::::0;::::1;::::0;;;-1:-1:-1;;;;;39128:52:0;;::::1;::::0;::::1;::::0;:67;;;;;39141:28:::1;::::0;39128:67;;;;;;;;:52;:67;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;39128:67:0;39106:150:::1;;;;-1:-1:-1::0;;;39106:150:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39291:45;33543:2;33607:6;39291:26;:45::i;:::-;39267:21:::0;:69;39347:7:::1;:13:::0;;-1:-1:-1;;39347:13:0::1;39357:3;39347:13;::::0;;39381:3:::1;::::0;:20:::1;::::0;;-1:-1:-1;;;39381:20:0;;;;-1:-1:-1;;;;;39381:3:0;;::::1;::::0;:18:::1;::::0;:20:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;:3;:20;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;39381:20:0;39371:7:::1;:30:::0;;-1:-1:-1;;;;;39371:30:0;;::::1;-1:-1:-1::0;;;;;;39371:30:0;;::::1;;::::0;;39412:19:::1;:32:::0;;;;::::1;::::0;;39476:12:::1;39455:18;:33:::0;;;39501:30;:38;;-1:-1:-1;;39501:38:0::1;::::0;;39371:7:::1;39501:8;39550:27:::0;;;39588;:31;;;39630:36;:40;;;39681:19;:34;;;39726:35;:50;;;;39787:21;:25;24300:57;;;;24344:5;24329:20;;-1:-1:-1;;24329:20:0;;;39006:814;:::o;39828:122::-;-1:-1:-1;;;;;39915:15:0;39888:7;39915:15;;;:8;:15;;;;;:27;;;;39828:122::o;27805:79::-;27870:6;;-1:-1:-1;;;;;27870:6:0;27805:79;:::o;36475:20::-;;;;:::o;35754:104::-;;;-1:-1:-1;;;;;35754:104:0;;:::o;36565:54::-;36617:2;36565:54;:::o;37031:351::-;37353:19;;37122:23;;37181:193;;37336:37;;:12;;:16;:37::i;:::-;37181:136;37297:19;:17;:19::i;:::-;37250:27;;37181:50;;:97;;:68;:97::i;:::-;:115;;:136::i;44965:1066::-;45056:10;45023:21;45047:20;;;:8;:20;;;;;45080:17;:15;:17::i;:::-;45166:34;45189:10;45166:22;:34::i;:::-;45230:112;45265:10;45298:4;45318:13;45230:20;:112::i;:::-;45213:14;:129;;;45480:25;;45476:274;;45522:3;;:67;;;-1:-1:-1;;;45522:67:0;;45547:10;45522:67;;;;45568:4;45522:67;;;;;;;;;;;;-1:-1:-1;;;;;45522:3:0;;;;:16;;:67;;;;;;;;;;;;;;;:3;;:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45621:1:0;45604:14;:18;45651:11;;:38;;45667:21;45651:15;:38::i;:::-;45637:52;;45723:15;45704:16;;;:34;45476:274;45824:8;:23;45808:11;;:50;;45853:4;;45808:40;;:15;:40::i;:50::-;45790:15;;;:68;45893:21;;:72;;45933:21;45893:25;:72::i;:::-;45869:21;:96;45981:42;;;;;;;;45989:10;;45981:42;;;;;;;;;;44965:1066;;;:::o;41712:124::-;-1:-1:-1;;;;;41800:15:0;41773:7;41800:15;;;:8;:15;;;;;:28;;;;41712:124::o;41034:670::-;-1:-1:-1;;;;;41134:15:0;;41090:7;41134:15;;;:8;:15;;;;;41185:8;:23;41236:11;;41282:21;;41320:16;41316:30;;41345:1;41338:8;;;;;;;;41316:30;41401:7;;41382:14;;41359:20;;41382:38;;41414:5;;41382:27;;:14;41401:7;;41382:18;:27::i;:38::-;41359:61;;41431:29;41463:32;41482:12;41463:14;;:18;;:32;;;;:::i;:::-;41431:64;-1:-1:-1;41506:11:0;41520:48;41556:11;41520:31;41431:64;41546:4;41520:25;:31::i;:48::-;41506:62;-1:-1:-1;41596:23:0;:14;41506:62;41596:18;:23::i;:::-;41680:15;;;;41579:40;;-1:-1:-1;41639:57:0;;:36;41670:4;41639:26;:6;41579:40;41639:10;:26::i;:36::-;:40;;:57::i;:::-;41632:64;41034:670;-1:-1:-1;;;;;;;;;41034:670:0:o;37879:119::-;37975:14;;37949:21;;37922:7;;37949:41;;:21;:25;:41::i;43410:61::-;43452:11;43461:1;43452:8;:11::i;36860:34::-;;;;:::o;37746:125::-;37807:7;37834:29;;;:21;:29;;;;;;;37746:125::o;36309:22::-;;;-1:-1:-1;;;;;36309:22:0;;:::o;49495:666::-;49564:30;;;;49542:118;;;;-1:-1:-1;;;49542:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49704:10;49671:21;49695:20;;;:8;:20;;;;;49776:11;;49750:21;;:38;;:25;:38::i;:::-;49726:21;:62;49825:11;;49869:3;;:28;;;-1:-1:-1;;;49869:28:0;;49891:4;49869:28;;;;;;-1:-1:-1;;;;;49869:3:0;;;;:13;;:28;;;;;;;;;;;;;;;:3;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49869:28:0;49851:46;;49847:125;;;49932:3;;:28;;;-1:-1:-1;;;49932:28:0;;49954:4;49932:28;;;;;;-1:-1:-1;;;;;49932:3:0;;;;:13;;:28;;;;;;;;;;;;;;;:3;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49932:28:0;;-1:-1:-1;49847:125:0;49982:53;50006:10;50019:15;49982;:53::i;:::-;50051:46;;;;;;;;50069:10;;50051:46;;;;;;;;;;-1:-1:-1;50122:1:0;50108:15;;;50134;;;;:19;49495:666::o;40102:152::-;28027:12;:10;:12::i;:::-;28017:6;;-1:-1:-1;;;;;28017:6:0;;;:22;;;28009:67;;;;;-1:-1:-1;;;28009:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28009:67:0;;;;;;;;;;;;;;;40186:4:::1;40174:8;:16;;;;40166:51;;;::::0;;-1:-1:-1;;;40166:51:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;40166:51:0;;;;;;;;;;;;;::::1;;40228:7;:18:::0;;-1:-1:-1;;40228:18:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;40102:152::o;33494:51::-;33543:2;33494:51;:::o;36437:29::-;;;;:::o;28750:244::-;28027:12;:10;:12::i;:::-;28017:6;;-1:-1:-1;;;;;28017:6:0;;;:22;;;28009:67;;;;;-1:-1:-1;;;28009:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28009:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;28839:22:0;::::1;28831:73;;;;-1:-1:-1::0;;;28831:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28941:6;::::0;28920:38:::1;::::0;-1:-1:-1;;;;;28920:38:0;;::::1;::::0;28941:6:::1;::::0;28920:38:::1;::::0;28941:6:::1;::::0;28920:38:::1;28969:6;:17:::0;;-1:-1:-1;;;;;;28969:17:0::1;-1:-1:-1::0;;;;;28969:17:0;;;::::1;::::0;;;::::1;::::0;;28750:244::o;36933:29::-;;;;:::o;43479:1420::-;43557:10;43524:21;43548:20;;;:8;:20;;;;;43587:11;;43579:24;;;;;;43614:17;:15;:17::i;:::-;43648:16;;;;43644:114;;43705:41;:15;36551:7;43705:19;:41::i;:::-;43686:16;;;:60;43644:114;43768:16;43821:4;:16;;;43803:15;:34;43799:314;;;43921:17;;;;;43898:20;43953:21;;;44008:41;:15;36551:7;44008:19;:41::i;:::-;43989:16;;;:60;44075:26;:8;44088:12;44075;:26::i;:::-;44064:37;;43799:314;;44125:15;44143:22;44154:10;44143;:22::i;:::-;44125:40;-1:-1:-1;44176:12:0;44191:47;44234:3;44191:38;44125:40;36617:2;44191:11;:38::i;:47::-;44176:62;-1:-1:-1;44249:21:0;44273:17;:7;44176:62;44273:11;:17::i;:::-;44249:41;-1:-1:-1;44305:17:0;;44301:106;;44359:17;;;;:36;;44381:13;44359:21;:36::i;:::-;44339:17;;;:56;44301:106;44430:18;:8;44443:4;44430:12;:18::i;:::-;44484:21;;44535:15;44516:16;;;:34;44645:11;;44419:29;;-1:-1:-1;44484:21:0;44645:25;;44419:29;44645:15;:25::i;:::-;44631:39;;;44715:8;:23;44699:50;;44744:4;;44699:40;;44631:39;44699:15;:40::i;:50::-;44681:15;;;:68;44784:21;;:35;;44810:8;44784:25;:35::i;:::-;44760:21;:59;44830:16;:14;:16::i;:::-;44862:29;;;;;;;;44870:10;;44862:29;;;;;;;;;;43479:1420;;;;;;:::o;42167:396::-;42217:18;42238:86;42301:12;:10;:12::i;:::-;42271:10;;42238:3;;:28;;;-1:-1:-1;;;42238:28:0;;42260:4;42238:28;;;;;;:44;;42271:10;-1:-1:-1;;;;;42238:3:0;;:13;;:28;;;;;;;;;;;;;;:3;:28;;;;;;;;;;:86;42217:107;-1:-1:-1;42341:14:0;;42337:219;;42385:46;42418:12;:10;:12::i;42385:46::-;42372:10;:59;42514:14;;:30;;42533:10;42514:18;:30::i;4222:136::-;4280:7;4307:43;4311:1;4314;4307:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4300:50;;4222:136;;;;;:::o;3766:181::-;3824:7;3856:5;;;3880:6;;;;3872:46;;;;;-1:-1:-1;;;3872:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;6035:132;6093:7;6120:39;6124:1;6127;6120:39;;;;;;;;;;;;;;;;;:3;:39::i;26081:106::-;26169:10;26081:106;:::o;47750:803::-;-1:-1:-1;;;;;47971:14:0;;47947:21;47971:14;;;:8;:14;;;;;48034:7;48004:26;47980:4;48004:20;:26::i;:::-;:37;;47996:68;;;;;-1:-1:-1;;;47996:68:0;;;;;;;;;;;;-1:-1:-1;;;47996:68:0;;;;;;;;;;;;;;;48077:17;:15;:17::i;:::-;48105:28;48128:4;48105:22;:28::i;:::-;48225:11;;48221:207;;48267:11;;:24;;48283:7;48267:15;:24::i;:::-;48253:38;;48330:21;;:34;;48356:7;48330:25;:34::i;:::-;48306:21;:58;48379:37;48403:2;48408:7;48379:15;:37::i;:::-;48472:8;:23;48456:11;;:50;;48501:4;;48456:40;;:15;:40::i;:50::-;48438:15;;;:68;48524:21;;;;;;;;-1:-1:-1;;;;;48524:21:0;;;;;;;;;;;;;47750:803;;;;:::o;48561:926::-;-1:-1:-1;;;;;48651:14:0;;48627:21;48651:14;;;:8;:14;;;;;48680:16;;;;48676:114;;48737:41;:15;36551:7;48737:19;:41::i;:::-;48718:16;;;:60;48676:114;48822:4;:16;;;48804:15;:34;48800:312;;;48922:17;;;;;48899:20;48954:21;;;48990:35;49006:4;48922:17;48990:15;:35::i;:::-;49059:41;:15;36551:7;49059:19;:41::i;:::-;49040:16;;;:60;-1:-1:-1;48800:312:0;49124:15;49142:16;49153:4;49142:10;:16::i;:::-;49124:34;-1:-1:-1;49169:12:0;49184:47;49227:3;49184:38;49124:34;36617:2;49184:11;:38::i;:47::-;49169:62;-1:-1:-1;49242:21:0;49266:17;:7;49169:62;49266:11;:17::i;:::-;49242:41;-1:-1:-1;49298:17:0;;49294:106;;49352:17;;;;:36;;49374:13;49352:21;:36::i;:::-;49332:17;;;:56;49294:106;49416:8;;49412:68;;49441:27;49457:4;49463;49441:15;:27::i;:::-;48561:926;;;;;:::o;40608:362::-;40744:7;40765:22;40822:3;;;;;;;;;-1:-1:-1;;;;;40822:3:0;-1:-1:-1;;;;;40822:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40822:28:0;40793:137;;;-1:-1:-1;;;40793:137:0;;-1:-1:-1;;;;;40793:137:0;;;;;;;;;;;;;;;;;;;;;;:107;;;;;:137;;;;;;;;;;;;;-1:-1:-1;40793:107:0;:137;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40793:137:0;;40608:362;-1:-1:-1;;;;;40608:362:0:o;5096:471::-;5154:7;5399:6;5395:47;;-1:-1:-1;5429:1:0;5422:8;;5395:47;5466:5;;;5470:1;5466;:5;:1;5490:5;;;;;:10;5482:56;;;;-1:-1:-1;;;5482:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42639:763;42736:21;;42679:22;;42772:16;42768:101;;42856:1;42849:8;;;;;42768:101;42896:14;;42965:7;;42896:14;;-1:-1:-1;42923:20:0;;42946:38;;42978:5;;42946:27;;42896:14;;42965:7;;42946:18;:27::i;:38::-;42923:61;-1:-1:-1;42995:29:0;43027:32;:14;42923:61;43027:18;:32::i;:::-;42995:64;-1:-1:-1;43072:11:0;43086:48;43122:11;43086:31;42995:64;43112:4;43086:25;:31::i;:48::-;43167:19;;43072:62;;-1:-1:-1;43167:37:0;;43191:12;43167:23;:37::i;:::-;43145:19;:59;43243:8;:23;:32;;43271:3;43243:27;:32::i;:::-;43217:8;:58;43316:27;;:78;;43362:21;43316:31;:78::i;:::-;43286:27;:108;-1:-1:-1;;;;42639:763:0;:::o;24451:508::-;24868:4;24914:17;24946:7;24451:508;:::o;27383:129::-;24050:12;;;;;;;;:31;;;24066:15;:13;:15::i;:::-;24050:47;;;-1:-1:-1;24086:11:0;;;;24085:12;24050:47;24042:106;;;;-1:-1:-1;;;24042:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24157:19;24180:12;;;;;;24179:13;24199:83;;;;24228:12;:19;;-1:-1:-1;;;;24228:19:0;;;;;24256:18;24243:4;24256:18;;;24199:83;27441:26:::1;:24;:26::i;:::-;27478;:24;:26::i;:::-;24304:14:::0;24300:57;;;24344:5;24329:20;;-1:-1:-1;;24329:20:0;;;27383:129;:::o;50169:448::-;50261:3;;:28;;;-1:-1:-1;;;50261:28:0;;50283:4;50261:28;;;;;;50244:14;;-1:-1:-1;;;;;50261:3:0;;:13;;:28;;;;;;;;;;;;;;:3;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50261:28:0;;-1:-1:-1;50306:16:0;;;50302:281;;;50339:3;;:25;;;-1:-1:-1;;;50339:25:0;;-1:-1:-1;;;;;50339:25:0;;;;;;;;;;;;;;;:3;;;;;:12;;:25;;;;;;;;;;;;;;:3;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50392:46:0;;-1:-1:-1;50425:12:0;:10;:12::i;50392:46::-;50379:10;:59;50302:281;;;50471:3;;:26;;;-1:-1:-1;;;50471:26:0;;-1:-1:-1;;;;;50471:26:0;;;;;;;;;;;;;;;:3;;;;;:12;;:26;;;;;;;;;;;;;;:3;;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50525:46:0;;-1:-1:-1;50558:12:0;:10;:12::i;50525:46::-;50512:10;:59;50302:281;50593:16;:14;:16::i;:::-;50169:448;;;:::o;4653:192::-;4739:7;4775:12;4767:6;;;;4759:29;;;;-1:-1:-1;;;4759:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4811:5:0;;;4653:192::o;6655:345::-;6741:7;6843:12;6836:5;6828:28;;;;-1:-1:-1;;;6828:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6867:9;6883:1;6879;:5;;;;;;;6655:345;-1:-1:-1;;;;;6655:345:0:o;26002:69::-;24050:12;;;;;;;;:31;;;24066:15;:13;:15::i;:::-;24050:47;;;-1:-1:-1;24086:11:0;;;;24085:12;24050:47;24042:106;;;;-1:-1:-1;;;24042:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24157:19;24180:12;;;;;;24179:13;24199:83;;;;24228:12;:19;;-1:-1:-1;;;;24228:19:0;;;;;24256:18;24243:4;24256:18;;;24304:14;24300:57;;;24344:5;24329:20;;-1:-1:-1;;24329:20:0;;;26002:69;:::o;27520:202::-;24050:12;;;;;;;;:31;;;24066:15;:13;:15::i;:::-;24050:47;;;-1:-1:-1;24086:11:0;;;;24085:12;24050:47;24042:106;;;;-1:-1:-1;;;24042:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24157:19;24180:12;;;;;;24179:13;24199:83;;;;24228:12;:19;;-1:-1:-1;;;;24228:19:0;;;;;24256:18;24243:4;24256:18;;;24199:83;27592:17:::1;27612:12;:10;:12::i;:::-;27635:6;:18:::0;;-1:-1:-1;;;;;;27635:18:0::1;-1:-1:-1::0;;;;;27635:18:0;::::1;::::0;;::::1;::::0;;;27669:43:::1;::::0;27635:18;;-1:-1:-1;27635:18:0;-1:-1:-1;;27669:43:0::1;::::0;-1:-1:-1;;27669:43:0::1;24290:1;24304:14:::0;24300:57;;;24344:5;24329:20;;-1:-1:-1;;24329:20:0;;;27520:202;:::o

ipfs://d4dc655a0cba9dd591da98801ac314aca3de8fa8672382758c9d93f2e0f7be70