Contract 0xd07b60ab845b720f2b792ed70367329ae87d02e8

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.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;
    }
}

pragma solidity >=0.6.2 <0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

pragma solidity >=0.6.0 <0.8.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.3.0, sets of type `bytes32` (`Bytes32Set`), `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];
    }

    // Bytes32Set

    struct Bytes32Set {
        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(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, 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(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

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

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set 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(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, 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(uint160(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(uint160(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(uint160(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(uint160(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));
    }
}

pragma solidity 0.6.12;

interface ISUGAR {
  // SUGAR specific functions
  function lock(address _account, uint256 _amount) external;

  function lockOf(address _account) external view returns (uint256);

  function unlock() external;

  function mint(address _to, uint256 _amount) external;

  // Generic BEP20 functions
  function totalSupply() external view returns (uint256);

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

  function transfer(address recipient, uint256 amount) external returns (bool);

  function allowance(address owner, address spender) external view returns (uint256);

  function approve(address spender, uint256 amount) external returns (bool);

  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) external returns (bool);

  // Getter functions
  function startReleaseBlock() external view returns (uint256);

  function endReleaseBlock() external view returns (uint256);

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

pragma solidity 0.6.12;

interface ERC20Interface {
  function balanceOf(address user) external view returns (uint256);
}

library SafeToken {
  function myBalance(address token) internal view returns (uint256) {
    return ERC20Interface(token).balanceOf(address(this));
  }

  function balanceOf(address token, address user) internal view returns (uint256) {
    return ERC20Interface(token).balanceOf(user);
  }

  function safeApprove(
    address token,
    address to,
    uint256 value
  ) internal {
    // bytes4(keccak256(bytes('approve(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeApprove");
  }

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

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

  function safeTransferETH(address to, uint256 value) internal {
    // solhint-disable-next-line no-call-value
    (bool success, ) = to.call{ value: value }(new bytes(0));
    require(success, "!safeTransferETH");
  }
}

pragma solidity >=0.5.0;

interface IWETH {
  function deposit() external payable;

  function transfer(address to, uint256 value) external returns (bool);

  function withdraw(uint256) external;
}

pragma solidity 0.6.12;

interface IWNativeRelayer {
  function withdraw(uint256 _amount) external;
}

pragma solidity 0.6.12;

pragma experimental ABIEncoderV2;

interface ISugarBoosterConfig {
  // getter

  function energyInfo(address nftAddress, uint256 nftTokenId)
    external
    view
    returns (
      uint256 maxEnergy,
      uint256 currentEnergy,
      uint256 boostBps
    );

  function sugarboosterNftAllowance(
    address stakingToken,
    address nftAddress,
    uint256 nftTokenId
  ) external view returns (bool);

  function stakeTokenAllowance(address stakingToken) external view returns (bool);

  function callerAllowance(address caller) external view returns (bool);

  // external

  function consumeEnergy(
    address nftAddress,
    uint256 nftTokenId,
    uint256 energyToBeConsumed
  ) external;
}

pragma solidity 0.6.12;

interface IMasterChefCallback {
  function masterChefCall(
    address stakeToken,
    address userAddr,
    uint256 unboostedReward
  ) external;
}

pragma solidity 0.6.12;

interface IMasterChef {
  /// @dev functions return information. no states changed.
  function poolLength() external view returns (uint256);

  function pendingSugar(address _stakeToken, address _user) external view returns (uint256);

  function userInfo(address _stakeToken, address _user)
    external
    view
    returns (
      uint256,
      uint256,
      address
    );

  function poolInfo(address _stakeToken)
    external
    view
    returns (
      uint256,
      uint256,
      uint256,
      uint256
    );

  function devAddr() external view returns (address);

  function refAddr() external view returns (address);

  function bonusMultiplier() external view returns (uint256);

  function totalAllocPoint() external view returns (uint256);

  function sugarPerBlock() external view returns (uint256);

  /// @dev configuration functions
  function addPool(
    address _stakeToken,
    uint256 _allocPoint,
    uint256 _depositFee
  ) external;

  function setPool(
    address _stakeToken,
    uint256 _allocPoint,
    uint256 _depositFee
  ) external;

  function updatePool(address _stakeToken) external;

  function removePool(address _stakeToken) external;

  /// @dev user interaction functions
  function deposit(
    address _for,
    address _stakeToken,
    uint256 _amount
  ) external;

  function withdraw(
    address _for,
    address _stakeToken,
    uint256 _amount
  ) external;

  function depositSugar(address _for, uint256 _amount) external;

  function withdrawSugar(address _for, uint256 _amount) external;

  function harvest(address _for, address _stakeToken) external;

  function harvest(address _for, address[] calldata _stakeToken) external;

  function emergencyWithdraw(address _for, address _stakeToken) external;

  function mintExtraReward(
    address _stakeToken,
    address _to,
    uint256 _amount
  ) external;

  function sugar() external returns (ISUGAR);
}

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            revert("ECDSA: invalid signature length");
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        return recover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
        require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * replicates the behavior of the
     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
     * JSON-RPC method.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

pragma solidity >=0.6.2 <0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
        return _roles[role].members.at(index);
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (_roles[role].members.add(account)) {
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (_roles[role].members.remove(account)) {
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

pragma solidity >=0.6.0 <0.8.0;

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

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

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

pragma solidity >=0.6.0 <0.8.0;

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

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

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

pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.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);
}

pragma solidity >=0.6.0 <0.8.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");
        }
    }
}

pragma solidity >=0.6.0 <0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor () internal {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

pragma solidity >=0.6.0 <0.8.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.
 */
abstract contract Ownable is Context {
    address private _owner;

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

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

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

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

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

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

pragma solidity 0.6.12;

contract SugarBooster is Ownable, Pausable, ReentrancyGuard, AccessControl, IMasterChefCallback, IERC721Receiver {
  using SafeERC20 for IERC20;
  using SafeMath for uint256;

  uint256 private constant _NOT_ENTERED = 1;
  uint256 private constant _ENTERED = 2;

  bytes32 public constant GOVERNANCE_ROLE = keccak256("GOVERNANCE_ROLE");
  // keccak256(abi.encodePacked("I am an EOA"))
  bytes32 public constant SIGNATURE_HASH = 0x08367bb0e0d2abf304a79452b2b95f4dc75fda0fc6df55dca6e5ad183de10cf0;

  IMasterChef public masterChef;
  ISugarBoosterConfig public sugarboosterConfig;
  IERC20 public sugar;
  IWNativeRelayer public wNativeRelayer;
  address public wNative;

  struct UserInfo {
    uint256 accumBoostedReward;
    uint256 lastUserActionTime;
  }

  struct NFTStakingInfo {
    address nftAddress;
    uint256 nftTokenId;
  }

  mapping(address => mapping(address => UserInfo)) public userInfo;

  mapping(address => uint256) public totalAccumBoostedReward;
  mapping(address => mapping(address => NFTStakingInfo)) public userStakingNFT;

  uint256 public _IN_EXEC_LOCK;

  event StakeNFT(address indexed staker, address indexed stakeToken, address nftAddress, uint256 nftTokenId);
  event UnstakeNFT(address indexed staker, address indexed stakeToken, address nftAddress, uint256 nftTokenId);
  event Stake(address indexed staker, IERC20 indexed stakeToken, uint256 amount);
  event Unstake(address indexed unstaker, IERC20 indexed stakeToken, uint256 amount);
  event Harvest(address indexed harvester, IERC20 indexed stakeToken, uint256 amount);
  event EmergencyWithdraw(address indexed caller, IERC20 indexed stakeToken, uint256 amount);
  event MasterChefCall(
    address indexed user,
    uint256 extraReward,
    address stakeToken,
    uint256 prevEnergy,
    uint256 currentEnergy
  );
  event Pause();
  event Unpause();

  constructor(
    IERC20 _sugar,
    IMasterChef _masterChef,
    ISugarBoosterConfig _sugarboosterConfig,
    IWNativeRelayer _wNativeRelayer,
    address _wNative
  ) public {
    require(_wNative != address(0), "SugarBooster::constructor:: _wNative cannot be address(0)");
    require(address(_sugar) != address(0), "SugarNFTOffering::constructor:: _sugar cannot be address(0)");
    require(address(_masterChef) != address(0), "SugarNFTOffering::constructor:: _masterChef cannot be address(0)");
    require(
      address(_sugarboosterConfig) != address(0),
      "SugarNFTOffering::constructor:: _sugarboosterConfig cannot be address(0)"
    );
    require(
      address(_wNativeRelayer) != address(0),
      "SugarNFTOffering::constructor:: _wNativeRelayer cannot be address(0)"
    );

    _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
    _setupRole(GOVERNANCE_ROLE, _msgSender());

    masterChef = _masterChef;
    sugarboosterConfig = _sugarboosterConfig;
    sugar = _sugar;
    wNativeRelayer = _wNativeRelayer;
    wNative = _wNative;

    _IN_EXEC_LOCK = _NOT_ENTERED;
  }

  /// @dev Ensure that the function is called with the execution scope
  modifier inExec() {
    require(_IN_EXEC_LOCK == _NOT_ENTERED, "SugarBooster::inExec:: in exec lock");
    require(address(masterChef) == _msgSender(), "SugarBooster::inExec:: not from the master chef");
    _IN_EXEC_LOCK = _ENTERED;
    _;
    _IN_EXEC_LOCK = _NOT_ENTERED;
  }

  /// @dev validate whether a specified stake token is allowed
  modifier isStakeTokenOK(address _stakeToken) {
    require(sugarboosterConfig.stakeTokenAllowance(_stakeToken), "SugarBooster::isStakeTokenOK::bad stake token");
    _;
  }

  /// @dev validate whether a specified nft can be staked into a particular staoke token
  modifier isSugarBoosterNftOK(
    address _stakeToken,
    address _nftAddress,
    uint256 _nftTokenId
  ) {
    require(
      sugarboosterConfig.sugarboosterNftAllowance(_stakeToken, _nftAddress, _nftTokenId),
      "SugarBooster::isSugarBoosterNftOK::bad nft"
    );
    _;
  }

  modifier permit(bytes calldata _sig) {
    address recoveredAddress = ECDSA.recover(ECDSA.toEthSignedMessageHash(SIGNATURE_HASH), _sig);
    require(recoveredAddress == _msgSender(), "SugarBooster::permit::INVALID_SIGNATURE");
    _;
  }

  modifier onlyGovernance() {
    require(hasRole(GOVERNANCE_ROLE, _msgSender()), "SugarBooster::onlyGovernance::only GOVERNANCE role");
    _;
  }

  /// @dev Require that the caller must be an EOA account to avoid flash loans.
  modifier onlyEOA() {
    require(msg.sender == tx.origin, "SugarBooster::onlyEOA:: not eoa");
    _;
  }

  /**
   * @notice Triggers stopped state
   * @dev Only possible when contract not paused.
   */
  function pause() external onlyGovernance whenNotPaused {
    _pause();
    emit Pause();
  }

  /**
   * @notice Returns to normal state
   * @dev Only possible when contract is paused.
   */
  function unpause() external onlyGovernance whenPaused {
    _unpause();
    emit Unpause();
  }

  /// @dev View function to see pending booster SUGARs on frontend.
  function pendingBoosterSugar(address _stakeToken, address _user) external view returns (uint256) {
    uint256 pendingSugar = masterChef.pendingSugar(_stakeToken, _user);
    NFTStakingInfo memory stakingNFT = userStakingNFT[_stakeToken][_user];
    if (stakingNFT.nftAddress == address(0)) {
      return 0;
    }
    (, , uint256 boostBps) = sugarboosterConfig.energyInfo(stakingNFT.nftAddress, stakingNFT.nftTokenId);
    // if (currentEnergy == 0) {
    //   return 0;
    // }
    return pendingSugar.mul(boostBps).div(1e4);
    // return Math.min(currentEnergy, pendingSugar.mul(boostBps).div(1e4));
  }

  /// @dev Internal function for withdrasugar a boosted stake token and receive a reward from a master chef
  /// @param _stakeToken specified stake token
  /// @param _shares user's shares to be withdrawn
  function _withdrawFromMasterChef(IERC20 _stakeToken, uint256 _shares) internal {
    if (_shares == 0) return;
    if (address(_stakeToken) == address(sugar)) {
      masterChef.withdrawSugar(_msgSender(), _shares);
    } else {
      masterChef.withdraw(_msgSender(), address(_stakeToken), _shares);
    }
  }

  /// @dev Internal function for harvest a reward from a master chef
  /// @param _stakeToken specified stake token
  function _harvestFromMasterChef(address user, IERC20 _stakeToken) internal {
    (uint256 userStakeAmount, , ) = masterChef.userInfo(address(_stakeToken), user);
    if (userStakeAmount == 0) {
      emit Harvest(user, _stakeToken, 0);
      return;
    }
    uint256 beforeReward = sugar.balanceOf(user);
    masterChef.harvest(user, address(_stakeToken));

    emit Harvest(user, _stakeToken, sugar.balanceOf(user).sub(beforeReward));
  }

  /// @notice function for staking a new nft
  /// @dev This one is a preparation for nft staking info, if nft address and nft token id are the same with existing record, it will be reverted
  /// @param _stakeToken a specified stake token address
  /// @param _nftAddress composite key for nft
  /// @param _nftTokenId composite key for nft
  function stakeNFT(
    address _stakeToken,
    address _nftAddress,
    uint256 _nftTokenId
  )
    external
    whenNotPaused
    isStakeTokenOK(_stakeToken)
    isSugarBoosterNftOK(_stakeToken, _nftAddress, _nftTokenId)
    nonReentrant
    onlyEOA
  {
    _stakeNFT(_stakeToken, _nftAddress, _nftTokenId);
  }

  /// @dev avoid stack-too-deep by branching the function
  function _stakeNFT(
    address _stakeToken,
    address _nftAddress,
    uint256 _nftTokenId
  ) internal {
    NFTStakingInfo memory toBeSentBackNft = userStakingNFT[_stakeToken][_msgSender()];
    require(
      toBeSentBackNft.nftAddress != _nftAddress || toBeSentBackNft.nftTokenId != _nftTokenId,
      "SugarBooster::stakeNFT:: nft already staked"
    );
    _harvestFromMasterChef(_msgSender(), IERC20(_stakeToken));

    userStakingNFT[_stakeToken][_msgSender()] = NFTStakingInfo({ nftAddress: _nftAddress, nftTokenId: _nftTokenId });

    IERC721(_nftAddress).safeTransferFrom(_msgSender(), address(this), _nftTokenId);

    if (toBeSentBackNft.nftAddress != address(0)) {
      IERC721(toBeSentBackNft.nftAddress).safeTransferFrom(address(this), _msgSender(), toBeSentBackNft.nftTokenId);
    }
    emit StakeNFT(_msgSender(), _stakeToken, _nftAddress, _nftTokenId);
  }

  /// @notice function for unstaking a current nft
  /// @dev This one is a preparation for nft staking info, if nft address and nft token id are the same with existing record, it will be reverted
  /// @param _stakeToken a specified stake token address
  function unstakeNFT(address _stakeToken) external isStakeTokenOK(_stakeToken) nonReentrant onlyEOA {
    _unstakeNFT(_stakeToken);
  }

  /// @dev avoid stack-too-deep by branching the function
  function _unstakeNFT(address _stakeToken) internal {
    NFTStakingInfo memory toBeSentBackNft = userStakingNFT[_stakeToken][_msgSender()];
    require(toBeSentBackNft.nftAddress != address(0), "SugarBooster::stakeNFT:: no nft staked");

    _harvestFromMasterChef(_msgSender(), IERC20(_stakeToken));

    userStakingNFT[_stakeToken][_msgSender()] = NFTStakingInfo({ nftAddress: address(0), nftTokenId: 0 });

    IERC721(toBeSentBackNft.nftAddress).safeTransferFrom(address(this), _msgSender(), toBeSentBackNft.nftTokenId);

    emit UnstakeNFT(_msgSender(), _stakeToken, toBeSentBackNft.nftAddress, toBeSentBackNft.nftTokenId);
  }

  /// @notice for staking a stakeToken and receive some rewards
  /// @param _stakeToken a specified stake token to be staked
  /// @param _amount amount to stake
  function stake(IERC20 _stakeToken, uint256 _amount)
    external
    payable
    whenNotPaused
    isStakeTokenOK(address(_stakeToken))
    nonReentrant
  {
    require(_amount > 0, "SugarBooster::stake::nothing to stake");

    UserInfo storage user = userInfo[address(_stakeToken)][_msgSender()];

    _harvestFromMasterChef(_msgSender(), _stakeToken);
    user.lastUserActionTime = block.timestamp;
    _stakeToken.safeApprove(address(masterChef), _amount);
    _safeWrap(_stakeToken, _amount);

    if (address(_stakeToken) == address(sugar)) {
      masterChef.depositSugar(_msgSender(), _amount);
    } else {
      masterChef.deposit(_msgSender(), address(_stakeToken), _amount);
    }

    _stakeToken.safeApprove(address(masterChef), 0);

    emit Stake(_msgSender(), _stakeToken, _amount);
  }

  /// @dev internal function for unstaking a stakeToken and receive some rewards
  /// @param _stakeToken a specified stake token to be unstaked
  /// @param _amount amount to stake
  function _unstake(IERC20 _stakeToken, uint256 _amount) internal {
    require(_amount > 0, "SugarBooster::_unstake::use harvest instead");

    UserInfo storage user = userInfo[address(_stakeToken)][_msgSender()];

    _withdrawFromMasterChef(_stakeToken, _amount);

    user.lastUserActionTime = block.timestamp;
    _safeUnwrap(_stakeToken, _msgSender(), _amount);

    emit Unstake(_msgSender(), _stakeToken, _amount);
  }

  /// @dev function for unstaking a stakeToken and receive some rewards
  /// @param _stakeToken a specified stake token to be unstaked
  /// @param _amount amount to stake
  function unstake(address _stakeToken, uint256 _amount) external isStakeTokenOK(_stakeToken) nonReentrant {
    _unstake(IERC20(_stakeToken), _amount);
  }

  /// @notice function for unstaking all portion of stakeToken and receive some rewards
  /// @dev similar to unstake with user's shares
  /// @param _stakeToken a specified stake token to be unstaked
  function unstakeAll(address _stakeToken) external isStakeTokenOK(_stakeToken) nonReentrant {
    (uint256 userStakeAmount, , ) = masterChef.userInfo(address(_stakeToken), _msgSender());
    _unstake(IERC20(_stakeToken), userStakeAmount);
  }

  /// @notice function for harvesting the reward
  /// @param _stakeToken a specified stake token to be harvested
  function harvest(address _stakeToken) external whenNotPaused isStakeTokenOK(_stakeToken) nonReentrant {
    _harvestFromMasterChef(_msgSender(), IERC20(_stakeToken));
  }

  /// @notice function for harvesting rewards in specified staking tokens
  /// @param _stakeTokens specified stake tokens to be harvested
  function harvest(address[] calldata _stakeTokens) external whenNotPaused nonReentrant {
    for (uint256 i = 0; i < _stakeTokens.length; i++) {
      require(sugarboosterConfig.stakeTokenAllowance(_stakeTokens[i]), "SugarBooster::harvest::bad stake token");
      _harvestFromMasterChef(_msgSender(), IERC20(_stakeTokens[i]));
    }
  }

  /// @dev a notifier function for letting some observer call when some conditions met
  /// @dev currently, the caller will be a master chef calling before a sugar lock
  function masterChefCall(
    address stakeToken,
    address userAddr,
    uint256 unboostedReward
  ) external override inExec {
    NFTStakingInfo memory stakingNFT = userStakingNFT[stakeToken][userAddr];
    UserInfo storage user = userInfo[stakeToken][userAddr];
    if (stakingNFT.nftAddress == address(0)) {
      return;
    }
    (, uint256 currentEnergy, uint256 boostBps) = sugarboosterConfig.energyInfo(
      stakingNFT.nftAddress,
      stakingNFT.nftTokenId
    );
    // if (currentEnergy == 0) {
    //   return;
    // }
    uint256 extraReward = unboostedReward.mul(boostBps).div(1e4);
    totalAccumBoostedReward[stakeToken] = totalAccumBoostedReward[stakeToken].add(extraReward);
    user.accumBoostedReward = user.accumBoostedReward.add(extraReward);
    uint256 newEnergy = 0;
    masterChef.mintExtraReward(stakeToken, userAddr, extraReward);
    // sugarboosterConfig.consumeEnergy(stakingNFT.nftAddress, stakingNFT.nftTokenId, extraReward);

    emit MasterChefCall(userAddr, extraReward, stakeToken, currentEnergy, newEnergy);
  }

  function _safeWrap(IERC20 _quoteBep20, uint256 _amount) internal {
    if (msg.value != 0) {
      require(address(_quoteBep20) == wNative, "SugarBooster::_safeWrap:: baseToken is not wNative");
      require(_amount == msg.value, "SugarBooster::_safeWrap:: value != msg.value");
      IWETH(wNative).deposit{ value: msg.value }();
      return;
    }
    _quoteBep20.safeTransferFrom(_msgSender(), address(this), _amount);
  }

  function _safeUnwrap(
    IERC20 _quoteBep20,
    address _to,
    uint256 _amount
  ) internal {
    if (address(_quoteBep20) == wNative) {
      _quoteBep20.safeTransfer(address(wNativeRelayer), _amount);
      wNativeRelayer.withdraw(_amount);
      SafeToken.safeTransferETH(_to, _amount);
      return;
    }
    _quoteBep20.safeTransfer(_to, _amount);
  }

  /**
   * @notice Withdraws a stake token from MasterChef back to the user considerless the rewards.
   * @dev EMERGENCY ONLY
   */
  function emergencyWithdraw(IERC20 _stakeToken) external isStakeTokenOK(address(_stakeToken)) {
    UserInfo storage user = userInfo[address(_stakeToken)][_msgSender()];
    (uint256 userStakeAmount, , ) = masterChef.userInfo(address(_stakeToken), _msgSender());

    user.lastUserActionTime = block.timestamp;
    masterChef.emergencyWithdraw(_msgSender(), address(_stakeToken));

    emit EmergencyWithdraw(_msgSender(), _stakeToken, userStakeAmount);
  }

  /// @dev when doing a safeTransferFrom, the caller needs to implement this, for safety reason
  function onERC721Received(
    address, /*operator*/
    address, /*from*/
    uint256, /*tokenId*/
    bytes calldata /*data*/
  ) external override returns (bytes4) {
    return IERC721Receiver.onERC721Received.selector;
  }

  /// @dev Fallback function to accept ETH. Workers will send ETH back the pool.
  receive() external payable {}
}

[{"inputs":[{"internalType":"contract IERC20","name":"_sugar","type":"address"},{"internalType":"contract IMasterChef","name":"_masterChef","type":"address"},{"internalType":"contract ISugarBoosterConfig","name":"_sugarboosterConfig","type":"address"},{"internalType":"contract IWNativeRelayer","name":"_wNativeRelayer","type":"address"},{"internalType":"address","name":"_wNative","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"harvester","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"extraReward","type":"uint256"},{"indexed":false,"internalType":"address","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"prevEnergy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"currentEnergy","type":"uint256"}],"name":"MasterChefCall","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":[],"name":"Pause","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":true,"internalType":"address","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"nftTokenId","type":"uint256"}],"name":"StakeNFT","type":"event"},{"anonymous":false,"inputs":[],"name":"Unpause","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"unstaker","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstake","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"staker","type":"address"},{"indexed":true,"internalType":"address","name":"stakeToken","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"nftTokenId","type":"uint256"}],"name":"UnstakeNFT","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GOVERNANCE_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SIGNATURE_HASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_IN_EXEC_LOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_stakeToken","type":"address"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakeToken","type":"address"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_stakeTokens","type":"address[]"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"masterChef","outputs":[{"internalType":"contract IMasterChef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"stakeToken","type":"address"},{"internalType":"address","name":"userAddr","type":"address"},{"internalType":"uint256","name":"unboostedReward","type":"uint256"}],"name":"masterChefCall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_stakeToken","type":"address"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingBoosterSugar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_stakeToken","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakeToken","type":"address"},{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_nftTokenId","type":"uint256"}],"name":"stakeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sugar","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sugarboosterConfig","outputs":[{"internalType":"contract ISugarBoosterConfig","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalAccumBoostedReward","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":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakeToken","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakeToken","type":"address"}],"name":"unstakeAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_stakeToken","type":"address"}],"name":"unstakeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"accumBoostedReward","type":"uint256"},{"internalType":"uint256","name":"lastUserActionTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userStakingNFT","outputs":[{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"nftTokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wNative","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wNativeRelayer","outputs":[{"internalType":"contract IWNativeRelayer","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

64334:15910:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69421:621;;;;;;;;;;-1:-1:-1;69421:621:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64878:45;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;76442:172::-;;;;;;;;;;-1:-1:-1;76442:172:0;;;;;:::i;:::-;;:::i;:::-;;65201:64;;;;;;;;;;-1:-1:-1;65201:64:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;65335:76::-;;;;;;;;;;-1:-1:-1;65335:76:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;79891:233::-;;;;;;;;;;-1:-1:-1;79891:233:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39340:114::-;;;;;;;;;;-1:-1:-1;39340:114:0;;;;;:::i;:::-;;:::i;64994:22::-;;;;;;;;;;;;;:::i;39716:227::-;;;;;;;;;;-1:-1:-1;39716:227:0;;;;;:::i;:::-;;:::i;40925:209::-;;;;;;;;;;-1:-1:-1;40925:209:0;;;;;:::i;:::-;;:::i;69248:98::-;;;;;;;;;;;;;:::i;77280:1081::-;;;;;;;;;;-1:-1:-1;77280:1081:0;;;;;:::i;:::-;;:::i;64844:29::-;;;;;;;;;;;;;:::i;60864:86::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;73056:136::-;;;;;;;;;;-1:-1:-1;73056:136:0;;;;;:::i;:::-;;:::i;79324:464::-;;;;;;;;;;-1:-1:-1;79324:464:0;;;;;:::i;:::-;;:::i;63753:148::-;;;;;;;;;;;;;:::i;69045:95::-;;;;;;;;;;;;;:::i;64730:107::-;;;;;;;;;;;;;:::i;63102:87::-;;;;;;;;;;;;;:::i;39013:138::-;;;;;;;;;;-1:-1:-1;39013:138:0;;;;;:::i;:::-;;:::i;37974:139::-;;;;;;;;;;-1:-1:-1;37974:139:0;;;;;:::i;:::-;;:::i;76076:244::-;;;;;;;;;;-1:-1:-1;76076:244:0;;;;;:::i;:::-;;:::i;64928:19::-;;;;;;;;;;;;;:::i;36719:49::-;;;;;;;;;;;;;:::i;65272:58::-;;;;;;;;;;-1:-1:-1;65272:58:0;;;;;:::i;:::-;;:::i;74073:828::-;;;;;;:::i;:::-;;:::i;71501:326::-;;;;;;;;;;-1:-1:-1;71501:326:0;;;;;:::i;:::-;;:::i;75710:156::-;;;;;;;;;;-1:-1:-1;75710:156:0;;;;;:::i;:::-;;:::i;76761:341::-;;;;;;;;;;-1:-1:-1;76761:341:0;;;;;:::i;:::-;;:::i;65418:28::-;;;;;;;;;;;;;:::i;38287:127::-;;;;;;;;;;-1:-1:-1;38287:127:0;;;;;:::i;:::-;;:::i;64952:37::-;;;;;;;;;;;;;:::i;40188:230::-;;;;;;;;;;-1:-1:-1;40188:230:0;;;;;:::i;:::-;;:::i;64056:244::-;;;;;;;;;;-1:-1:-1;64056:244:0;;;;;:::i;:::-;;:::i;64606:70::-;;;;;;;;;;;;;:::i;69421:621::-;69548:10;;:43;;-1:-1:-1;;;69548:43:0;;69509:7;;;;-1:-1:-1;;;;;69548:10:0;;;;:23;;:43;;69572:11;;69585:5;;69548:43;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69525:66;;69598:32;;:::i;:::-;-1:-1:-1;;;;;;69633:27:0;;;;;;;:14;:27;;;;;;;;:34;;;;;;;;;;;69598:69;;;;;;;;;;;;;;;;;;;;;;;;;;69674:66;;69731:1;69724:8;;;;;;69674:66;69771:18;;;69801:21;;69824;;;;69771:75;;-1:-1:-1;;;69771:75:0;;69751:16;;-1:-1:-1;;;;;69771:18:0;;;;:29;;:75;;69801:21;;69824;;69771:75;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;69746:100;-1:-1:-1;69924:35:0;;-1:-1:-1;69955:3:0;;-1:-1:-1;69924:26:0;:12;69746:100;69924:16;:26::i;:::-;:30;;:35::i;:::-;69917:42;;;;;69421:621;;;;;:::o;64878:45::-;;;-1:-1:-1;;;;;64878:45:0;;:::o;76442:172::-;61190:8;:6;:8::i;:::-;61189:9;61181:38;;;;-1:-1:-1;;;61181:38:0;;;;;;;:::i;:::-;;;;;;;;;67840:18:::1;::::0;;:51:::1;::::0;-1:-1:-1;;;67840:51:0;;76518:11;;-1:-1:-1;;;;;67840:18:0;;::::1;::::0;:38:::1;::::0;:51:::1;::::0;76518:11;;67840:51:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1::0;;;67832:109:0::1;;;;;;;:::i;:::-;44249:1:::2;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::2;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;76551:57:::3;76574:12;:10;:12::i;:::-;76595:11;76551:22;:57::i;:::-;-1:-1:-1::0;;44205:1:0::2;45167:22:::0;;76442:172::o;65201:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;65335:76::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65335:76:0;;;;;:::o;79891:233::-;-1:-1:-1;;;79891:233:0;;;;;;;:::o;39340:114::-;39397:7;39424:12;;;:6;:12;;;;;;;;:22;;;39340:114::o;64994:22::-;;;-1:-1:-1;;;;;64994:22:0;;:::o;39716:227::-;39808:12;;;;:6;:12;;;;;;;;:22;;39800:45;;39832:12;:10;:12::i;39800:45::-;39792:105;;;;-1:-1:-1;;;39792:105:0;;;;;;;:::i;:::-;39910:25;39921:4;39927:7;39910:10;:25::i;:::-;39716:227;;:::o;40925:209::-;41023:12;:10;:12::i;:::-;-1:-1:-1;;;;;41012:23:0;:7;-1:-1:-1;;;;;41012:23:0;;41004:83;;;;-1:-1:-1;;;41004:83:0;;;;;;;:::i;:::-;41100:26;41112:4;41118:7;41100:11;:26::i;69248:98::-;68636:38;64648:28;68661:12;:10;:12::i;68636:38::-;68628:101;;;;-1:-1:-1;;;68628:101:0;;;;;;;:::i;:::-;61467:8:::1;:6;:8::i;:::-;61459:41;;;;-1:-1:-1::0;;;61459:41:0::1;;;;;;;:::i;:::-;69309:10:::2;:8;:10::i;:::-;69331:9;::::0;::::2;::::0;;;::::2;69248:98::o:0;77280:1081::-;64556:1;67459:13;;:29;67451:77;;;;-1:-1:-1;;;67451:77:0;;;;;;;:::i;:::-;67566:12;:10;:12::i;:::-;67551:10;;-1:-1:-1;;;;;67551:10:0;;;67543:35;;;67535:95;;;;-1:-1:-1;;;67535:95:0;;;;;;;:::i;:::-;64598:1;67637:13;:24;77419:32:::1;;:::i;:::-;-1:-1:-1::0;;;;;;77454:26:0;;::::1;;::::0;;;:14:::1;:26;::::0;;;;;;;:36;;::::1;::::0;;;;;;;;;77419:71;;;;::::1;::::0;;;;;::::1;::::0;;;;;::::1;::::0;;;::::1;::::0;77521:20;;;:8:::1;:20:::0;;;;;:30;;;;;;;;77562:21;;77419:71;;77521:30;;77562:35:::1;77558:64;;77608:7;;;;77558:64;77674:18;::::0;;77712:21;;77742::::1;::::0;::::1;::::0;77674:96:::1;::::0;-1:-1:-1;;;77674:96:0;;77631:21:::1;::::0;;;-1:-1:-1;;;;;77674:18:0::1;::::0;:29:::1;::::0;:96:::1;::::0;77712:21;;77742;;77674:96:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77628:142:::0;;-1:-1:-1;77628:142:0;-1:-1:-1;77839:19:0::1;::::0;-1:-1:-1;77861:38:0::1;77895:3;77861:29;:15:::0;77628:142;77861:19:::1;:29::i;:38::-;-1:-1:-1::0;;;;;77944:35:0;::::1;;::::0;;;:23:::1;:35;::::0;;;;;77839:60;;-1:-1:-1;77944:52:0::1;::::0;77839:60;77944:39:::1;:52::i;:::-;-1:-1:-1::0;;;;;77906:35:0;::::1;;::::0;;;:23:::1;:35;::::0;;;;:90;78029:23;;:40:::1;::::0;78057:11;78029:27:::1;:40::i;:::-;78003:66:::0;;78104:10:::1;::::0;:61:::1;::::0;-1:-1:-1;;;78104:61:0;;78003:23:::1;::::0;-1:-1:-1;;;;;78104:10:0::1;::::0;:26:::1;::::0;:61:::1;::::0;78131:10;;78143:8;;78153:11;;78104:61:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;78295:8;-1:-1:-1::0;;;;;78280:75:0::1;;78305:11;78318:10;78330:13;78345:9;78280:75;;;;;;;;;:::i;:::-;;;;;;;;67668:1;;;;;;;-1:-1:-1::0;;64556:1:0;67676:13;:28;-1:-1:-1;77280:1081:0:o;64844:29::-;;;-1:-1:-1;;;;;64844:29:0;;:::o;60864:86::-;60911:4;60935:7;-1:-1:-1;;;60935:7:0;;;;;60864:86::o;73056:136::-;67840:18;;;:51;;-1:-1:-1;;;67840:51:0;;73121:11;;-1:-1:-1;;;;;67840:18:0;;;;:38;;:51;;73121:11;;67840:51;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1;;;67832:109:0;;;;;;;:::i;:::-;44249:1:::1;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::1;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;68864:10:::2;68878:9;68864:23;68856:67;;;;-1:-1:-1::0;;;68856:67:0::2;;;;;;;:::i;:::-;73162:24:::3;73174:11;73162;:24::i;79324:464::-:0;67840:18;;;:51;;-1:-1:-1;;;67840:51:0;;79403:11;;-1:-1:-1;;;;;67840:18:0;;;;:38;;:51;;79403:11;;67840:51;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1;;;67832:109:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;79448:30:0;::::1;79424:21;79448:30:::0;;;:8:::1;:30;::::0;;;;79424:21;79479:12:::1;:10;:12::i;:::-;-1:-1:-1::0;;;;;79448:44:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;79448:44:0;;;79531:10:::1;::::0;79448:44;;-1:-1:-1;;;79531:10:0::1;:19;79559:11:::0;79573:12:::1;:10;:12::i;:::-;79531:55;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;79621:15:0::1;79595:23;::::0;::::1;:41:::0;79643:10:::1;::::0;79499:87;;-1:-1:-1;;;;;;79643:10:0::1;:28;79672:12;:10;:12::i;:::-;79694:11;79643:64;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;79753:11;-1:-1:-1::0;;;;;79721:61:0::1;79739:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;79721:61:0::1;;79766:15;79721:61;;;;;;:::i;:::-;;;;;;;;67948:1;;79324:464:::0;;:::o;63753:148::-;63333:12;:10;:12::i;:::-;-1:-1:-1;;;;;63322:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;63322:23:0;;63314:68;;;;-1:-1:-1;;;63314:68:0;;;;;;;:::i;:::-;63860:1:::1;63844:6:::0;;63823:40:::1;::::0;-1:-1:-1;;;;;63844:6:0;;::::1;::::0;63823:40:::1;::::0;63860:1;;63823:40:::1;63891:1;63874:19:::0;;-1:-1:-1;;;;;;63874:19:0::1;::::0;;63753:148::o;69045:95::-;68636:38;64648:28;68661:12;:10;:12::i;68636:38::-;68628:101;;;;-1:-1:-1;;;68628:101:0;;;;;;;:::i;:::-;61190:8:::1;:6;:8::i;:::-;61189:9;61181:38;;;;-1:-1:-1::0;;;61181:38:0::1;;;;;;;:::i;:::-;69107:8:::2;:6;:8::i;:::-;69127:7;::::0;::::2;::::0;;;::::2;69045:95::o:0;64730:107::-;64771:66;64730:107;:::o;63102:87::-;63148:7;63175:6;-1:-1:-1;;;;;63175:6:0;63102:87;:::o;39013:138::-;39086:7;39113:12;;;:6;:12;;;;;:30;;39137:5;39113:23;:30::i;:::-;39106:37;39013:138;-1:-1:-1;;;39013:138:0:o;37974:139::-;38043:4;38067:12;;;:6;:12;;;;;:38;;38097:7;38067:29;:38::i;76076:244::-;67840:18;;;:51;;-1:-1:-1;;;67840:51:0;;76141:11;;-1:-1:-1;;;;;67840:18:0;;;;:38;;:51;;76141:11;;67840:51;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1;;;67832:109:0;;;;;;;:::i;:::-;44249:1:::1;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::1;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;76206:10:::2;::::0;76175:23:::2;::::0;-1:-1:-1;;;;;76206:10:0::2;:19;76234:11:::0;76248:12:::2;:10;:12::i;:::-;76206:55;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76174:87;;;;76268:46;76284:11;76298:15;76268:8;:46::i;:::-;-1:-1:-1::0;;44205:1:0::1;45167:22:::0;;-1:-1:-1;76076:244:0:o;64928:19::-;;;-1:-1:-1;;;;;64928:19:0;;:::o;36719:49::-;36764:4;36719:49;:::o;65272:58::-;;;;;;;;;;;;;:::o;74073:828::-;61190:8;:6;:8::i;:::-;61189:9;61181:38;;;;-1:-1:-1;;;61181:38:0;;;;;;;:::i;:::-;67840:18:::1;::::0;;:51:::1;::::0;-1:-1:-1;;;67840:51:0;;74199:11;;-1:-1:-1;;;;;67840:18:0;;::::1;::::0;:38:::1;::::0;:51:::1;::::0;74199:11;;67840:51:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1::0;;;67832:109:0::1;;;;;;;:::i;:::-;44249:1:::2;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::2;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;74249:11;74241:61:::3;;;;-1:-1:-1::0;;;74241:61:0::3;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;74335:30:0;::::3;74311:21;74335:30:::0;;;:8:::3;:30;::::0;;;;74311:21;74366:12:::3;:10;:12::i;:::-;-1:-1:-1::0;;;;;74335:44:0::3;-1:-1:-1::0;;;;;74335:44:0::3;;;;;;;;;;;;74311:68;;74388:49;74411:12;:10;:12::i;:::-;74425:11;74388:22;:49::i;:::-;74470:15;74444:23;::::0;::::3;:41:::0;74524:10:::3;::::0;74492:53:::3;::::0;-1:-1:-1;;;;;74492:23:0;;::::3;::::0;74524:10:::3;74537:7:::0;74492:23:::3;:53::i;:::-;74552:31;74562:11;74575:7;74552:9;:31::i;:::-;74628:5;::::0;-1:-1:-1;;;;;74596:38:0;;::::3;74628:5:::0;::::3;74596:38;74592:193;;;74645:10;::::0;-1:-1:-1;;;;;74645:10:0::3;:23;74669:12;:10;:12::i;:::-;74683:7;74645:46;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;74592:193;;;74714:10;::::0;-1:-1:-1;;;;;74714:10:0::3;:18;74733:12;:10;:12::i;:::-;74755:11;74769:7;74714:63;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;74592:193;74825:10;::::0;74793:47:::3;::::0;-1:-1:-1;;;;;74793:23:0;;::::3;::::0;74825:10:::3;;74793:23;:47::i;:::-;74874:11;-1:-1:-1::0;;;;;74854:41:0::3;74860:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;74854:41:0::3;;74887:7;74854:41;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;44205:1:0::2;45167:22:::0;;-1:-1:-1;;74073:828:0:o;71501:326::-;61190:8;:6;:8::i;:::-;61189:9;61181:38;;;;-1:-1:-1;;;61181:38:0;;;;;;;:::i;:::-;67840:18:::1;::::0;;:51:::1;::::0;-1:-1:-1;;;67840:51:0;;71655:11;;-1:-1:-1;;;;;67840:18:0;;::::1;::::0;:38:::1;::::0;:51:::1;::::0;71655:11;;67840:51:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1::0;;;67832:109:0::1;;;;;;;:::i;:::-;68186:18:::2;::::0;;:82:::2;::::0;-1:-1:-1;;;68186:82:0;;71693:11;;71706;;71719;;-1:-1:-1;;;;;68186:18:0;;::::2;::::0;:43:::2;::::0;:82:::2;::::0;71693:11;;71706;;71719;;68186:82:::2;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68170:158;;;;-1:-1:-1::0;;;68170:158:0::2;;;;;;;:::i;:::-;44249:1:::3;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::3;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;68864:10:::4;68878:9;68864:23;68856:67;;;;-1:-1:-1::0;;;68856:67:0::4;;;;;;;:::i;:::-;71773:48:::5;71783:11;71796;71809;71773:9;:48::i;:::-;-1:-1:-1::0;;44205:1:0::3;45167:22:::0;;-1:-1:-1;;;;;71501:326:0:o;75710:156::-;67840:18;;;:51;;-1:-1:-1;;;67840:51:0;;75789:11;;-1:-1:-1;;;;;67840:18:0;;;;:38;;:51;;75789:11;;67840:51;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67832:109;;;;-1:-1:-1;;;67832:109:0;;;;;;;:::i;:::-;44249:1:::1;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::1;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;75822:38:::2;75838:11:::0;75852:7;75822:8:::2;:38::i;76761:341::-:0;61190:8;:6;:8::i;:::-;61189:9;61181:38;;;;-1:-1:-1;;;61181:38:0;;;;;;;:::i;:::-;44249:1:::1;44855:7;;:19;;44847:63;;;;-1:-1:-1::0;;;44847:63:0::1;;;;;;;:::i;:::-;44249:1;44988:7;:18:::0;76859:9:::2;76854:243;76874:23:::0;;::::2;76854:243;;;76921:18;::::0;-1:-1:-1;;;;;76921:18:0::2;:38;76960:12:::0;;76973:1;76960:15;;::::2;;;;;;;;;;;;;;;;;;:::i;:::-;76921:55;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;76913:106;;;;-1:-1:-1::0;;;76913:106:0::2;;;;;;;:::i;:::-;77028:61;77051:12;:10;:12::i;:::-;77072;;77085:1;77072:15;;;;;;;;;;;;;;;;;;;;:::i;:::-;77028:22;:61::i;:::-;76899:3;;76854:243;;65418:28:::0;;;;:::o;38287:127::-;38350:7;38377:12;;;:6;:12;;;;;:29;;:27;:29::i;64952:37::-;;;-1:-1:-1;;;;;64952:37:0;;:::o;40188:230::-;40281:12;;;;:6;:12;;;;;;;;:22;;40273:45;;40305:12;:10;:12::i;40273:45::-;40265:106;;;;-1:-1:-1;;;40265:106:0;;;;;;;:::i;64056:244::-;63333:12;:10;:12::i;:::-;-1:-1:-1;;;;;63322:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;63322:23:0;;63314:68;;;;-1:-1:-1;;;63314:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;64145:22:0;::::1;64137:73;;;;-1:-1:-1::0;;;64137:73:0::1;;;;;;;:::i;:::-;64247:6;::::0;;64226:38:::1;::::0;-1:-1:-1;;;;;64226:38:0;;::::1;::::0;64247:6;::::1;::::0;64226:38:::1;::::0;::::1;64275:6;:17:::0;;-1:-1:-1;;;;;;64275:17:0::1;-1:-1:-1::0;;;;;64275:17:0;;;::::1;::::0;;;::::1;::::0;;64056:244::o;64606:70::-;64648:28;64606:70;:::o;16321:152::-;16391:4;16415:50;16420:3;-1:-1:-1;;;;;16440:23:0;;16415:4;:50::i;49629:220::-;49687:7;49711:6;49707:20;;-1:-1:-1;49726:1:0;49719:8;;49707:20;49750:5;;;49754:1;49750;:5;:1;49774:5;;;;;:10;49766:56;;;;-1:-1:-1;;;49766:56:0;;;;;;;:::i;50327:153::-;50385:7;50417:1;50413;:5;50405:44;;;;-1:-1:-1;;;50405:44:0;;;;;;;:::i;:::-;50471:1;50467;:5;;;;;;;50327:153;-1:-1:-1;;;50327:153:0:o;613:106::-;701:10;613:106;:::o;70698:450::-;70812:10;;:47;;-1:-1:-1;;;70812:47:0;;70781:23;;-1:-1:-1;;;;;70812:10:0;;:19;;:47;;70840:11;;70854:4;;70812:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70780:79;;;;70870:15;70889:1;70870:20;70866:92;;;70920:11;-1:-1:-1;;;;;70906:29:0;70914:4;-1:-1:-1;;;;;70906:29:0;;70933:1;70906:29;;;;;;:::i;:::-;;;;;;;;70944:7;;;70866:92;70987:5;;:21;;-1:-1:-1;;;70987:21:0;;70964:20;;-1:-1:-1;;;;;70987:5:0;;:15;;:21;;71003:4;;70987:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71015:10;;:46;;-1:-1:-1;;;71015:46:0;;70964:44;;-1:-1:-1;;;;;;71015:10:0;;:18;;:46;;71034:4;;71048:11;;71015:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;71102:5:0;;:21;;-1:-1:-1;;;71102:21:0;;-1:-1:-1;;;;;71075:67:0;;;;-1:-1:-1;71075:67:0;;;;-1:-1:-1;71075:67:0;;71102:39;;71128:12;;71102:5;;;;:15;;:21;;71075:67;;71102:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:25;;:39::i;:::-;71075:67;;;;;;:::i;42168:188::-;42242:12;;;;:6;:12;;;;;:33;;42267:7;42242:24;:33::i;:::-;42238:111;;;42324:12;:10;:12::i;:::-;-1:-1:-1;;;;;42297:40:0;42315:7;-1:-1:-1;;;;;42297:40:0;42309:4;42297:40;;;;;;;;;;42168:188;;:::o;42364:192::-;42439:12;;;;:6;:12;;;;;:36;;42467:7;42439:27;:36::i;:::-;42435:114;;;42524:12;:10;:12::i;:::-;-1:-1:-1;;;;;42497:40:0;42515:7;-1:-1:-1;;;;;42497:40:0;42509:4;42497:40;;;;;;;;;;42364:192;;:::o;61923:120::-;61467:8;:6;:8::i;:::-;61459:41;;;;-1:-1:-1;;;61459:41:0;;;;;;;:::i;:::-;61992:5:::1;61982:15:::0;;-1:-1:-1;;;;61982:15:0::1;::::0;;62013:22:::1;62022:12;:10;:12::i;:::-;62013:22;;;;;;:::i;:::-;;;;;;;;61923:120::o:0;48750:179::-;48808:7;48840:5;;;48864:6;;;;48856:46;;;;-1:-1:-1;;;48856:46:0;;;;;;;:::i;73257:644::-;73315:37;;:::i;:::-;-1:-1:-1;;;;;73355:27:0;;;;;;:14;:27;;;;;;73383:12;:10;:12::i;:::-;-1:-1:-1;;;;;73355:41:0;;;;;;;;;;;;;;;;;-1:-1:-1;73355:41:0;73315:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73403:91:0;;;;-1:-1:-1;;;73403:91:0;;;;;;;:::i;:::-;73503:57;73526:12;:10;:12::i;73503:57::-;73613;;;;;;;;-1:-1:-1;73613:57:0;;;;;;;;;;-1:-1:-1;;;;;73569:27:0;;;;:14;:27;;;;;73613:57;;73597:12;:10;:12::i;:::-;-1:-1:-1;;;;;73569:41:0;;;;;;;;;;;;;;;;;-1:-1:-1;73569:41:0;:101;;;;-1:-1:-1;;;;;;73569:101:0;;;;;;;;;;;;-1:-1:-1;73569:101:0;;;;;;;73687:26;;73679:52;;73740:4;73747:12;:10;:12::i;:::-;73761:15;:26;;;73679:109;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73827:11;-1:-1:-1;;;;;73802:93:0;73813:12;:10;:12::i;:::-;-1:-1:-1;;;;;73802:93:0;;73840:15;:26;;;73868:15;:26;;;73802:93;;;;;;;:::i;:::-;;;;;;;;73257:644;;:::o;61664:118::-;61190:8;:6;:8::i;:::-;61189:9;61181:38;;;;-1:-1:-1;;;61181:38:0;;;;;;;:::i;:::-;61724:7:::1;:14:::0;;-1:-1:-1;;;;61724:14:0::1;-1:-1:-1::0;;;61724:14:0::1;::::0;;61754:20:::1;61761:12;:10;:12::i;17607:158::-:0;17681:7;17732:22;17736:3;17748:5;17732:3;:22::i;16893:167::-;16973:4;16997:55;17007:3;-1:-1:-1;;;;;17027:23:0;;16997:9;:55::i;75092:436::-;75181:1;75171:7;:11;75163:67;;;;-1:-1:-1;;;75163:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;75263:30:0;;75239:21;75263:30;;;:8;:30;;;;;75239:21;75294:12;:10;:12::i;:::-;-1:-1:-1;;;;;75263:44:0;-1:-1:-1;;;;;75263:44:0;;;;;;;;;;;;75239:68;;75316:45;75340:11;75353:7;75316:23;:45::i;:::-;75396:15;75370:23;;;:41;75418:47;75430:11;75443:12;:10;:12::i;:::-;75457:7;75418:11;:47::i;:::-;75501:11;-1:-1:-1;;;;;75479:43:0;75487:12;:10;:12::i;:::-;-1:-1:-1;;;;;75479:43:0;;75514:7;75479:43;;;;;;:::i;:::-;;;;;;;;75092:436;;;:::o;57420:622::-;57790:10;;;57789:62;;-1:-1:-1;57806:39:0;;-1:-1:-1;;;57806:39:0;;-1:-1:-1;;;;;57806:15:0;;;;;:39;;57830:4;;57837:7;;57806:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;57789:62;57781:152;;;;-1:-1:-1;;;57781:152:0;;;;;;;:::i;:::-;57944:90;57964:5;57994:22;;;58018:7;58027:5;57971:62;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;57971:62:0;;;;;;;;;;;;;;-1:-1:-1;;;;;57971:62:0;-1:-1:-1;;;;;;57971:62:0;;;;;;;;;;57944:19;:90::i;:::-;57420:622;;;:::o;78367:435::-;78443:9;:14;78439:285;;78500:7;;-1:-1:-1;;;;;78476:31:0;;;78500:7;;78476:31;78468:94;;;;-1:-1:-1;;;78468:94:0;;;;;;;:::i;:::-;78590:9;78579:7;:20;78571:77;;;;-1:-1:-1;;;78571:77:0;;;;;;;:::i;:::-;78663:7;;;;;;;;;-1:-1:-1;;;;;78663:7:0;-1:-1:-1;;;;;78657:22:0;;78688:9;78657:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78710:7;;78439:285;78730:66;78759:12;:10;:12::i;:::-;-1:-1:-1;;;;;78730:28:0;;;78781:4;78788:7;78730:28;:66::i;71892:901::-;72010:37;;:::i;:::-;-1:-1:-1;;;;;72050:27:0;;;;;;:14;:27;;;;;;72078:12;:10;:12::i;:::-;-1:-1:-1;;;;;72050:41:0;;;;;;;;;;;;;;;;;-1:-1:-1;72050:41:0;72010:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72114:41:0;;;;;:86;;;72189:11;72159:15;:26;;;:41;;72114:86;72098:163;;;;-1:-1:-1;;;72098:163:0;;;;;;;:::i;:::-;72268:57;72291:12;:10;:12::i;72268:57::-;72378:68;;;;;;;;-1:-1:-1;;;;;72378:68:0;;;;;;;;;;;;72334:27;;;-1:-1:-1;72334:27:0;;;:14;:27;;;;;;72378:68;;72362:12;:10;:12::i;:::-;-1:-1:-1;;;;;72334:41:0;;;;;;;;;;;;;;;;;-1:-1:-1;72334:41:0;:112;;;;-1:-1:-1;;;;;;72334:112:0;;;;;;;;;;;;-1:-1:-1;72334:112:0;;;;;;;72455:37;;;72493:12;:10;:12::i;:::-;72515:4;72522:11;72455:79;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;72547:26:0;;-1:-1:-1;;;;;72547:40:0;;;-1:-1:-1;72543:172:0;;-1:-1:-1;72543:172:0;72606:26;;-1:-1:-1;;;;;72598:52:0;;72659:4;72666:12;:10;:12::i;:::-;72680:15;:26;;;72598:109;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72543:172;72749:11;-1:-1:-1;;;;;72726:61:0;72735:12;:10;:12::i;:::-;-1:-1:-1;;;;;72726:61:0;;72762:11;72775;72726:61;;;;;;;:::i;17146:117::-;17209:7;17236:19;17244:3;17236:7;:19::i;11385:414::-;11448:4;11470:21;11480:3;11485:5;11470:9;:21::i;:::-;11465:327;;-1:-1:-1;11508:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;11691:18;;11669:19;;;:12;;;:19;;;;;;:40;;;;11724:11;;11465:327;-1:-1:-1;11775:5:0;11768:12;;49212:158;49270:7;49303:1;49298;:6;;49290:49;;;;-1:-1:-1;;;49290:49:0;;;;;;;:::i;:::-;-1:-1:-1;49357:5:0;;;49212:158::o;16649:::-;16722:4;16746:53;16754:3;-1:-1:-1;;;;;16774:23:0;;16746:7;:53::i;14273:204::-;14368:18;;14340:7;;14368:26;-1:-1:-1;14360:73:0;;;;-1:-1:-1;;;14360:73:0;;;;;;;:::i;:::-;14451:3;:11;;14463:5;14451:18;;;;;;;;;;;;;;;;14444:25;;14273:204;;;;:::o;13605:129::-;13678:4;13702:19;;;:12;;;;;:19;;;;;;:24;;;13605:129::o;70257:317::-;70347:12;70343:25;;70361:7;;70343:25;70410:5;;-1:-1:-1;;;;;70378:38:0;;;70410:5;;70378:38;70374:195;;;70427:10;;-1:-1:-1;;;;;70427:10:0;:24;70452:12;:10;:12::i;:::-;70466:7;70427:47;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70374:195;;;70497:10;;-1:-1:-1;;;;;70497:10:0;:19;70517:12;:10;:12::i;:::-;70539:11;70553:7;70497:64;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70257:317;;:::o;78808:373::-;78943:7;;-1:-1:-1;;;;;78919:31:0;;;78943:7;;78919:31;78915:216;;;78994:14;;78961:58;;-1:-1:-1;;;;;78961:24:0;;;;78994:14;79011:7;78961:24;:58::i;:::-;79028:14;;:32;;-1:-1:-1;;;79028:32:0;;-1:-1:-1;;;;;79028:14:0;;;;:23;;:32;;79052:7;;79028:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79069:39;79095:3;79100:7;79069:25;:39::i;:::-;79117:7;;78915:216;79137:38;-1:-1:-1;;;;;79137:24:0;;79162:3;79167:7;79137:24;:38::i;59066:761::-;59490:23;59516:69;59544:4;59516:69;;;;;;;;;;;;;;;;;59524:5;-1:-1:-1;;;;;59516:27:0;;;:69;;;;;:::i;:::-;59600:17;;59490:95;;-1:-1:-1;59600:21:0;59596:224;;59742:10;59731:30;;;;;;;;;;;;:::i;:::-;59723:85;;;;-1:-1:-1;;;59723:85:0;;;;;;;:::i;56946:205::-;57047:96;57067:5;57097:27;;;57126:4;57132:2;57136:5;57074:68;;;;;;;;;;:::i;57047:96::-;56946:205;;;;:::o;13820:109::-;13903:18;;13820:109::o;11975:1544::-;12041:4;12180:19;;;:12;;;:19;;;;;;12216:15;;12212:1300;;12651:18;;-1:-1:-1;;12602:14:0;;;;12651:22;;;;12578:21;;12651:3;;:22;;12938;;;;;;;;;;;;;;12918:42;;13084:9;13055:3;:11;;13067:13;13055:26;;;;;;;;;;;;;;;;;;;:38;;;;13161:23;;;13203:1;13161:12;;;:23;;;;;;13187:17;;;13161:43;;13313:17;;13161:3;;13313:17;;;;;;;;;;;;;;;;;;;;;;13408:3;:12;;:19;13421:5;13408:19;;;;;;;;;;;13401:26;;;13451:4;13444:11;;;;;;;;12212:1300;13495:5;13488:12;;;;;56761:177;56844:86;56864:5;56894:23;;;56919:2;56923:5;56871:58;;;;;;;;;:::i;22092:221::-;22251:12;;;22209;22251;;;;;;;;;-1:-1:-1;;;;;22227:7:0;;;22243:5;;22227:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22208:56;;;22279:7;22271:36;;;;-1:-1:-1;;;22271:36:0;;;;;;;:::i;4601:195::-;4704:12;4736:52;4758:6;4766:4;4772:1;4775:12;4736:21;:52::i;:::-;4729:59;4601:195;-1:-1:-1;;;;4601:195:0:o;5653:530::-;5780:12;5838:5;5813:21;:30;;5805:81;;;;-1:-1:-1;;;5805:81:0;;;;;;;:::i;:::-;5905:18;5916:6;5905:10;:18::i;:::-;5897:60;;;;-1:-1:-1;;;5897:60:0;;;;;;;:::i;:::-;6031:12;6045:23;6072:6;-1:-1:-1;;;;;6072:11:0;6092:5;6100:4;6072:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6030:75;;;;6123:52;6141:7;6150:10;6162:12;6123:17;:52::i;:::-;6116:59;5653:530;-1:-1:-1;;;;;;;5653:530:0:o;1683:422::-;2050:20;2089:8;;;1683:422::o;8193:742::-;8308:12;8337:7;8333:595;;;-1:-1:-1;8368:10:0;8361:17;;8333:595;8482:17;;:21;8478:439;;8745:10;8739:17;8806:15;8793:10;8789:2;8785:19;8778:44;8693:148;8888:12;8881:20;;-1:-1:-1;;;8881:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o;1736:241::-;;1840:2;1828:9;1819:7;1815:23;1811:32;1808:2;;;-1:-1;;1846:12;1808:2;85:6;72:20;97:33;124:5;97:33;:::i;1984:366::-;;;2105:2;2093:9;2084:7;2080:23;2076:32;2073:2;;;-1:-1;;2111:12;2073:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2163:63;-1:-1;2263:2;2302:22;;72:20;97:33;72:20;97:33;:::i;:::-;2271:63;;;;2067:283;;;;;:::o;2357:491::-;;;;2495:2;2483:9;2474:7;2470:23;2466:32;2463:2;;;-1:-1;;2501:12;2463:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2553:63;-1:-1;2653:2;2692:22;;72:20;97:33;72:20;97:33;:::i;:::-;2457:391;;2661:63;;-1:-1;;;2761:2;2800:22;;;;1525:20;;2457:391::o;2855:741::-;;;;;;3029:3;3017:9;3008:7;3004:23;3000:33;2997:2;;;-1:-1;;3036:12;2997:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3088:63;-1:-1;3188:2;3227:22;;72:20;97:33;72:20;97:33;:::i;:::-;3196:63;-1:-1;3296:2;3335:22;;1525:20;;-1:-1;3432:2;3417:18;;3404:32;3456:18;3445:30;;;3442:2;;;-1:-1;;3478:12;3442:2;3563:6;3552:9;3548:22;;;1061:3;1054:4;1046:6;1042:17;1038:27;1028:2;;-1:-1;;1069:12;1028:2;1112:6;1099:20;3456:18;1131:6;1128:30;1125:2;;;-1:-1;;1161:12;1125:2;1256:3;3188:2;1236:17;1197:6;1222:32;;1219:41;1216:2;;;-1:-1;;1263:12;1216:2;2991:605;;;;-1:-1;2991:605;;-1:-1;3188:2;1193:17;;3498:82;2991:605;-1:-1;;;2991:605::o;3603:366::-;;;3724:2;3712:9;3703:7;3699:23;3695:32;3692:2;;;-1:-1;;3730:12;3692:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3782:63;3882:2;3921:22;;;;1525:20;;-1:-1;;;3686:283::o;3976:397::-;;;4115:2;4103:9;4094:7;4090:23;4086:32;4083:2;;;-1:-1;;4121:12;4083:2;4179:17;4166:31;4217:18;;4209:6;4206:30;4203:2;;;-1:-1;;4239:12;4203:2;4340:6;4329:9;4325:22;;;431:3;424:4;416:6;412:17;408:27;398:2;;-1:-1;;439:12;398:2;482:6;469:20;4217:18;501:6;498:30;495:2;;;-1:-1;;531:12;495:2;626:3;4115:2;;610:6;606:17;567:6;592:32;;589:41;586:2;;;-1:-1;;633:12;586:2;4115;563:17;;;;;4259:98;;-1:-1;4077:296;;-1:-1;;;;4077:296::o;4380:257::-;;4492:2;4480:9;4471:7;4467:23;4463:32;4460:2;;;-1:-1;;4498:12;4460:2;742:6;736:13;45602:5;42704:13;42697:21;45580:5;45577:32;45567:2;;-1:-1;;45613:12;4644:241;;4748:2;4736:9;4727:7;4723:23;4719:32;4716:2;;;-1:-1;;4754:12;4716:2;-1:-1;863:20;;4710:175;-1:-1;4710:175::o;4892:366::-;;;5013:2;5001:9;4992:7;4988:23;4984:32;4981:2;;;-1:-1;;5019:12;4981:2;876:6;863:20;5071:63;;5171:2;5214:9;5210:22;72:20;97:33;124:5;97:33;:::i;5265:366::-;;;5386:2;5374:9;5365:7;5361:23;5357:32;5354:2;;;-1:-1;;5392:12;5354:2;-1:-1;;863:20;;;5544:2;5583:22;;;1525:20;;-1:-1;5348:283::o;6319:263::-;;6434:2;6422:9;6413:7;6409:23;6405:32;6402:2;;;-1:-1;;6440:12;6402:2;-1:-1;1673:13;;6396:186;-1:-1;6396:186::o;6589:535::-;;;;6738:2;6726:9;6717:7;6713:23;6709:32;6706:2;;;-1:-1;;6744:12;6706:2;1679:6;1673:13;6796:74;;6907:2;6961:9;6957:22;1673:13;6915:74;;7026:2;7080:9;7076:22;220:13;238:33;265:5;238:33;:::i;:::-;7034:74;;;;6700:424;;;;;:::o;7131:535::-;;;;7280:2;7268:9;7259:7;7255:23;7251:32;7248:2;;;-1:-1;;7286:12;7248:2;1679:6;1673:13;7338:74;;7449:2;7503:9;7499:22;1673:13;7457:74;;7568:2;7622:9;7618:22;1673:13;7576:74;;7242:424;;;;;:::o;21489:271::-;;8450:5;42045:12;8561:52;8606:6;8601:3;8594:4;8587:5;8583:16;8561:52;:::i;:::-;8625:16;;;;;21623:137;-1:-1;;21623:137::o;21767:222::-;-1:-1;;;;;43135:54;;;;7893:37;;21894:2;21879:18;;21865:124::o;22241:349::-;-1:-1;;;;;43135:54;;;7752:58;;43135:54;;22576:2;22561:18;;7893:37;22404:2;22389:18;;22375:215::o;22597:476::-;-1:-1;;;;;43135:54;;;7752:58;;43135:54;;;;22976:2;22961:18;;7752:58;23059:2;23044:18;;8124:37;;;;22796:2;22781:18;;22767:306::o;23547:349::-;-1:-1;;;;;43135:54;;;;7752:58;;23882:2;23867:18;;8124:37;23710:2;23695:18;;23681:215::o;25390:210::-;42704:13;;42697:21;8007:34;;25511:2;25496:18;;25482:118::o;25607:222::-;8124:37;;;25734:2;25719:18;;25705:124::o;25836:218::-;-1:-1;;;;;;42870:78;;;;8242:36;;25961:2;25946:18;;25932:122::o;27396:310::-;;27543:2;27564:17;27557:47;9653:5;42045:12;42484:6;27543:2;27532:9;27528:18;42472:19;9747:52;9792:6;42512:14;27532:9;42512:14;27543:2;9773:5;9769:16;9747:52;:::i;:::-;45376:7;45360:14;-1:-1;;45356:28;9811:39;;;;42512:14;9811:39;;27514:192;-1:-1;;27514:192::o;27713:416::-;27913:2;27927:47;;;10087:2;27898:18;;;42472:19;10123:34;42512:14;;;10103:55;-1:-1;;;10178:12;;;10171:29;10219:12;;;27884:245::o;28136:416::-;28336:2;28350:47;;;10470:2;28321:18;;;42472:19;10506:34;42512:14;;;10486:55;-1:-1;;;10561:12;;;10554:26;10599:12;;;28307:245::o;28559:416::-;28759:2;28773:47;;;10850:2;28744:18;;;42472:19;10886:34;42512:14;;;10866:55;-1:-1;;;10941:12;;;10934:39;10992:12;;;28730:245::o;28982:416::-;29182:2;29196:47;;;11243:2;29167:18;;;42472:19;11279:34;42512:14;;;11259:55;-1:-1;;;11334:12;;;11327:39;11385:12;;;29153:245::o;29405:416::-;29605:2;29619:47;;;11636:2;29590:18;;;42472:19;-1:-1;;;42512:14;;;11652:43;11714:12;;;29576:245::o;29828:416::-;30028:2;30042:47;;;11965:2;30013:18;;;42472:19;12001:34;42512:14;;;11981:55;-1:-1;;;12056:12;;;12049:30;12098:12;;;29999:245::o;30251:416::-;30451:2;30465:47;;;12349:2;30436:18;;;42472:19;12385:34;42512:14;;;12365:55;-1:-1;;;12440:12;;;12433:42;12494:12;;;30422:245::o;30674:416::-;30874:2;30888:47;;;12745:2;30859:18;;;42472:19;12781:34;42512:14;;;12761:55;-1:-1;;;12836:12;;;12829:35;12883:12;;;30845:245::o;31097:416::-;31297:2;31311:47;;;13134:2;31282:18;;;42472:19;13170:34;42512:14;;;13150:55;-1:-1;;;13225:12;;;13218:30;13267:12;;;31268:245::o;31520:416::-;31720:2;31734:47;;;13518:2;31705:18;;;42472:19;13554:34;42512:14;;;13534:55;-1:-1;;;13609:12;;;13602:30;13651:12;;;31691:245::o;31943:416::-;32143:2;32157:47;;;13902:2;32128:18;;;42472:19;13938:29;42512:14;;;13918:50;13987:12;;;32114:245::o;32366:416::-;32566:2;32580:47;;;14238:2;32551:18;;;42472:19;14274:34;42512:14;;;14254:55;-1:-1;;;14329:12;;;14322:36;14377:12;;;32537:245::o;32789:416::-;32989:2;33003:47;;;14628:2;32974:18;;;42472:19;14664:34;42512:14;;;14644:55;-1:-1;;;14719:12;;;14712:35;14766:12;;;32960:245::o;33212:416::-;33412:2;33426:47;;;15017:2;33397:18;;;42472:19;15053:34;42512:14;;;15033:55;-1:-1;;;15108:12;;;15101:34;15154:12;;;33383:245::o;33635:416::-;33835:2;33849:47;;;15405:2;33820:18;;;42472:19;15441:32;42512:14;;;15421:53;15493:12;;;33806:245::o;34058:416::-;34258:2;34272:47;;;15744:2;34243:18;;;42472:19;15780:34;42512:14;;;15760:55;-1:-1;;;15835:12;;;15828:30;15877:12;;;34229:245::o;34481:416::-;34681:2;34695:47;;;16128:2;34666:18;;;42472:19;16164:28;42512:14;;;16144:49;16212:12;;;34652:245::o;34904:416::-;35104:2;35118:47;;;16463:2;35089:18;;;42472:19;16499:34;42512:14;;;16479:55;-1:-1;;;16554:12;;;16547:40;16606:12;;;35075:245::o;35327:416::-;35527:2;35541:47;;;16857:2;35512:18;;;42472:19;-1:-1;;;42512:14;;;16873:39;16931:12;;;35498:245::o;35750:416::-;35950:2;35964:47;;;17182:2;35935:18;;;42472:19;17218:34;42512:14;;;17198:55;-1:-1;;;17273:12;;;17266:25;17310:12;;;35921:245::o;36173:416::-;36373:2;36387:47;;;17561:2;36358:18;;;42472:19;17597:34;42512:14;;;17577:55;-1:-1;;;17652:12;;;17645:42;17706:12;;;36344:245::o;36596:416::-;36796:2;36810:47;;;36781:18;;;42472:19;17993:34;42512:14;;;17973:55;18047:12;;;36767:245::o;37019:416::-;37219:2;37233:47;;;18298:2;37204:18;;;42472:19;18334:34;42512:14;;;18314:55;-1:-1;;;18389:12;;;18382:37;18438:12;;;37190:245::o;37442:416::-;37642:2;37656:47;;;18689:2;37627:18;;;42472:19;-1:-1;;;42512:14;;;18705:39;18763:12;;;37613:245::o;37865:416::-;38065:2;38079:47;;;19014:2;38050:18;;;42472:19;19050:33;42512:14;;;19030:54;19103:12;;;38036:245::o;38288:416::-;38488:2;38502:47;;;19354:2;38473:18;;;42472:19;19390:31;42512:14;;;19370:52;19441:12;;;38459:245::o;38711:416::-;38911:2;38925:47;;;19692:2;38896:18;;;42472:19;19728:34;42512:14;;;19708:55;-1:-1;;;19783:12;;;19776:27;19822:12;;;38882:245::o;39134:416::-;39334:2;39348:47;;;20073:2;39319:18;;;42472:19;20109:34;42512:14;;;20089:55;-1:-1;;;20164:12;;;20157:34;20210:12;;;39305:245::o;39557:416::-;39757:2;39771:47;;;20461:2;39742:18;;;42472:19;20497:33;42512:14;;;20477:54;20550:12;;;39728:245::o;39980:416::-;40180:2;40194:47;;;20801:2;40165:18;;;42472:19;20837:34;42512:14;;;20817:55;-1:-1;;;20892:12;;;20885:46;20950:12;;;40151:245::o;40403:416::-;40603:2;40617:47;;;21201:2;40588:18;;;42472:19;21237:34;42512:14;;;21217:55;-1:-1;;;21292:12;;;21285:39;21343:12;;;40574:245::o;41055:556::-;8124:37;;;-1:-1;;;;;43135:54;;;;41431:2;41416:18;;7893:37;41514:2;41499:18;;8124:37;41597:2;41582:18;;8124:37;41266:3;41251:19;;41237:374::o;41618:333::-;8124:37;;;41937:2;41922:18;;8124:37;41773:2;41758:18;;41744:207::o;45016:268::-;45081:1;45088:101;45102:6;45099:1;45096:13;45088:101;;;45169:11;;;45163:18;45150:11;;;45143:39;45124:2;45117:10;45088:101;;;45204:6;45201:1;45198:13;45195:2;;;-1:-1;;45081:1;45251:16;;45244:27;45065:219::o;45397:117::-;-1:-1;;;;;43135:54;;45456:35;;45446:2;;45505:1;;45495:12;45446:2;45440:74;:::o

db28a746224fed258869e4a8645cbbd8efe45302ec46dccc56149fb7acc03529