Contract 0x8F4Ed4Cf0300E22c739d2E5A22220497B123b66e

/**
 *Submitted for verification at Arbiscan on 2023-01-05
*/

pragma solidity 0.6.12;


// 
/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

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

    /**
     * @dev Returns the token decimals.
     */
    function decimals() external view returns (uint8);

    /**
     * @dev Returns the token symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the token name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external view returns (address);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

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

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

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

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

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

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// 
/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-ERC20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external override view returns (address) {
        return owner();
    }

    /**
     * @dev Returns the token name.
     */
    function name() public override view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token decimals.
     */
    function decimals() public override view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Returns the token symbol.
     */
    function symbol() public override view returns (string memory) {
        return _symbol;
    }

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

    /**
     * @dev See {ERC20-balanceOf}.
     */
    function balanceOf(address account) public override view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {ERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {ERC20-allowance}.
     */
    function allowance(address owner, address spender) public override view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {ERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {ERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")
        );
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")
        );
        return true;
    }

    /**
     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
     * the total supply.
     *
     * Requirements
     *
     * - `msg.sender` must be the token owner
     */
    function mint(uint256 amount) public onlyOwner returns (bool) {
        _mint(_msgSender(), amount);
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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




// WaterfallToken with Governance.
contract WaterfallToken is ERC20('Waterfall DEX', 'WTFX') {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }
}



// MasterChef is the master of Waterfall. He can make Waterfall and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once KR is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract WaterfallMasterChefV2 is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;         // How many LP tokens the user has provided.
        uint256 rewardDebt;     // Reward debt. See explanation below.
        uint256 rewardLockedUp;  // Reward locked up.
        uint256 nextHarvestUntil; // When can the user harvest again.
        //
        // We do some fancy math here. Basically, any point in time, the amount of KRs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accWaterfallPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accWaterfallPerShare` (and `lastRewardTime`) 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.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;             // Address of LP token contract.
        uint256 allocPoint;         // How many allocation points assigned to this pool. KRs to distribute per second.
        uint256 lastRewardTime;     // Last time KRs distribution occurs.
        uint256 accWaterfallPerShare;  // Accumulated KRs per share, times 1e18. See below.
        uint16 depositFeeBP;        // Deposit fee in basis points
        uint256 harvestInterval;    // Harvest interval in seconds
    }

    // The KR TOKEN!
    WaterfallToken public immutable waterfall;
    // Dev address.
    address public devAddress;
    // KR tokens created per second.
    uint256 public waterfallPerSecond;
    // Deposit Fee address
    address public feeAddress;

    // MAX TOKEN SUPPLY
    uint256 public constant MAX_SUPPLY = 1000000 ether;

    // MAX POOL FEE
    uint256 public constant MAX_POOL_FEE = 200;

    // Max harvest interval: 5 days.
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 5 days;

    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The timestamp when KR mining starts.
    uint256 public startTime;
    
    // Maximum waterfallPerSecond
    uint256 public constant MAX_EMISSION_RATE = 0.1 ether;
    // Initial waterfallPerSecond
    uint256 public constant INITIAL_EMISSION_RATE = 0.07 ether;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event SetFeeAddress(address indexed user, address indexed newAddress);
    event SetDevAddress(address indexed user, address indexed newAddress);
    event UpdateEmissionRate(address indexed user, uint256 indexed waterfallPerSecond);
    event RewardLockedUp(address indexed user, uint256 indexed pid, uint256 amountLockedUp);
    event StartTimeChanged(uint256 oldStartTime, uint256 newStartTime);

    constructor(
        WaterfallToken _waterfall,
        address _devAddress,
        address _feeAddress,
        uint256 _startTime
    ) public {
        waterfall = _waterfall;
        devAddress = _devAddress;
        feeAddress = _feeAddress;
        waterfallPerSecond = INITIAL_EMISSION_RATE;
        startTime = _startTime;
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    mapping(IERC20 => bool) public poolExistence;
    modifier nonDuplicated(IERC20 _lpToken) {
        require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated");
        _;
    }
    
    function blockTimestamp() external view returns (uint time) { // to assist with countdowns on site
        time = block.timestamp;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function addPool(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) public onlyOwner nonDuplicated(_lpToken) {
        require(_depositFeeBP <= MAX_POOL_FEE, "add: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "add: invalid harvest interval");

        _lpToken.balanceOf(address(this));

        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolExistence[_lpToken] = true;
        poolInfo.push(PoolInfo({
        lpToken : _lpToken,
        allocPoint : _allocPoint,
        lastRewardTime: lastRewardTime,
        accWaterfallPerShare : 0,
        depositFeeBP : _depositFeeBP,
        harvestInterval : _harvestInterval
        }));
    }


     // Update startTime by the owner (added this to ensure that dev can delay startTime due to the congestion network). Only used if required. 
    function setStartTime(uint256 _newStartTime) external onlyOwner {
        require(startTime > block.timestamp, 'setStartTime: farm already started');
        require(_newStartTime > block.timestamp, 'setStartTime: new start time must be future time');

        uint256 _previousStartTime = startTime;

        startTime = _newStartTime;

        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; pid++) {
            PoolInfo storage pool = poolInfo[pid];
            pool.lastRewardTime = startTime;
        }

        emit StartTimeChanged(_previousStartTime, _newStartTime);
    }

    // Update the given pool's KR allocation point and deposit fee. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP, uint256 _harvestInterval, bool _withUpdate) external onlyOwner {
        require(_depositFeeBP <= MAX_POOL_FEE, "set: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "set: invalid harvest interval");

        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
        poolInfo[_pid].harvestInterval = _harvestInterval;
    }

    // Return reward multiplier over the given _from to _to timestamp.
    function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
        return _to.sub(_from);
    }

    // View function to see pending KRs on frontend.
    function pendingWaterfall(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accWaterfallPerShare = pool.accWaterfallPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0 && totalAllocPoint > 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 waterfallReward = multiplier.mul(waterfallPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
            accWaterfallPerShare = accWaterfallPerShare.add(waterfallReward.mul(1e18).div(lpSupply));
        }

        uint256 pending = user.amount.mul(accWaterfallPerShare).div(1e18).sub(user.rewardDebt);
        return pending.add(user.rewardLockedUp);
    }


    // View function to see if user can harvest Waterfalls's.
    function canHarvest(uint256 _pid, address _user) public view returns (bool) {
        UserInfo storage user = userInfo[_pid][_user];
        return block.timestamp >= user.nextHarvestUntil;
    }
    // View function to see if user harvest until time.
    function getHarvestUntil(uint256 _pid, address _user) external view returns (uint256) {
        UserInfo storage user = userInfo[_pid][_user];
        return user.nextHarvestUntil;
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 waterfallReward = multiplier.mul(waterfallPerSecond).mul(pool.allocPoint).div(totalAllocPoint);

        if (waterfall.totalSupply() >= MAX_SUPPLY) {
            waterfallReward = 0;
        } else if (waterfall.totalSupply().add(waterfallReward.mul(11).div(10)) >= MAX_SUPPLY) {
            waterfallReward = (MAX_SUPPLY.sub(waterfall.totalSupply()).mul(10).div(11));
        }

        if (waterfallReward > 0) {
            waterfall.mint(devAddress, waterfallReward.div(10));
            waterfall.mint(address(this), waterfallReward);
            pool.accWaterfallPerShare = pool.accWaterfallPerShare.add(waterfallReward.mul(1e18).div(lpSupply)); 
        }

        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens to MasterChef for KR allocation.
    function deposit(uint256 _pid, uint256 _amount) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);
        payOrLockuppendingWaterfall(_pid);

        if (_amount > 0) {
            uint256 _balanceBefore = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(msg.sender, address(this), _amount);
            // for token that have transfer tax
            _amount = pool.lpToken.balanceOf(address(this)).sub(_balanceBefore);
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
            } else {
                user.amount = user.amount.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accWaterfallPerShare).div(1e18);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        payOrLockuppendingWaterfall(_pid);

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(msg.sender, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accWaterfallPerShare).div(1e18);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    function getPoolHarvestInterval(uint256 _pid) internal view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];

        return block.timestamp.add(pool.harvestInterval);
    }

    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

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

    // Pay or lockup pending waterfall.
    function payOrLockuppendingWaterfall(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        if (user.nextHarvestUntil == 0) {
            user.nextHarvestUntil = getPoolHarvestInterval(_pid);
        }
        uint256 pending = user.amount.mul(pool.accWaterfallPerShare).div(1e18).sub(user.rewardDebt);
        if (canHarvest(_pid, msg.sender)) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 totalRewards = pending.add(user.rewardLockedUp);
                uint256 rewardsToLockup = totalRewards.div(2);
                uint256 rewardsToDistribute = totalRewards.sub(rewardsToLockup);
                // reset lockup
                totalLockedUpRewards = totalLockedUpRewards.sub(user.rewardLockedUp).add(rewardsToLockup);
                user.rewardLockedUp = rewardsToLockup;
                user.nextHarvestUntil = getPoolHarvestInterval(_pid);
                // send rewards
                safeWaterfallTransfer(msg.sender, rewardsToDistribute);
            }
        } else if (pending > 0) {
            user.rewardLockedUp = user.rewardLockedUp.add(pending);
            totalLockedUpRewards = totalLockedUpRewards.add(pending);
            emit RewardLockedUp(msg.sender, _pid, pending);
        }
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(msg.sender, user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
        user.rewardLockedUp = 0;
        user.nextHarvestUntil = 0;
    }

    // Safe waterfall transfer function, just in case if rounding error causes pool to not have enough KRs.
    function safeWaterfallTransfer(address _to, uint256 _amount) internal {
        uint256 waterfallBal = waterfall.balanceOf(address(this));
        bool transferSuccess = false;
        if (_amount > waterfallBal) {
            transferSuccess = waterfall.transfer(_to, waterfallBal);
        } else {
            transferSuccess = waterfall.transfer(_to, _amount);
        }
        require(transferSuccess, "safeWaterfallTransfer: transfer failed");
    }

    // Update dev address by the previous dev.
    function setDevAddress(address _devAddress) external {
        require(_devAddress != address(0), "setDevAddress: setting devAddress to the zero address is forbidden");
        require(msg.sender == devAddress, "setDevAddress: caller is not devAddress");
        devAddress = _devAddress;
        emit SetDevAddress(msg.sender, _devAddress);
    }

    function setFeeAddress(address _feeAddress) external {
        require(_feeAddress != address(0), "setFeeAddress: setting feeAddress to the zero address is forbidden");
        require(msg.sender == feeAddress, "setFeeAddress: caller is not feeAddress");
        feeAddress = _feeAddress;
        emit SetFeeAddress(msg.sender, _feeAddress);
    }

    //Pancake has to add hidden dummy pools inorder to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _waterfallPerSecond) external onlyOwner {
        require (_waterfallPerSecond <= MAX_EMISSION_RATE, "updateEmissionRate: value higher than maximum");
        massUpdatePools();
        waterfallPerSecond = _waterfallPerSecond;
        emit UpdateEmissionRate(msg.sender, _waterfallPerSecond);
    }
    
}

[{"inputs":[{"internalType":"contract WaterfallToken","name":"_waterfall","type":"address"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"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":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLockedUp","type":"uint256"}],"name":"RewardLockedUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldStartTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newStartTime","type":"uint256"}],"name":"StartTimeChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"waterfallPerSecond","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"INITIAL_EMISSION_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_HARVEST_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_EMISSION_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_POOL_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"addPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"blockTimestamp","outputs":[{"internalType":"uint256","name":"time","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"canHarvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"getHarvestUntil","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingWaterfall","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accWaterfallPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"harvestInterval","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newStartTime","type":"uint256"}],"name":"setStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedUpRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_waterfallPerSecond","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLockedUp","type":"uint256"},{"internalType":"uint256","name":"nextHarvestUntil","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"waterfall","outputs":[{"internalType":"contract WaterfallToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"waterfallPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

38927:16293:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42786:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54871:340;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;41211:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41452:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45140:657;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47028:198;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;40873:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40676:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;44404:626;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40814:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;41610:53;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50230:611;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;41140:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47817:1215;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52958:432;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47561:180;;;:::i;:::-;;47289:189;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;24959:148;;;:::i;:::-;;41538:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54388:352;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24308:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;45877:121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;41705:58;;;:::i;:::-;;;;;;;;;;;;;;;;;;;41293:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46060:895;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40746:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43093:138;;;:::i;:::-;;;;;;;;;;;;;;;;;;;42889:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;54028:352;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;43306:942;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;41042:57;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49099:1079;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40953:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40607:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;25262:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42786:95;42831:7;42858:8;:15;;;;42851:22;;42786:95;:::o;54871:340::-;24539:12;:10;:12::i;:::-;24528:23;;:7;:5;:7::i;:::-;:23;;;24520:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41654:9:::1;54967:19;:40;;54958:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55068:17;:15;:17::i;:::-;55117:19;55096:18;:40;;;;55183:19;55171:10;55152:51;;;;;;;;;;;;54871:340:::0;:::o;41211:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;41452:34::-;;;;:::o;45140:657::-;24539:12;:10;:12::i;:::-;24528:23;;:7;:5;:7::i;:::-;:23;;;24520:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40992:3:::1;45292:13;:29;;;;45284:79;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41093:6;45382:16;:44;;45374:86;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;45477:11;45473:61;;;45505:17;:15;:17::i;:::-;45473:61;45562:63;45613:11;45562:46;45582:8;45591:4;45582:14;;;;;;;;;;;;;;;;;;:25;;;45562:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;45544:15;:81;;;;45664:11;45636:8;45645:4;45636:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;45716:13;45686:8;45695:4;45686:14;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;45773:16;45740:8;45749:4;45740:14;;;;;;;;;;;;;;;;;;:30;;:49;;;;45140:657:::0;;;;;:::o;47028:198::-;47098:4;47115:21;47139:8;:14;47148:4;47139:14;;;;;;;;;;;:21;47154:5;47139:21;;;;;;;;;;;;;;;47115:45;;47197:4;:21;;;47178:15;:40;;47171:47;;;47028:198;;;;:::o;40873:50::-;40910:13;40873:50;:::o;40676:25::-;;;;;;;;;;;;;:::o;44404:626::-;24539:12;:10;:12::i;:::-;24528:23;;:7;:5;:7::i;:::-;:23;;;24520:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44499:15:::1;44487:9;;:27;44479:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44588:15;44572:13;:31;44564:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44669:26;44698:9;;44669:38;;44732:13;44720:9;:25;;;;44758:14;44775:8;:15;;;;44758:32;;44806:11;44801:153;44829:6;44823:3;:12;44801:153;;;44859:21;44883:8;44892:3;44883:13;;;;;;;;;;;;;;;;;;44859:37;;44933:9;;44911:4;:19;;:31;;;;44801:153;44837:5;;;;;;;44801:153;;;;44971:51;44988:18;45008:13;44971:51;;;;;;;;;;;;;;;;;;;;;;;;24599:1;;44404:626:::0;:::o;40814:25::-;;;;;;;;;;;;;:::o;41610:53::-;41654:9;41610:53;:::o;50230:611::-;27169:1;27775:7;;:19;;27767:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27169:1;27908:7;:18;;;;50312:21:::1;50336:8;50345:4;50336:14;;;;;;;;;;;;;;;;;;50312:38;;50361:21;50385:8;:14;50394:4;50385:14;;;;;;;;;;;:26;50400:10;50385:26;;;;;;;;;;;;;;;50361:50;;50445:7;50430:4;:11;;;:22;;50422:53;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;50486:16;50497:4;50486:10;:16::i;:::-;50513:33;50541:4;50513:27;:33::i;:::-;50573:1;50563:7;:11;50559:143;;;50605:24;50621:7;50605:4;:11;;;:15;;:24;;;;:::i;:::-;50591:4;:11;;:38;;;;50644:46;50670:10;50682:7;50644:4;:12;;;;;;;;;;;;:25;;;;:46;;;;;:::i;:::-;50559:143;50730:52;50777:4;50730:42;50746:4;:25;;;50730:4;:11;;;:15;;:42;;;;:::i;:::-;:46;;:52;;;;:::i;:::-;50712:4;:15;;:70;;;;50819:4;50807:10;50798:35;;;50825:7;50798:35;;;;;;;;;;;;;;;;;;27939:1;;27125::::0;28087:7;:22;;;;50230:611;;:::o;41140:35::-;;;;:::o;47817:1215::-;47869:21;47893:8;47902:4;47893:14;;;;;;;;;;;;;;;;;;47869:38;;47941:4;:19;;;47922:15;:38;47918:77;;47977:7;;;47918:77;48005:16;48024:4;:12;;;;;;;;;;;;:22;;;48055:4;48024:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48005:56;;48088:1;48076:8;:13;:37;;;;48112:1;48093:4;:15;;;:20;48076:37;48072:128;;;48152:15;48130:4;:19;;:37;;;;48182:7;;;;48072:128;48210:18;48231:51;48245:4;:19;;;48266:15;48231:13;:51::i;:::-;48210:72;;48293:23;48319:76;48379:15;;48319:55;48358:4;:15;;;48319:34;48334:18;;48319:10;:14;;:34;;;;:::i;:::-;:38;;:55;;;;:::i;:::-;:59;;:76;;;;:::i;:::-;48293:102;;40910:13;48412:9;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:37;48408:277;;48484:1;48466:19;;48408:277;;;40910:13;48507:60;48535:31;48563:2;48535:23;48555:2;48535:15;:19;;:23;;;;:::i;:::-;:27;;:31;;;;:::i;:::-;48507:9;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:27;;:60;;;;:::i;:::-;:74;48503:182;;48617:55;48669:2;48617:47;48661:2;48617:39;48632:9;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40910:13;48617:14;;:39;;;;:::i;:::-;:43;;:47;;;;:::i;:::-;:51;;:55;;;;:::i;:::-;48598:75;;48503:182;48408:277;48719:1;48701:15;:19;48697:278;;;48737:9;:14;;;48752:10;;;;;;;;;;;48764:23;48784:2;48764:15;:19;;:23;;;;:::i;:::-;48737:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48803:9;:14;;;48826:4;48833:15;48803:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48892:70;48922:39;48952:8;48922:25;48942:4;48922:15;:19;;:25;;;;:::i;:::-;:29;;:39;;;;:::i;:::-;48892:4;:25;;;:29;;:70;;;;:::i;:::-;48864:4;:25;;:98;;;;48697:278;49009:15;48987:4;:19;;:37;;;;47817:1215;;;;;;:::o;52958:432::-;27169:1;27775:7;;:19;;27767:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27169:1;27908:7;:18;;;;53032:21:::1;53056:8;53065:4;53056:14;;;;;;;;;;;;;;;;;;53032:38;;53081:21;53105:8;:14;53114:4;53105:14;;;;;;;;;;;:26;53120:10;53105:26;;;;;;;;;;;;;;;53081:50;;53142;53168:10;53180:4;:11;;;53142:4;:12;;;;;;;;;;;;:25;;;;:50;;;;;:::i;:::-;53238:4;53226:10;53208:48;;;53244:4;:11;;;53208:48;;;;;;;;;;;;;;;;;;53281:1;53267:4;:11;;:15;;;;53311:1;53293:4;:15;;:19;;;;53345:1;53323:4;:19;;:23;;;;53381:1;53357:4;:21;;:25;;;;27939:1;;27125::::0;28087:7;:22;;;;52958:432;:::o;47561:180::-;47606:14;47623:8;:15;;;;47606:32;;47654:11;47649:85;47677:6;47671:3;:12;47649:85;;;47707:15;47718:3;47707:10;:15::i;:::-;47685:5;;;;;47649:85;;;;47561:180;:::o;47289:189::-;47366:7;47386:21;47410:8;:14;47419:4;47410:14;;;;;;;;;;;:21;47425:5;47410:21;;;;;;;;;;;;;;;47386:45;;47449:4;:21;;;47442:28;;;47289:189;;;;:::o;24959:148::-;24539:12;:10;:12::i;:::-;24528:23;;:7;:5;:7::i;:::-;:23;;;24520:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25066:1:::1;25029:40;;25050:6;::::0;::::1;;;;;;;;25029:40;;;;;;;;;;;;25097:1;25080:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;24959:148::o:0;41538:24::-;;;;:::o;54388:352::-;54483:1;54460:25;;:11;:25;;;;54452:104;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54589:10;;;;;;;;;;;54575:24;;:10;:24;;;54567:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54667:11;54654:10;;:24;;;;;;;;;;;;;;;;;;54720:11;54694:38;;54708:10;54694:38;;;;;;;;;;;;54388:352;:::o;24308:87::-;24354:7;24381:6;;;;;;;;;;;24374:13;;24308:87;:::o;45877:121::-;45949:7;45976:14;45984:5;45976:3;:7;;:14;;;;:::i;:::-;45969:21;;45877:121;;;;:::o;41705:58::-;41753:10;41705:58;:::o;41293:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;46060:895::-;46138:7;46158:21;46182:8;46191:4;46182:14;;;;;;;;;;;;;;;;;;46158:38;;46207:21;46231:8;:14;46240:4;46231:14;;;;;;;;;;;:21;46246:5;46231:21;;;;;;;;;;;;;;;46207:45;;46263:28;46294:4;:25;;;46263:56;;46330:16;46349:4;:12;;;;;;;;;;;;:22;;;46380:4;46349:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46330:56;;46419:4;:19;;;46401:15;:37;:54;;;;;46454:1;46442:8;:13;;46401:54;:77;;;;;46477:1;46459:15;;:19;46401:77;46397:402;;;46495:18;46516:51;46530:4;:19;;;46551:15;46516:13;:51::i;:::-;46495:72;;46582:23;46608:76;46668:15;;46608:55;46647:4;:15;;;46608:34;46623:18;;46608:10;:14;;:34;;;;:::i;:::-;:38;;:55;;;;:::i;:::-;:59;;:76;;;;:::i;:::-;46582:102;;46722:65;46747:39;46777:8;46747:25;46767:4;46747:15;:19;;:25;;;;:::i;:::-;:29;;:39;;;;:::i;:::-;46722:20;:24;;:65;;;;:::i;:::-;46699:88;;46397:402;;;46811:15;46829:68;46881:4;:15;;;46829:47;46871:4;46829:37;46845:20;46829:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47;;;;:::i;:::-;:51;;:68;;;;:::i;:::-;46811:86;;46915:32;46927:4;:19;;;46915:7;:11;;:32;;;;:::i;:::-;46908:39;;;;;;;46060:895;;;;:::o;40746:33::-;;;;:::o;43093:138::-;43142:9;43208:15;43201:22;;43093:138;:::o;42889:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;54028:352::-;54123:1;54100:25;;:11;:25;;;;54092:104;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54229:10;;;;;;;;;;;54215:24;;:10;:24;;;54207:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54307:11;54294:10;;:24;;;;;;;;;;;;;;;;;;54360:11;54334:38;;54348:10;54334:38;;;;;;;;;;;;54028:352;:::o;43306:942::-;24539:12;:10;:12::i;:::-;24528:23;;:7;:5;:7::i;:::-;:23;;;24520:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43458:8:::1;43026:5;42999:32;;:13;:23;43013:8;42999:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;42991:70;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;40992:3:::2;43487:13;:29;;;;43479:79;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41093:6;43577:16;:44;;43569:86;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;43668:8;:18;;;43695:4;43668:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;43718:11;43714:61;;;43746:17;:15;:17::i;:::-;43714:61;43785:22;43828:9;;43810:15;:27;:57;;43858:9;;43810:57;;;43840:15;43810:57;43785:82;;43896:32;43916:11;43896:15;;:19;;:32;;;;:::i;:::-;43878:15;:50;;;;43965:4;43939:13;:23;43953:8;43939:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;43980:8;43994:245;;;;;;;;44024:8;43994:245;;;;;;44056:11;43994:245;;;;44094:14;43994:245;;;;44142:1;43994:245;;;;44169:13;43994:245;;;;;;44211:16;43994:245;;::::0;43980:260:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43072:1;24599::::1;43306:942:::0;;;;;:::o;41042:57::-;41093:6;41042:57;:::o;49099:1079::-;27169:1;27775:7;;:19;;27767:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27169:1;27908:7;:18;;;;49180:21:::1;49204:8;49213:4;49204:14;;;;;;;;;;;;;;;;;;49180:38;;49229:21;49253:8;:14;49262:4;49253:14;;;;;;;;;;;:26;49268:10;49253:26;;;;;;;;;;;;;;;49229:50;;49292:16;49303:4;49292:10;:16::i;:::-;49319:33;49347:4;49319:27;:33::i;:::-;49379:1;49369:7;:11;49365:675;;;49397:22;49422:4;:12;;;;;;;;;;;;:22;;;49453:4;49422:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;49397:62;;49474:65;49504:10;49524:4;49531:7;49474:4;:12;;;;;;;;;;;;:29;;;;:65;;;;;;:::i;:::-;49613:57;49655:14;49613:4;:12;;;;;;;;;;;;:22;;;49644:4;49613:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;:41;;:57;;;;:::i;:::-;49603:67;;49709:1;49689:4;:17;;;;;;;;;;;;:21;;;49685:344;;;49731:18;49752:41;49787:5;49752:30;49764:4;:17;;;;;;;;;;;;49752:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;49731:62;;49812:49;49838:10;;;;;;;;;;;49850;49812:4;:12;;;;;;;;;;;;:25;;;;:49;;;;;:::i;:::-;49894:40;49923:10;49894:24;49910:7;49894:4;:11;;;:15;;:24;;;;:::i;:::-;:28;;:40;;;;:::i;:::-;49880:4;:11;;:54;;;;49685:344;;;;49989:24;50005:7;49989:4;:11;;;:15;;:24;;;;:::i;:::-;49975:4;:11;;:38;;;;49685:344;49365:675;;50068:52;50115:4;50068:42;50084:4;:25;;;50068:4;:11;;;:15;;:42;;;;:::i;:::-;:46;;:52;;;;:::i;:::-;50050:4;:15;;:70;;;;50156:4;50144:10;50136:34;;;50162:7;50136:34;;;;;;;;;;;;;;;;;;27939:1;;27125::::0;28087:7;:22;;;;49099:1079;;:::o;40953:42::-;40992:3;40953:42;:::o;40607:41::-;;;:::o;25262:244::-;24539:12;:10;:12::i;:::-;24528:23;;:7;:5;:7::i;:::-;:23;;;24520:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25371:1:::1;25351:22;;:8;:22;;;;25343:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25461:8;25432:38;;25453:6;::::0;::::1;;;;;;;;25432:38;;;;;;;;;;;;25490:8;25481:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;25262:244:::0;:::o;22932:106::-;22985:15;23020:10;23013:17;;22932:106;:::o;3200:158::-;3258:7;3291:1;3286;:6;;3278:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3349:1;3345;:5;3338:12;;3200:158;;;;:::o;2738:179::-;2796:7;2816:9;2832:1;2828;:5;2816:17;;2857:1;2852;:6;;2844:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2908:1;2901:8;;;2738:179;;;;:::o;51524:1363::-;51595:21;51619:8;51628:4;51619:14;;;;;;;;;;;;;;;;;;51595:38;;51644:21;51668:8;:14;51677:4;51668:14;;;;;;;;;;;:26;51683:10;51668:26;;;;;;;;;;;;;;;51644:50;;51736:1;51711:4;:21;;;:26;51707:111;;;51778:28;51801:4;51778:22;:28::i;:::-;51754:4;:21;;:52;;;;51707:111;51828:15;51846:73;51903:4;:15;;;51846:52;51893:4;51846:42;51862:4;:25;;;51846:4;:11;;;:15;;:42;;;;:::i;:::-;:46;;:52;;;;:::i;:::-;:56;;:73;;;;:::i;:::-;51828:91;;51934:28;51945:4;51951:10;51934;:28::i;:::-;51930:950;;;51993:1;51983:7;:11;:38;;;;52020:1;51998:4;:19;;;:23;51983:38;51979:654;;;52042:20;52065:32;52077:4;:19;;;52065:7;:11;;:32;;;;:::i;:::-;52042:55;;52116:23;52142:19;52159:1;52142:12;:16;;:19;;;;:::i;:::-;52116:45;;52180:27;52210:33;52227:15;52210:12;:16;;:33;;;;:::i;:::-;52180:63;;52318:66;52368:15;52318:45;52343:4;:19;;;52318:20;;:24;;:45;;;;:::i;:::-;:49;;:66;;;;:::i;:::-;52295:20;:89;;;;52425:15;52403:4;:19;;:37;;;;52483:28;52506:4;52483:22;:28::i;:::-;52459:4;:21;;:52;;;;52563:54;52585:10;52597:19;52563:21;:54::i;:::-;51979:654;;;;51930:950;;;52664:1;52654:7;:11;52650:230;;;52704:32;52728:7;52704:4;:19;;;:23;;:32;;;;:::i;:::-;52682:4;:19;;:54;;;;52774:33;52799:7;52774:20;;:24;;:33;;;;:::i;:::-;52751:20;:56;;;;52854:4;52842:10;52827:41;;;52860:7;52827:41;;;;;;;;;;;;;;;;;;52650:230;51930:950;51524:1363;;;;:::o;19068:211::-;19185:86;19205:5;19235:23;;;19260:2;19264:5;19212:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19185:19;:86::i;:::-;19068:211;;;:::o;3617:220::-;3675:7;3704:1;3699;:6;3695:20;;;3714:1;3707:8;;;;3695:20;3726:9;3742:1;3738;:5;3726:17;;3771:1;3766;3762;:5;;;;;;:10;3754:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3828:1;3821:8;;;3617:220;;;;;:::o;4315:153::-;4373:7;4405:1;4401;:5;4393:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4459:1;4455;:5;;;;;;4448:12;;4315:153;;;;:::o;19287:248::-;19431:96;19451:5;19481:27;;;19510:4;19516:2;19520:5;19458:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19431:19;:96::i;:::-;19287:248;;;;:::o;50849:196::-;50918:7;50938:21;50962:8;50971:4;50962:14;;;;;;;;;;;;;;;;;;50938:38;;50996:41;51016:4;:20;;;50996:15;:19;;:41;;;;:::i;:::-;50989:48;;;50849:196;;;:::o;53507:465::-;53588:20;53611:9;:19;;;53639:4;53611:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53588:57;;53656:20;53709:12;53699:7;:22;53695:193;;;53756:9;:18;;;53775:3;53780:12;53756:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53738:55;;53695:193;;;53844:9;:18;;;53863:3;53868:7;53844:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53826:50;;53695:193;53906:15;53898:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53507:465;;;;:::o;21603:774::-;22027:23;22053:69;22081:4;22053:69;;;;;;;;;;;;;;;;;22061:5;22053:27;;;;:69;;;;;:::i;:::-;22027:95;;22157:1;22137:10;:17;:21;22133:237;;;22292:10;22281:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22273:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22133:237;21603:774;;;:::o;14163:195::-;14266:12;14298:52;14320:6;14328:4;14334:1;14337:12;14298:21;:52::i;:::-;14291:59;;14163:195;;;;;:::o;15215:530::-;15342:12;15400:5;15375:21;:30;;15367:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15467:18;15478:6;15467:10;:18::i;:::-;15459:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15593:12;15607:23;15634:6;:11;;15654:5;15662:4;15634:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15592:75;;;;15685:52;15703:7;15712:10;15724:12;15685:17;:52::i;:::-;15678:59;;;;15215:530;;;;;;:::o;11245:422::-;11305:4;11513:12;11624:7;11612:20;11604:28;;11658:1;11651:4;:8;11644:15;;;11245:422;;;:::o;17755:742::-;17870:12;17899:7;17895:595;;;17930:10;17923:17;;;;17895:595;18064:1;18044:10;:17;:21;18040:439;;;18307:10;18301:17;18368:15;18355:10;18351:2;18347:19;18340:44;18255:148;18450:12;18443:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17755:742;;;;;;:::o

55a6d88e66d5da3fc8cb614ba5d04b90ffef28ad2d38604456a01e56b0f708b0