Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-10-16
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

// File: node_modules\@openzeppelin\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) {
        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: node_modules\@openzeppelin\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");
    }

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

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

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

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

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

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

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

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

pragma solidity ^0.6.0;




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

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

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

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

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

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

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

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

// File: @openzeppelin\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: node_modules\@openzeppelin\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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

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

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

// File: contracts\SakeToken.sol

pragma solidity 0.6.12;






// SakeToken with Governance.
contract SakeToken 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 = "SakeToken";
    string private _symbol = "SAKE";
    uint8 private _decimals = 18;

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(sender, recipient, amount);

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

        _moveDelegates(_delegates[sender], _delegates[recipient], amount);
    }

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

        _beforeTokenTransfer(address(0), account, amount);

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

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

        _beforeTokenTransfer(account, address(0), amount);

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

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

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

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }

    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (SakeMaster).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    // Copied and modified from YAM code:
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
    // Which is copied and modified from COMPOUND:
    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol

    /// @notice A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @notice Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "SAKE::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "SAKE::delegateBySig: invalid nonce");
        require(now <= expiry, "SAKE::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "SAKE::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying SAKEs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld.sub(amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "SAKE::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

// File: contracts\SakeMasterV2.sol

pragma solidity 0.6.12;







// SakeMaster is the master of Sake. He can make Sake 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 SAKE is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract SakeMasterV2 is Ownable {
    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 amountStoken; // How many S tokens the user has provided.
        uint256 amountLPtoken; // How many LP tokens the user has provided.
        uint256 pengdingSake; // record sake amount when user withdraw lp.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 lastWithdrawBlock; // user last withdraw time;

        //
        // We do some fancy math here. Basically, any point in time, the amount of SAKEs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accSakePerShare` (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.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract.
        IERC20 sToken; // Address of S token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block.
        uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs.
        uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below.
        uint256 multiplierSToken; // times 1e8;
        bool sakeLockSwitch; // true-have sake withdraw interval,default 1 months;false-no withdraw interval,but have sake withdraw fee,default 10%
    }

    // The SAKE TOKEN!
    SakeToken public sake;
    // sakeMaker address.
    address public sakeMaker;
    // admin address.
    address public admin;
    // receive sake fee address
    address public sakeFeeAddress;
    // Block number when trade mining speed up period ends.
    uint256 public tradeMiningSpeedUpEndBlock;
    // Block number when phase II yield farming period ends.
    uint256 public yieldFarmingIIEndBlock;
    // Block number when trade mining period ends.
    uint256 public tradeMiningEndBlock;
    // trade mining speed end block num,about 1 months.
    uint256 public tradeMiningSpeedUpEndBlockNum = 192000;
    // phase II yield farming end block num,about 6 months.
    uint256 public yieldFarmingIIEndBlockNum = 1152000;
    // trade mining end block num,about 12 months.
    uint256 public tradeMiningEndBlockNum = 2304000;
    // SAKE tokens created per block for phase II yield farming.
    uint256 public sakePerBlockYieldFarming = 5 * 10**18;
    // SAKE tokens created per block for trade mining.
    uint256 public sakePerBlockTradeMining = 10 * 10**18;
    // Bonus muliplier for trade mining.
    uint256 public constant BONUS_MULTIPLIER = 2;
    // withdraw block num interval,about 1 months.
    uint256 public withdrawInterval = 192000;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when SAKE mining starts.
    uint256 public startBlock;
    // The ratio of withdraw lp fee(default is 0%)
    uint8 public lpFeeRatio = 0;
    // The ratio of withdraw sake fee if no withdraw interval(default is 10%)
    uint8 public sakeFeeRatio = 10;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens and S tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amountLPtoken, uint256 amountStoken);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amountLPtoken);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amountLPtoken);

    constructor(
        SakeToken _sake,
        address _admin,
        address _sakeMaker,
        address _sakeFeeAddress,
        uint256 _startBlock
    ) public {
        sake = _sake;
        admin = _admin;
        sakeMaker = _sakeMaker;
        sakeFeeAddress = _sakeFeeAddress;
        startBlock = _startBlock;
        tradeMiningSpeedUpEndBlock = startBlock.add(tradeMiningSpeedUpEndBlockNum);
        yieldFarmingIIEndBlock = startBlock.add(yieldFarmingIIEndBlockNum);
        tradeMiningEndBlock = startBlock.add(tradeMiningEndBlockNum);
    }

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

    // XXX DO NOT add the same LP token more than once.
    function _checkValidity(IERC20 _lpToken, IERC20 _sToken) internal view {
        for (uint256 i = 0; i < poolInfo.length; i++) {
            require(poolInfo[i].lpToken != _lpToken && poolInfo[i].sToken != _sToken, "pool exist");
        }
    }

    // Add a new lp to the pool. Can only be called by the admin.
    function add(
        uint256 _allocPoint,
        uint256 _multiplierSToken,
        IERC20 _lpToken,
        IERC20 _sToken,
        bool _withUpdate
    ) public {
        require(msg.sender == admin, "add:Call must come from admin.");
        if (_withUpdate) {
            massUpdatePools();
        }
        _checkValidity(_lpToken, _sToken);
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                sToken: _sToken,
                allocPoint: _allocPoint,
                multiplierSToken: _multiplierSToken,
                lastRewardBlock: lastRewardBlock,
                accSakePerShare: 0,
                sakeLockSwitch: true
            })
        );
    }

    // Update the given pool's SAKE allocation point. Can only be called by the admin.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        bool _withUpdate
    ) public {
        require(msg.sender == admin, "set:Call must come from admin.");
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    function setMultiplierSToken(
        uint256 _pid,
        uint256 _multiplierSToken,
        bool _withUpdate
    ) public {
        require(msg.sender == admin, "sms:Call must come from admin.");
        if (_withUpdate) {
            massUpdatePools();
        }
        poolInfo[_pid].multiplierSToken = _multiplierSToken;
    }

    // set sake withdraw switch. Can only be called by the admin.
    function setSakeLockSwitch(
        uint256 _pid,
        bool _sakeLockSwitch,
        bool _withUpdate
    ) public {
        require(msg.sender == admin, "s:Call must come from admin.");
        if (_withUpdate) {
            massUpdatePools();
        }
        poolInfo[_pid].sakeLockSwitch = _sakeLockSwitch;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256 multipY, uint256 multipT) {
        uint256 _toFinalY = _to > yieldFarmingIIEndBlock ? yieldFarmingIIEndBlock : _to;
        uint256 _toFinalT = _to > tradeMiningEndBlock ? tradeMiningEndBlock : _to;
        // phase II yield farming multiplier
        if (_from >= yieldFarmingIIEndBlock) {
            multipY = 0;
        } else {
            multipY = _toFinalY.sub(_from);
        }
        // trade mining multiplier
        if (_from >= tradeMiningEndBlock) {
            multipT = 0;
        } else {
            if (_toFinalT <= tradeMiningSpeedUpEndBlock) {
                multipT = _toFinalT.sub(_from).mul(BONUS_MULTIPLIER);
            } else {
                if (_from < tradeMiningSpeedUpEndBlock) {
                    multipT = tradeMiningSpeedUpEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(
                        _toFinalT.sub(tradeMiningSpeedUpEndBlock)
                    );
                } else {
                    multipT = _toFinalT.sub(_from);
                }
            }
        }
    }

    function getSakePerBlock(uint256 blockNum) public view returns (uint256) {
        if (blockNum <= tradeMiningSpeedUpEndBlock) {
            return sakePerBlockYieldFarming.add(sakePerBlockTradeMining.mul(BONUS_MULTIPLIER));
        } else if (blockNum > tradeMiningSpeedUpEndBlock && blockNum <= yieldFarmingIIEndBlock) {
            return sakePerBlockYieldFarming.add(sakePerBlockTradeMining);
        } else if (blockNum > yieldFarmingIIEndBlock && blockNum <= tradeMiningEndBlock) {
            return sakePerBlockTradeMining;
        } else {
            return 0;
        }
    }

    // Handover the saketoken mintage right.
    function handoverSakeMintage(address newOwner) public onlyOwner {
        sake.transferOwnership(newOwner);
    }

    // View function to see pending SAKEs on frontend.
    function pendingSake(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accSakePerShare = pool.accSakePerShare;
        uint256 lpTokenSupply = pool.lpToken.balanceOf(address(this));
        uint256 sTokenSupply = pool.sToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpTokenSupply != 0) {
            uint256 totalSupply = lpTokenSupply.add(sTokenSupply.mul(pool.multiplierSToken).div(1e8));
            (uint256 multipY, uint256 multipT) = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 sakeRewardY = multipY.mul(sakePerBlockYieldFarming).mul(pool.allocPoint).div(totalAllocPoint);
            uint256 sakeRewardT = multipT.mul(sakePerBlockTradeMining).mul(pool.allocPoint).div(totalAllocPoint);
            uint256 sakeReward = sakeRewardY.add(sakeRewardT);
            accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(totalSupply));
        }
        return user.amount.mul(accSakePerShare).div(1e12).add(user.pengdingSake).sub(user.rewardDebt);
    }

    // Update reward vairables 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.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpTokenSupply = pool.lpToken.balanceOf(address(this));
        uint256 sTokenSupply = pool.sToken.balanceOf(address(this));
        if (lpTokenSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        (uint256 multipY, uint256 multipT) = getMultiplier(pool.lastRewardBlock, block.number);
        if (multipY == 0 && multipT == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 sakeRewardY = multipY.mul(sakePerBlockYieldFarming).mul(pool.allocPoint).div(totalAllocPoint);
        uint256 sakeRewardT = multipT.mul(sakePerBlockTradeMining).mul(pool.allocPoint).div(totalAllocPoint);
        uint256 sakeReward = sakeRewardY.add(sakeRewardT);
        uint256 totalSupply = lpTokenSupply.add(sTokenSupply.mul(pool.multiplierSToken).div(1e8));
        if (sake.owner() == address(this)) {
            sake.mint(address(this), sakeRewardT);
        }
        pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(totalSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to SakeMasterV2 for SAKE allocation.
    function deposit(
        uint256 _pid,
        uint256 _amountlpToken,
        uint256 _amountsToken
    ) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        if (_amountlpToken <= 0 && user.pengdingSake == 0) {
            require(user.amountLPtoken > 0, "deposit:invalid");
        }
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).add(user.pengdingSake).sub(user.rewardDebt);
        uint256 _originAmountStoken = user.amountStoken;
        user.amountLPtoken = user.amountLPtoken.add(_amountlpToken);
        user.amountStoken = user.amountStoken.add(_amountsToken);
        user.amount = user.amount.add(_amountlpToken.add(_amountsToken.mul(pool.multiplierSToken).div(1e8)));
        user.pengdingSake = pending;
        if (pool.sakeLockSwitch) {
            if (block.number > (user.lastWithdrawBlock.add(withdrawInterval))) {
                user.lastWithdrawBlock = block.number;
                user.pengdingSake = 0;
                user.amountStoken = _amountsToken;
                user.amount = user.amountLPtoken.add(_amountsToken.mul(pool.multiplierSToken).div(1e8));
                pool.sToken.safeTransfer(address(1), _originAmountStoken);
                if (pending > 0) {
                    _safeSakeTransfer(msg.sender, pending);
                }
            }
        } else {
            user.lastWithdrawBlock = block.number;
            user.pengdingSake = 0;
            if (_amountlpToken == 0 && _amountsToken == 0) {
                user.amountStoken = 0;
                user.amount = user.amountLPtoken;
                pool.sToken.safeTransfer(address(1), _originAmountStoken);
            }
            if (pending > 0) {
                uint256 sakeFee = pending.mul(sakeFeeRatio).div(100);
                uint256 sakeToUser = pending.sub(sakeFee);
                _safeSakeTransfer(msg.sender, sakeToUser);
                _safeSakeTransfer(sakeFeeAddress, sakeFee);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12);
        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amountlpToken);
        pool.sToken.safeTransferFrom(address(msg.sender), address(this), _amountsToken);
        emit Deposit(msg.sender, _pid, _amountlpToken, _amountsToken);
    }

    // Withdraw LP tokens from SakeMaster.
    function withdraw(uint256 _pid, uint256 _amountLPtoken) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amountLPtoken >= _amountLPtoken, "withdraw: LP amount not enough");
        updatePool(_pid);
        uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).add(user.pengdingSake).sub(user.rewardDebt);
        user.amountLPtoken = user.amountLPtoken.sub(_amountLPtoken);
        uint256 _amountStoken = user.amountStoken;
        user.amountStoken = 0;
        user.amount = user.amountLPtoken;
        user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12);
        if (pool.sakeLockSwitch) {
            if (block.number > (user.lastWithdrawBlock.add(withdrawInterval))) {
                user.lastWithdrawBlock = block.number;
                user.pengdingSake = 0;
                _safeSakeTransfer(msg.sender, pending);
            } else {
                user.pengdingSake = pending;
            }
        } else {
            user.lastWithdrawBlock = block.number;
            user.pengdingSake = 0;
            uint256 sakeFee = pending.mul(sakeFeeRatio).div(100);
            uint256 sakeToUser = pending.sub(sakeFee);
            _safeSakeTransfer(msg.sender, sakeToUser);
            _safeSakeTransfer(sakeFeeAddress, sakeFee);
        }
        uint256 lpTokenFee;
        uint256 lpTokenToUser;
        if (block.number < tradeMiningEndBlock) {
            lpTokenFee = _amountLPtoken.mul(lpFeeRatio).div(100);
            pool.lpToken.safeTransfer(sakeMaker, lpTokenFee);
        }
        lpTokenToUser = _amountLPtoken.sub(lpTokenFee);
        pool.lpToken.safeTransfer(address(msg.sender), lpTokenToUser);
        pool.sToken.safeTransfer(address(1), _amountStoken);
        emit Withdraw(msg.sender, _pid, lpTokenToUser);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amountLPtoken > 0, "withdraw: LP amount not enough");
        uint256 _amountLPtoken = user.amountLPtoken;
        uint256 _amountStoken = user.amountStoken;
        user.amount = 0;
        user.amountLPtoken = 0;
        user.amountStoken = 0;
        user.rewardDebt = 0;

        uint256 lpTokenFee;
        uint256 lpTokenToUser;
        if (block.number < tradeMiningEndBlock) {
            lpTokenFee = _amountLPtoken.mul(lpFeeRatio).div(100);
            pool.lpToken.safeTransfer(sakeMaker, lpTokenFee);
        }
        lpTokenToUser = _amountLPtoken.sub(lpTokenFee);
        pool.lpToken.safeTransfer(address(msg.sender), lpTokenToUser);
        pool.sToken.safeTransfer(address(1), _amountStoken);
        emit EmergencyWithdraw(msg.sender, _pid, lpTokenToUser);
    }

    // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs.
    function _safeSakeTransfer(address _to, uint256 _amount) internal {
        uint256 sakeBal = sake.balanceOf(address(this));
        if (_amount > sakeBal) {
            sake.transfer(_to, sakeBal);
        } else {
            sake.transfer(_to, _amount);
        }
    }

    // Update admin address by owner.
    function setAdmin(address _adminaddr) public onlyOwner {
        require(_adminaddr != address(0), "invalid address");
        admin = _adminaddr;
    }

    // Update sakeMaker address by admin.
    function setSakeMaker(address _sakeMaker) public {
        require(msg.sender == admin, "sm:Call must come from admin.");
        require(_sakeMaker != address(0), "invalid address");
        sakeMaker = _sakeMaker;
    }

    // Update sakeFee address by admin.
    function setSakeFeeAddress(address _sakeFeeAddress) public {
        require(msg.sender == admin, "sf:Call must come from admin.");
        require(_sakeFeeAddress != address(0), "invalid address");
        sakeFeeAddress = _sakeFeeAddress;
    }

    // update tradeMiningSpeedUpEndBlock by owner
    function setTradeMiningSpeedUpEndBlock(uint256 _endBlock) public {
        require(msg.sender == admin, "tmsu:Call must come from admin.");
        require(_endBlock > startBlock, "invalid endBlock");
        tradeMiningSpeedUpEndBlock = _endBlock;
    }

    // update yieldFarmingIIEndBlock by owner
    function setYieldFarmingIIEndBlock(uint256 _endBlock) public {
        require(msg.sender == admin, "yf:Call must come from admin.");
        require(_endBlock > startBlock, "invalid endBlock");
        yieldFarmingIIEndBlock = _endBlock;
    }

    // update tradeMiningEndBlock by owner
    function setTradeMiningEndBlock(uint256 _endBlock) public {
        require(msg.sender == admin, "tm:Call must come from admin.");
        require(_endBlock > startBlock, "invalid endBlock");
        tradeMiningEndBlock = _endBlock;
    }

    function setSakeFeeRatio(uint8 newRatio) public {
        require(msg.sender == admin, "sfr:Call must come from admin.");
        require(newRatio >= 0 && newRatio <= 100, "invalid ratio");
        sakeFeeRatio = newRatio;
    }

    function setLpFeeRatio(uint8 newRatio) public {
        require(msg.sender == admin, "lp:Call must come from admin.");
        require(newRatio >= 0 && newRatio <= 100, "invalid ratio");
        lpFeeRatio = newRatio;
    }

    function setWithdrawInterval(uint256 _blockNum) public {
        require(msg.sender == admin, "i:Call must come from admin.");
        withdrawInterval = _blockNum;
    }

    // set sakePerBlock phase II yield farming
    function setSakePerBlockYieldFarming(uint256 _sakePerBlockYieldFarming, bool _withUpdate) public {
        require(msg.sender == admin, "yield:Call must come from admin.");
        if (_withUpdate) {
            massUpdatePools();
        }
        sakePerBlockYieldFarming = _sakePerBlockYieldFarming;
    }

    // set sakePerBlock trade mining
    function setSakePerBlockTradeMining(uint256 _sakePerBlockTradeMining, bool _withUpdate) public {
        require(msg.sender == admin, "trade:Call must come from admin.");
        if (_withUpdate) {
            massUpdatePools();
        }
        sakePerBlockTradeMining = _sakePerBlockTradeMining;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract SakeToken","name":"_sake","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"address","name":"_sakeMaker","type":"address"},{"internalType":"address","name":"_sakeFeeAddress","type":"address"},{"internalType":"uint256","name":"_startBlock","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":"amountLPtoken","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountStoken","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":"amountLPtoken","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":"amountLPtoken","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint256","name":"_multiplierSToken","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"contract IERC20","name":"_sToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amountlpToken","type":"uint256"},{"internalType":"uint256","name":"_amountsToken","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"multipY","type":"uint256"},{"internalType":"uint256","name":"multipT","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNum","type":"uint256"}],"name":"getSakePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"handoverSakeMintage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lpFeeRatio","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","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":"pendingSake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"contract IERC20","name":"sToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accSakePerShare","type":"uint256"},{"internalType":"uint256","name":"multiplierSToken","type":"uint256"},{"internalType":"bool","name":"sakeLockSwitch","type":"bool"}],"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":[],"name":"sake","outputs":[{"internalType":"contract SakeToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakeFeeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakeFeeRatio","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakeMaker","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakePerBlockTradeMining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakePerBlockYieldFarming","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_adminaddr","type":"address"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newRatio","type":"uint8"}],"name":"setLpFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_multiplierSToken","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setMultiplierSToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sakeFeeAddress","type":"address"}],"name":"setSakeFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newRatio","type":"uint8"}],"name":"setSakeFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"bool","name":"_sakeLockSwitch","type":"bool"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSakeLockSwitch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sakeMaker","type":"address"}],"name":"setSakeMaker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sakePerBlockTradeMining","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSakePerBlockTradeMining","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sakePerBlockYieldFarming","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSakePerBlockYieldFarming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"setTradeMiningEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"setTradeMiningSpeedUpEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_blockNum","type":"uint256"}],"name":"setWithdrawInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"setYieldFarmingIIEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","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":"tradeMiningEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeMiningEndBlockNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeMiningSpeedUpEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeMiningSpeedUpEndBlockNum","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":"_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":"amountStoken","type":"uint256"},{"internalType":"uint256","name":"amountLPtoken","type":"uint256"},{"internalType":"uint256","name":"pengdingSake","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amountLPtoken","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldFarmingIIEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldFarmingIIEndBlockNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000066798d9ef0833ccc719076dab77199ecbd178b0000000000000000000000000142151d3b15b8961f2937cf7880bcd10c050800c000000000000000000000000ea3978b82419d5671c14aa6151b7e92fc0b1fd220000000000000000000000005fe808a4889b714496e7b821c8542e26be2f8f670000000000000000000000000000000000000000000000000000000000a8ec88

-----Decoded View---------------
Arg [0] : _sake (address): 0x066798d9ef0833ccc719076Dab77199eCbd178b0
Arg [1] : _admin (address): 0x142151D3b15b8961F2937Cf7880Bcd10c050800C
Arg [2] : _sakeMaker (address): 0xEa3978b82419D5671C14aa6151B7E92fc0b1Fd22
Arg [3] : _sakeFeeAddress (address): 0x5fe808a4889b714496E7b821c8542e26be2f8f67
Arg [4] : _startBlock (uint256): 11070600

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000066798d9ef0833ccc719076dab77199ecbd178b0
Arg [1] : 000000000000000000000000142151d3b15b8961f2937cf7880bcd10c050800c
Arg [2] : 000000000000000000000000ea3978b82419d5671c14aa6151b7e92fc0b1fd22
Arg [3] : 0000000000000000000000005fe808a4889b714496e7b821c8542e26be2f8f67
Arg [4] : 0000000000000000000000000000000000000000000000000000000000a8ec88

48313:21137:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60543:2435;;;;;;;;;;;;;;;;-1:-1:-1;60543:2435:0;;;;;;;;;;;;:::i;:::-;;51145:52;;;:::i;:::-;;;;;;;;;;;;;;;;52992:95;;;:::i;51260:52::-;;;:::i;51953:26::-;;;;;;;;;;;;;;;;-1:-1:-1;51953:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;51953:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51464:40;;;:::i;51599:34::-;;;:::i;55285:330::-;;;;;;;;;;;;;;;;-1:-1:-1;55285:330:0;;;;;;;;;;;;;;;;:::i;56829:596::-;;;;;;;;;;;;;;;;-1:-1:-1;56829:596:0;;:::i;54867:343::-;;;;;;;;;;;;;;;;-1:-1:-1;54867:343:0;;;;;;;;;;;;;;:::i;51887:30::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;68548:173;;;;;;;;;;;;;;;;-1:-1:-1;68548:173:0;;:::i;68073:232::-;;;;;;;;;;;;;;;;-1:-1:-1;68073:232:0;;;;:::i;63030:1899::-;;;;;;;;;;;;;;;;-1:-1:-1;63030:1899:0;;;;;;;:::i;50795:53::-;;;:::i;51690:25::-;;;:::i;68777:314::-;;;;;;;;;;;;;;;;-1:-1:-1;68777:314:0;;;;;;;;;:::i;59171:1301::-;;;;;;;;;;;;;;;;-1:-1:-1;59171:1301:0;;:::i;65000:981::-;;;;;;;;;;;;;;;;-1:-1:-1;65000:981:0;;:::i;67210:258::-;;;;;;;;;;;;;;;;-1:-1:-1;67210:258:0;;:::i;58915:180::-;;;:::i;54458:401::-;;;;;;;;;;;;;;;;-1:-1:-1;54458:401:0;;;;;;;;;;;;;;:::i;50280:24::-;;;:::i;:::-;;;;-1:-1:-1;;;;;50280:24:0;;;;;;;;;;;;;;66421:155;;;;;;;;;;;;;;;;-1:-1:-1;66421:155:0;-1:-1:-1;;;;;66421:155:0;;:::i;28986:148::-;;;:::i;50601:37::-;;;:::i;67823:242::-;;;;;;;;;;;;;;;;-1:-1:-1;67823:242:0;;:::i;51361:44::-;;;:::i;28344:79::-;;;:::i;55691:1130::-;;;;;;;;;;;;;;;;-1:-1:-1;55691:1130:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;52048:64;;;;;;;;;;;;;;;;-1:-1:-1;52048:64:0;;;;;;-1:-1:-1;;;;;52048:64:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57479:115;;;;;;;;;;;;;;;;-1:-1:-1;57479:115:0;-1:-1:-1;;;;;57479:115:0;;:::i;50225:21::-;;;:::i;50916:50::-;;;:::i;50394:29::-;;;:::i;66901:250::-;;;;;;;;;;;;;;;;-1:-1:-1;66901:250:0;-1:-1:-1;;;;;66901:250:0;;:::i;68313:227::-;;;;;;;;;;;;;;;;-1:-1:-1;68313:227:0;;;;:::i;50697:34::-;;;:::i;50491:41::-;;;:::i;57658:1174::-;;;;;;;;;;;;;;;;-1:-1:-1;57658:1174:0;;;;;;-1:-1:-1;;;;;57658:1174:0;;:::i;53476:886::-;;;;;;;;;;;;;;;;-1:-1:-1;53476:886:0;;;;;;;;-1:-1:-1;;;;;53476:886:0;;;;;;;;;;;;;;;;;;;;;:::i;29289:244::-;;;;;;;;;;;;;;;;-1:-1:-1;29289:244:0;-1:-1:-1;;;;;29289:244:0;;:::i;51774:27::-;;;:::i;67523:248::-;;;;;;;;;;;;;;;;-1:-1:-1;67523:248:0;;:::i;50334:20::-;;;:::i;66627:225::-;;;;;;;;;;;;;;;;-1:-1:-1;66627:225:0;-1:-1:-1;;;;;66627:225:0;;:::i;69137:310::-;;;;;;;;;;;;;;;;-1:-1:-1;69137:310:0;;;;;;;;;:::i;51025:47::-;;;:::i;60543:2435::-;60673:21;60697:8;60706:4;60697:14;;;;;;;;;;;;;;;;60746;;;:8;:14;;;;;;60761:10;60746:26;;;;;;;60697:14;;;;;;;;-1:-1:-1;60787:19:0;;;;:45;;-1:-1:-1;60810:17:0;;;;:22;60787:45;60783:128;;;60878:1;60857:4;:18;;;:22;60849:50;;;;;-1:-1:-1;;;60849:50:0;;;;;;;;;;;;-1:-1:-1;;;60849:50:0;;;;;;;;;;;;;;;60921:16;60932:4;60921:10;:16::i;:::-;60948:15;60966:91;61041:4;:15;;;60966:70;61018:4;:17;;;60966:47;61008:4;60966:37;60982:4;:20;;;60966:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47::i;:::-;:51;;:70::i;:::-;:74;;:91::i;:::-;61098:17;;;;61147:18;;;;60948:109;;-1:-1:-1;61098:17:0;61147:38;;61170:14;61147:22;:38::i;:::-;61126:18;;;:59;61216:17;;;;:36;;61238:13;61216:21;:36::i;:::-;61196:4;:17;;:56;;;;61277:86;61293:69;61312:49;61357:3;61312:40;61330:4;:21;;;61312:13;:17;;:40;;;;:::i;:49::-;61293:14;;:18;:69::i;:::-;61277:11;;;:15;:86::i;:::-;61263:100;;61374:17;;;:27;;;61416:19;;;;;;61412:1229;;;61499:16;;61472:22;;;;:44;;:26;:44::i;:::-;61456:12;:61;61452:529;;;61563:12;61538:22;;;;:37;;;;61614:1;61594:17;;;:21;61634:17;;;:33;;;61741:21;;;61700:73;;61723:49;;61768:3;;61723:40;;61654:13;;61723:17;:40::i;:49::-;61700:18;;;;;:22;:73::i;:::-;61686:87;;61825:1;61792:11;;;;:57;;-1:-1:-1;;;;;61792:11:0;;;;61829:19;61792:24;:57::i;:::-;61872:11;;61868:98;;61908:38;61926:10;61938:7;61908:17;:38::i;:::-;61412:1229;;;62038:12;62013:22;;;:37;62085:1;62065:17;;;:21;62105:19;;:41;;;;-1:-1:-1;62128:18:0;;62105:41;62101:230;;;62187:1;62167:17;;;;:21;;;;62221:18;;;;62207:32;;62258:11;;;;:57;;-1:-1:-1;;;;;62258:11:0;;;;62295:19;62258:24;:57::i;:::-;62349:11;;62345:285;;62411:12;;62381:15;;62399:34;;62429:3;;62399:25;;:7;;62411:12;;;;;62399:11;:25::i;:34::-;62381:52;-1:-1:-1;62452:18:0;62473:20;:7;62381:52;62473:11;:20::i;:::-;62452:41;;62512;62530:10;62542;62512:17;:41::i;:::-;62590:14;;62572:42;;-1:-1:-1;;;;;62590:14:0;62606:7;62572:17;:42::i;:::-;62345:285;;;62685:20;;;;62669:11;;:47;;62711:4;;62669:37;;:15;:37::i;:47::-;62651:15;;;:65;62727:12;;:81;;-1:-1:-1;;;;;62727:12:0;62765:10;62786:4;62793:14;62727:29;:81::i;:::-;62819:11;;;;:79;;-1:-1:-1;;;;;62819:11:0;62856:10;62877:4;62884:13;62819:28;:79::i;:::-;62914:56;;;;;;;;;;;;;;62934:4;;62922:10;;62914:56;;;;;;;;;;;60543:2435;;;;;;;:::o;51145:52::-;;;;:::o;52992:95::-;53064:8;:15;52992:95;:::o;51260:52::-;;;;:::o;51953:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;51953:26:0;;;;-1:-1:-1;51953:26:0;;;;;;;;;;;;;;:::o;51464:40::-;;;;:::o;51599:34::-;;;;:::o;55285:330::-;55440:5;;-1:-1:-1;;;;;55440:5:0;55426:10;:19;55418:60;;;;;-1:-1:-1;;;55418:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55493:11;55489:61;;;55521:17;:15;:17::i;:::-;55592:15;55560:8;55569:4;55560:14;;;;;;;;;;;;;;;;;;;;;:29;;:47;;-1:-1:-1;;55560:47:0;;;;;;;;;;-1:-1:-1;;;55285:330:0:o;56829:596::-;56893:7;56929:26;;56917:8;:38;56913:505;;57008:23;;56979:75;;57008:45;;51404:1;57008:27;:45::i;:::-;56979:24;;;:28;:75::i;:::-;56972:82;;;;56913:505;57087:26;;57076:8;:37;:75;;;;;57129:22;;57117:8;:34;;57076:75;57072:346;;;57204:23;;57175:24;;:53;;:28;:53::i;57072:346::-;57261:22;;57250:8;:33;:68;;;;;57299:19;;57287:8;:31;;57250:68;57246:172;;;-1:-1:-1;57342:23:0;;57335:30;;57246:172;-1:-1:-1;57405:1:0;57246:172;56829:596;;;:::o;54867:343::-;55029:5;;-1:-1:-1;;;;;55029:5:0;55015:10;:19;55007:62;;;;;-1:-1:-1;;;55007:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55084:11;55080:61;;;55112:17;:15;:17::i;:::-;55185;55151:8;55160:4;55151:14;;;;;;;;;;;;;;;;;;:31;;:51;;;;54867:343;;;:::o;51887:30::-;;;;;;;;;:::o;68548:173::-;68636:5;;-1:-1:-1;;;;;68636:5:0;68622:10;:19;68614:60;;;;;-1:-1:-1;;;68614:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;68685:16;:28;68548:173::o;68073:232::-;68154:5;;-1:-1:-1;;;;;68154:5:0;68140:10;:19;68132:62;;;;;-1:-1:-1;;;68132:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;68242:3;68230:8;:15;;;;68205:58;;;;;-1:-1:-1;;;68205:58:0;;;;;;;;;;;;-1:-1:-1;;;68205:58:0;;;;;;;;;;;;;;;68274:12;:23;;;;;;;;-1:-1:-1;;68274:23:0;;;;;;;;;68073:232::o;63030:1899::-;63104:21;63128:8;63137:4;63128:14;;;;;;;;;;;;;;;;63177;;;:8;:14;;;;;;63192:10;63177:26;;;;;;;63222:18;;;;63128:14;;;;;;;;-1:-1:-1;63222:36:0;-1:-1:-1;63222:36:0;63214:79;;;;;-1:-1:-1;;;63214:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;63304:16;63315:4;63304:10;:16::i;:::-;63331:15;63349:91;63424:4;:15;;;63349:70;63401:4;:17;;;63349:47;63391:4;63349:37;63365:4;:20;;;63349:4;:11;;;:15;;:37;;;;:::i;:91::-;63472:18;;;;63331:109;;-1:-1:-1;63472:38:0;;63495:14;63472:22;:38::i;:::-;63451:18;;;:59;;;63545:17;;;;;63521:21;63573;;;63605:32;;;63682:20;;;;63545:17;;63666:47;;63708:4;;63666:37;;:15;:37::i;:47::-;63648:15;;;:65;63728:19;;;;;;63724:697;;;63811:16;;63784:22;;;;:44;;:26;:44::i;:::-;63768:12;:61;63764:304;;;63875:12;63850:22;;;:37;63926:1;63906:17;;;:21;63946:38;63964:10;63976:7;63946:17;:38::i;:::-;63764:304;;;64025:17;;;:27;;;63764:304;63724:697;;;64125:12;64100:22;;;:37;64172:1;64152:17;;;:21;;;64218:12;;64206:34;;64236:3;;64206:25;;:7;;64218:12;;;;;64206:11;:25::i;:34::-;64188:52;-1:-1:-1;64255:18:0;64276:20;:7;64188:52;64276:11;:20::i;:::-;64255:41;;64311;64329:10;64341;64311:17;:41::i;:::-;64385:14;;64367:42;;-1:-1:-1;;;;;64385:14:0;64401:7;64367:17;:42::i;:::-;63724:697;;;64431:18;64460:21;64511:19;;64496:12;:34;64492:182;;;64579:10;;64560:39;;64595:3;;64560:30;;:14;;64579:10;;64560:18;:30::i;:39::-;64640:9;;64614:12;;64547:52;;-1:-1:-1;64614:48:0;;-1:-1:-1;;;;;64614:12:0;;;;64640:9;64547:52;64614:25;:48::i;:::-;64700:30;:14;64719:10;64700:18;:30::i;:::-;64741:12;;64684:46;;-1:-1:-1;64741:61:0;;-1:-1:-1;;;;;64741:12:0;64775:10;64684:46;64741:25;:61::i;:::-;64846:1;64813:11;;;;:51;;-1:-1:-1;;;;;64813:11:0;;;;64850:13;64813:24;:51::i;:::-;64880:41;;;;;;;;64901:4;;64889:10;;64880:41;;;;;;;;;63030:1899;;;;;;;;:::o;50795:53::-;;;;:::o;51690:25::-;;;;:::o;68777:314::-;68907:5;;-1:-1:-1;;;;;68907:5:0;68893:10;:19;68885:64;;;;;-1:-1:-1;;;68885:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68964:11;68960:61;;;68992:17;:15;:17::i;:::-;-1:-1:-1;69031:24:0;:52;68777:314::o;59171:1301::-;59223:21;59247:8;59256:4;59247:14;;;;;;;;;;;;;;;;;;59223:38;;59292:4;:20;;;59276:12;:36;59272:75;;59329:7;;;59272:75;59381:12;;:37;;;-1:-1:-1;;;59381:37:0;;59412:4;59381:37;;;;;;59357:21;;-1:-1:-1;;;;;59381:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59381:37:0;59452:11;;;;:36;;;-1:-1:-1;;;59452:36:0;;59482:4;59452:36;;;;;;59381:37;;-1:-1:-1;59429:20:0;;-1:-1:-1;;;;;59452:11:0;;;;:21;;:36;;;;;59381:37;;59452:36;;;;;;;;:11;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59452:36:0;;-1:-1:-1;59503:18:0;59499:107;;-1:-1:-1;;59561:12:0;59538:20;;;;:35;59588:7;;59499:107;59617:15;59634;59653:49;59667:4;:20;;;59689:12;59653:13;:49::i;:::-;59616:86;;;;59717:7;59728:1;59717:12;:28;;;;-1:-1:-1;59733:12:0;;59717:28;59713:117;;;59785:12;59762:4;:20;;:35;;;;59812:7;;;;;;;59713:117;59840:19;59862:79;59925:15;;59862:58;59904:4;:15;;;59862:37;59874:24;;59862:7;:11;;:37;;;;:::i;:::-;:41;;:58::i;:79::-;59840:101;;59952:19;59974:78;60036:15;;59974:57;60015:4;:15;;;59974:36;59986:23;;59974:7;:11;;:36;;;;:::i;:78::-;59952:100;-1:-1:-1;60063:18:0;60084:28;:11;59952:100;60084:15;:28::i;:::-;60063:49;;60123:19;60145:67;60163:48;60207:3;60163:39;60180:4;:21;;;60163:12;:16;;:39;;;;:::i;:48::-;60145:13;;:17;:67::i;:::-;60123:89;;60251:4;-1:-1:-1;;;;;60227:29:0;:4;;;;;;;;;-1:-1:-1;;;;;60227:4:0;-1:-1:-1;;;;;60227:10:0;;:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60227:12:0;-1:-1:-1;;;;;60227:29:0;;60223:99;;;60273:4;;:37;;;-1:-1:-1;;;60273:37:0;;60291:4;60273:37;;;;;;;;;;;;-1:-1:-1;;;;;60273:4:0;;;;:9;;:37;;;;;:4;;:37;;;;;;;;:4;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60223:99;60355:63;60380:37;60405:11;60380:20;:10;60395:4;60380:14;:20::i;:37::-;60355:20;;;;;:24;:63::i;:::-;60332:20;;;:86;-1:-1:-1;;60452:12:0;60429:20;;;;:35;;;;-1:-1:-1;;;;;;59171:1301:0;;:::o;65000:981::-;65059:21;65083:8;65092:4;65083:14;;;;;;;;;;;;;;;;65132;;;:8;:14;;;;;;65147:10;65132:26;;;;;;;65177:18;;;;65083:14;;;;;;;;-1:-1:-1;65169:65:0;;;;;-1:-1:-1;;;65169:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;65270:18;;;;;65323:17;;;;;65245:22;65351:15;;;65377:22;;;;65410:21;;;;65442:15;;;:19;;;65554;;65270:18;;65323:17;;65245:22;;65539:12;:34;65535:182;;;65622:10;;65603:39;;65638:3;;65603:30;;:14;;65622:10;;65603:18;:30::i;:39::-;65683:9;;65657:12;;65590:52;;-1:-1:-1;65657:48:0;;-1:-1:-1;;;;;65657:12:0;;;;65683:9;65590:52;65657:25;:48::i;:::-;65743:30;:14;65762:10;65743:18;:30::i;:::-;65784:12;;65727:46;;-1:-1:-1;65784:61:0;;-1:-1:-1;;;;;65784:12:0;65818:10;65727:46;65784:25;:61::i;:::-;65889:1;65856:11;;;;:51;;-1:-1:-1;;;;;65856:11:0;;;;65893:13;65856:24;:51::i;:::-;65923:50;;;;;;;;65953:4;;65941:10;;65923:50;;;;;;;;;65000:981;;;;;;;:::o;67210:258::-;67308:5;;-1:-1:-1;;;;;67308:5:0;67294:10;:19;67286:63;;;;;-1:-1:-1;;;67286:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67380:10;;67368:9;:22;67360:51;;;;;-1:-1:-1;;;67360:51:0;;;;;;;;;;;;-1:-1:-1;;;67360:51:0;;;;;;;;;;;;;;;67422:26;:38;67210:258::o;58915:180::-;58977:8;:15;58960:14;59003:85;59031:6;59025:3;:12;59003:85;;;59061:15;59072:3;59061:10;:15::i;:::-;59039:5;;59003:85;;;;58915:180;:::o;54458:401::-;54598:5;;-1:-1:-1;;;;;54598:5:0;54584:10;:19;54576:62;;;;;-1:-1:-1;;;54576:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54653:11;54649:61;;;54681:17;:15;:17::i;:::-;54738:63;54789:11;54738:46;54758:8;54767:4;54758:14;;;;;;;;;;;;;;;;;;:25;;;54738:15;;:19;;:46;;;;:::i;:63::-;54720:15;:81;;;;54840:11;54812:8;54821:4;54812:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;54458:401;;;:::o;50280:24::-;;;-1:-1:-1;;;;;50280:24:0;;:::o;66421:155::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;66495:24:0;::::1;66487:52;;;::::0;;-1:-1:-1;;;66487:52:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;66487:52:0;;;;;;;;;;;;;::::1;;66550:5;:18:::0;;-1:-1:-1;;;;;;66550:18:0::1;-1:-1:-1::0;;;;;66550:18:0;;;::::1;::::0;;;::::1;::::0;;66421:155::o;28986:148::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;29093:1:::1;29077:6:::0;;29056:40:::1;::::0;-1:-1:-1;;;;;29077:6:0;;::::1;::::0;29056:40:::1;::::0;29093:1;;29056:40:::1;29124:1;29107:19:::0;;-1:-1:-1;;;;;;29107:19:0::1;::::0;;28986:148::o;50601:37::-;;;;:::o;67823:242::-;67914:5;;-1:-1:-1;;;;;67914:5:0;67900:10;:19;67892:61;;;;;-1:-1:-1;;;67892:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67984:10;;67972:9;:22;67964:51;;;;;-1:-1:-1;;;67964:51:0;;;;;;;;;;;;-1:-1:-1;;;67964:51:0;;;;;;;;;;;;;;;68026:19;:31;67823:242::o;51361:44::-;51404:1;51361:44;:::o;28344:79::-;28382:7;28409:6;-1:-1:-1;;;;;28409:6:0;28344:79;:::o;55691:1130::-;55763:15;55780;55808:17;55834:22;;55828:3;:28;:59;;55884:3;55828:59;;;55859:22;;55828:59;55808:79;;55898:17;55924:19;;55918:3;:25;:53;;55968:3;55918:53;;;55946:19;;55918:53;55898:73;;56041:22;;56032:5;:31;56028:138;;56090:1;56080:11;;56028:138;;;56134:20;:9;56148:5;56134:13;:20::i;:::-;56124:30;;56028:138;56225:19;;56216:5;:28;56212:602;;56271:1;56261:11;;56212:602;;;56322:26;;56309:9;:39;56305:498;;56379:42;51404:1;56379:20;:9;56393:5;56379:13;:20::i;:42::-;56369:52;;56305:498;;;56474:26;;56466:5;:34;56462:326;;;56535:154;56625:41;56639:26;;56625:9;:13;;:41;;;;:::i;:::-;56535:59;51404:1;56535:37;56566:5;56535:26;;:30;;:37;;;;:::i;56462:326::-;56748:20;:9;56762:5;56748:13;:20::i;:::-;56738:30;;56462:326;55691:1130;;;;;;;:::o;52048:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57479:115::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;57554:4:::1;::::0;:32:::1;::::0;;-1:-1:-1;;;57554:32:0;;-1:-1:-1;;;;;57554:32:0;;::::1;;::::0;::::1;::::0;;;:4;;;::::1;::::0;:22:::1;::::0;:32;;;;;:4:::1;::::0;:32;;;;;;;:4;;:32;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57479:115:::0;:::o;50225:21::-;;;-1:-1:-1;;;;;50225:21:0;;:::o;50916:50::-;;;;:::o;50394:29::-;;;-1:-1:-1;;;;;50394:29:0;;:::o;66901:250::-;66993:5;;-1:-1:-1;;;;;66993:5:0;66979:10;:19;66971:61;;;;;-1:-1:-1;;;66971:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;67051:29:0;;67043:57;;;;;-1:-1:-1;;;67043:57:0;;;;;;;;;;;;-1:-1:-1;;;67043:57:0;;;;;;;;;;;;;;;67111:14;:32;;-1:-1:-1;;;;;;67111:32:0;-1:-1:-1;;;;;67111:32:0;;;;;;;;;;66901:250::o;68313:227::-;68392:5;;-1:-1:-1;;;;;68392:5:0;68378:10;:19;68370:61;;;;;-1:-1:-1;;;68370:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;68479:3;68467:8;:15;;;;68442:58;;;;;-1:-1:-1;;;68442:58:0;;;;;;;;;;;;-1:-1:-1;;;68442:58:0;;;;;;;;;;;;;;;68511:10;:21;;-1:-1:-1;;68511:21:0;;;;;;;;;;;;68313:227::o;50697:34::-;;;;:::o;50491:41::-;;;;:::o;57658:1174::-;57731:7;57751:21;57775:8;57784:4;57775:14;;;;;;;;;;;;;;;;57824;;;:8;:14;;;;;;-1:-1:-1;;;;;57824:21:0;;;;;;;;;;;57775:14;;;;;;;;57882:20;;;;;57937:12;;:37;;-1:-1:-1;;;57937:37:0;;57968:4;57937:37;;;;;;;;;57775:14;;-1:-1:-1;57824:21:0;;57775:14;57937:12;;;;;:22;;:37;;;;;57775:14;;57937:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57937:37:0;58008:11;;;;:36;;;-1:-1:-1;;;58008:36:0;;58038:4;58008:36;;;;;;57937:37;;-1:-1:-1;57985:20:0;;-1:-1:-1;;;;;58008:11:0;;;;:21;;:36;;;;;57937:37;;58008:36;;;;;;;;:11;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58008:36:0;58074:20;;;;58008:36;;-1:-1:-1;58059:12:0;:35;:57;;;;-1:-1:-1;58098:18:0;;;58059:57;58055:666;;;58133:19;58155:67;58173:48;58217:3;58173:39;58190:4;:21;;;58173:12;:16;;:39;;;;:::i;:48::-;58155:13;;:17;:67::i;:::-;58133:89;;58238:15;58255;58274:49;58288:4;:20;;;58310:12;58274:13;:49::i;:::-;58237:86;;;;58338:19;58360:79;58423:15;;58360:58;58402:4;:15;;;58360:37;58372:24;;58360:7;:11;;:37;;;;:::i;:79::-;58338:101;;58454:19;58476:78;58538:15;;58476:57;58517:4;:15;;;58476:36;58488:23;;58476:7;:11;;:36;;;;:::i;:78::-;58454:100;-1:-1:-1;58569:18:0;58590:28;:11;58454:100;58590:15;:28::i;:::-;58569:49;-1:-1:-1;58651:58:0;58671:37;58696:11;58671:20;58569:49;58686:4;58671:14;:20::i;:37::-;58651:15;;:19;:58::i;:::-;58633:76;;58055:666;;;;;;;58738:86;58808:4;:15;;;58738:65;58785:4;:17;;;58738:42;58775:4;58738:32;58754:15;58738:4;:11;;;:15;;:32;;;;:::i;:86::-;58731:93;;;;;;;57658:1174;;;;;:::o;53476:886::-;53680:5;;-1:-1:-1;;;;;53680:5:0;53666:10;:19;53658:62;;;;;-1:-1:-1;;;53658:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53735:11;53731:61;;;53763:17;:15;:17::i;:::-;53802:33;53817:8;53827:7;53802:14;:33::i;:::-;53846:23;53887:10;;53872:12;:25;:53;;53915:10;;53872:53;;;53900:12;53872:53;53954:15;;53846:79;;-1:-1:-1;53954:32:0;;53974:11;53954:19;:32::i;:::-;53936:15;:50;54025:318;;;;;;;;-1:-1:-1;;;;;54025:318:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54025:318:0;;;;;;;;;;;;54323:4;54025:318;;;;;;53997:8;:357;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;53997:357:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53997:357:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53997:357:0;;;;;;;;;53476:886::o;29289:244::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;29378:22:0;::::1;29370:73;;;;-1:-1:-1::0;;;29370:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29480:6;::::0;;29459:38:::1;::::0;-1:-1:-1;;;;;29459:38:0;;::::1;::::0;29480:6;::::1;::::0;29459:38:::1;::::0;::::1;29508:6;:17:::0;;-1:-1:-1;;;;;;29508:17:0::1;-1:-1:-1::0;;;;;29508:17:0;;;::::1;::::0;;;::::1;::::0;;29289:244::o;51774:27::-;;;;;;:::o;67523:248::-;67617:5;;-1:-1:-1;;;;;67617:5:0;67603:10;:19;67595:61;;;;;-1:-1:-1;;;67595:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67687:10;;67675:9;:22;67667:51;;;;;-1:-1:-1;;;67667:51:0;;;;;;;;;;;;-1:-1:-1;;;67667:51:0;;;;;;;;;;;;;;;67729:22;:34;67523:248::o;50334:20::-;;;-1:-1:-1;;;;;50334:20:0;;:::o;66627:225::-;66709:5;;-1:-1:-1;;;;;66709:5:0;66695:10;:19;66687:61;;;;;-1:-1:-1;;;66687:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;66767:24:0;;66759:52;;;;;-1:-1:-1;;;66759:52:0;;;;;;;;;;;;-1:-1:-1;;;66759:52:0;;;;;;;;;;;;;;;66822:9;:22;;-1:-1:-1;;;;;;66822:22:0;-1:-1:-1;;;;;66822:22:0;;;;;;;;;;66627:225::o;69137:310::-;69265:5;;-1:-1:-1;;;;;69265:5:0;69251:10;:19;69243:64;;;;;-1:-1:-1;;;69243:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69322:11;69318:61;;;69350:17;:15;:17::i;:::-;-1:-1:-1;69389:23:0;:50;69137:310::o;51025:47::-;;;;:::o;3768:181::-;3826:7;3858:5;;;3882:6;;;;3874:46;;;;;-1:-1:-1;;;3874:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;3940:1;3768:181;-1:-1:-1;;;3768:181:0:o;5122:471::-;5180:7;5425:6;5421:47;;-1:-1:-1;5455:1:0;5448:8;;5421:47;5492:5;;;5496:1;5492;:5;:1;5516:5;;;;;:10;5508:56;;;;-1:-1:-1;;;5508:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6069:132;6127:7;6154:39;6158:1;6161;6154:39;;;;;;;;;;;;;;;;;:3;:39::i;4232:136::-;4290:7;4317:43;4321:1;4324;4317:43;;;;;;;;;;;;;;;;;:3;:43::i;15135:177::-;15245:58;;;-1:-1:-1;;;;;15245:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15245:58:0;-1:-1:-1;;;15245:58:0;;;15218:86;;15238:5;;15218:19;:86::i;:::-;15135:177;;;:::o;66095:279::-;66190:4;;:29;;;-1:-1:-1;;;66190:29:0;;66213:4;66190:29;;;;;;66172:15;;-1:-1:-1;;;;;66190:4:0;;:14;;:29;;;;;;;;;;;;;;:4;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66190:29:0;;-1:-1:-1;66234:17:0;;;66230:137;;;66268:4;;:27;;;-1:-1:-1;;;66268:27:0;;-1:-1:-1;;;;;66268:27:0;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66230:137:0;;-1:-1:-1;66230:137:0;;66328:4;;:27;;;-1:-1:-1;;;66328:27:0;;-1:-1:-1;;;;;66328:27:0;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15320:205;15448:68;;;-1:-1:-1;;;;;15448:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15448:68:0;-1:-1:-1;;;15448:68:0;;;15421:96;;15441:5;;15421:19;:96::i;:::-;15320:205;;;;:::o;26900:106::-;26988:10;26900:106;:::o;53152:249::-;53239:9;53234:160;53258:8;:15;53254:19;;53234:160;;;53326:8;-1:-1:-1;;;;;53303:31:0;:8;53312:1;53303:11;;;;;;;;;;;;;;;;;;;;;:19;-1:-1:-1;;;;;53303:19:0;:31;;;;:64;;;53360:7;-1:-1:-1;;;;;53338:29:0;:8;53347:1;53338:11;;;;;;;;;;;;;;;;:18;:11;;;;;:18;;-1:-1:-1;;;;;53338:18:0;:29;;53303:64;53295:87;;;;;-1:-1:-1;;;53295:87:0;;;;;;;;;;;;-1:-1:-1;;;53295:87:0;;;;;;;;;;;;;;;53275:3;;53234:160;;6697:278;6783:7;6818:12;6811:5;6803:28;;;;-1:-1:-1;;;6803:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6842:9;6858:1;6854;:5;;;;;;;6697:278;-1:-1:-1;;;;;6697:278:0:o;4671:192::-;4757:7;4793:12;4785:6;;;;4777:29;;;;-1:-1:-1;;;4777:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4829:5:0;;;4671:192::o;17440:761::-;17864:23;17890:69;17918:4;17890:69;;;;;;;;;;;;;;;;;17898:5;-1:-1:-1;;;;;17890:27:0;;;:69;;;;;:::i;:::-;17974:17;;17864:95;;-1:-1:-1;17974:21:0;17970:224;;18116:10;18105:30;;;;;;;;;;;;;;;-1:-1:-1;18105:30:0;18097:85;;;;-1:-1:-1;;;18097:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12118:196;12221:12;12253:53;12276:6;12284:4;12290:1;12293:12;12253:22;:53::i;:::-;12246:60;12118:196;-1:-1:-1;;;;12118:196:0:o;13495:979::-;13625:12;13658:18;13669:6;13658:10;:18::i;:::-;13650:60;;;;;-1:-1:-1;;;13650:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;13784:12;13798:23;13825:6;-1:-1:-1;;;;;13825:11:0;13845:8;13856:4;13825:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;13825:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13783:78;;;;13876:7;13872:595;;;13907:10;-1:-1:-1;13900:17:0;;-1:-1:-1;13900:17:0;13872:595;14021:17;;:21;14017:439;;14284:10;14278:17;14345:15;14332:10;14328:2;14324:19;14317:44;14232:148;14420:20;;-1:-1:-1;;;14420:20:0;;;;;;;;;;;;;;;;;14427:12;;14420:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9003:619;9063:4;9531:20;;9374:66;9571:23;;;;;;:42;;-1:-1:-1;;9598:15:0;;;9563:51;-1:-1:-1;;9003:619:0:o

ipfs://b28a0bac053452a98dff26e9bb408ed9b483e85c36f40b78aef58885dc4c31fb