Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at moonriver.moonscan.io on 2021-11-21
*/

// Sources flattened with hardhat v2.6.8 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^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);
}


// File @openzeppelin/contracts/utils/[email protected]



pragma solidity ^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;
        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");

        (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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/utils/[email protected]



pragma solidity ^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 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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]



pragma solidity ^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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]



pragma solidity ^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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/security/[email protected]



pragma solidity ^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() {
        _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;
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]



pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
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) {
        unchecked {
            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) {
        unchecked {
            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) {
        unchecked {
            // 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) {
        unchecked {
            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) {
        unchecked {
            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) {
        return a + b;
    }

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

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]



pragma solidity ^0.8.0;



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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

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

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

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

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

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

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

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

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

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

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


// File contracts/KittyPaws.sol



pragma solidity ^0.8.0;


contract KittyPaws is ERC20("KittyPaws", "PAWS"), Ownable {
    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (PawsChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }
}


// File contracts/interfaces/IMasterChef.sol



pragma solidity ^0.8.0;

interface IMasterChef {
    function deposit(uint256 _pid, uint256 _amount) external;

    function withdraw(uint256 _pid, uint256 _amount) external;

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

    function emergencyWithdraw(uint256 _pid) external;

    function pendingReward(uint256 _pid, address _user)
        external
        view
        returns (uint256);
}


// File contracts/PawsChef.sol



pragma solidity ^0.8.2;







// Copied and changed from SolarDistributor with few twicks - removed meta, forwarder, lockup, devAddress.
// Added possibility to add LP to for additional farm rewards
contract PawsChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 addRewardDebt;
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. Paws to distribute per block.
        uint256 lastRewardBlock; // Last block number that Paws distribution occurs.
        uint256 accPawsPerShare; // Accumulated Paws per share, times 1e12. See below.
        uint16 depositFeeBP; // Deposit fee in basis points
        uint256 totalLp; // Total token in Pool
        address addRewardChef; // Additional reward chef - lpToken will be deposited in that chef, not in PawsChef
        uint256 addRewardChefPid; // Additional reward chef pid - pid of farm at additional reward chef
        address addRewardToken; // Additional reward token that user gets
        uint256 accAddRewardsPerShare;
    }

    KittyPaws public paws;

    // The operator can only update EmissionRate and AllocPoint to protect tokenomics
    //i.e some wrong setting and a pools get too much allocation accidentally
    address private _operator;

    // Deposit Fee address
    address public feeAddress;

    // Paws tokens created per block
    uint256 public pawsPerBlock;

    // Maximum deposit fee rate: 10%
    uint16 public constant MAXIMUM_DEPOSIT_FEE_RATE = 1000;

    // Info of each pool
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    // The block number when Paws mining starts.
    uint256 public startBlock;

    // Total Paws in Paws Pools (can be multiple pools)
    uint256 public totalPawsInPools = 0;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(
        address indexed user,
        uint256 indexed pid,
        uint256 amount
    );
    event EmissionRateUpdated(
        address indexed caller,
        uint256 previousAmount,
        uint256 newAmount
    );
    event OperatorTransferred(
        address indexed previousOperator,
        address indexed newOperator
    );
    event FeeAddressChanged(
        address indexed caller,
        address oldAddress,
        address newAddress
    );
    event AllocPointsUpdated(
        address indexed caller,
        uint256 previousAmount,
        uint256 newAmount
    );

    modifier onlyOperator() {
        require(
            _operator == msg.sender,
            "Operator: caller is not the operator"
        );
        _;
    }

    constructor(KittyPaws _paws, uint256 _pawsPerBlock) {
        //StartBlock always many years later from contract construct, will be set later in StartFarming function
        startBlock = block.number + (10 * 365 * 24 * 60 * 60);

        paws = _paws;
        pawsPerBlock = _pawsPerBlock;

        feeAddress = msg.sender;
        _operator = msg.sender;
        emit OperatorTransferred(address(0), _operator);
    }

    function operator() public view returns (address) {
        return _operator;
    }

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

    function transferOperator(address newOperator) public onlyOperator {
        require(
            newOperator != address(0),
            "TransferOperator: new operator is the zero address"
        );
        emit OperatorTransferred(_operator, newOperator);
        _operator = newOperator;
    }

    // Set farming start, can call only once
    function startFarming() public onlyOwner {
        require(block.number < startBlock, "Error::Farm started already");

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

        startBlock = block.number;
    }

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

    // Add a new lp to the pool. Can only be called by the owner.
    // Can add multiple pool with same lp token without messing up rewards, because each pool's balance is tracked using its own totalLp
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        uint16 _depositFeeBP,
        bool _withUpdate
    ) public onlyOwner {
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "add: deposit fee too high"
        );
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock
            ? block.number
            : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accPawsPerShare: 0,
                depositFeeBP: _depositFeeBP,
                totalLp: 0,
                addRewardChef: address(0x0),
                addRewardChefPid: 0,
                addRewardToken: address(0x0),
                accAddRewardsPerShare: 0
            })
        );
    }

    function addWithAddReward(
        uint256 _allocPoint,
        IERC20 _lpToken,
        uint16 _depositFeeBP,
        bool _withUpdate,
        address _addRewardChef,
        uint256 _addRewardChefPid,
        address _addRewardToken
    ) public onlyOwner {
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "addWithAddReward: deposit fee too high"
        );
        require(
            _addRewardChef != address(0x0),
            "addWithAddReward: reward chef cannot be 0x0"
        );
        require(
            _addRewardToken != address(0x0),
            "addWithAddReward: reward token cannot be 0x0"
        );
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock
            ? block.number
            : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accPawsPerShare: 0,
                depositFeeBP: _depositFeeBP,
                totalLp: 0,
                addRewardChef: _addRewardChef,
                addRewardChefPid: _addRewardChefPid,
                addRewardToken: _addRewardToken,
                accAddRewardsPerShare: 0
            })
        );

        IERC20(_lpToken).safeApprove(_addRewardChef, type(uint128).max);
    }

    // Update the given pool's Paws allocation point and deposit fee. Can only be called by the owner.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        uint16 _depositFeeBP,
        bool _withUpdate
    ) public onlyOwner {
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "set: deposit fee too high"
        );
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(
            _allocPoint
        );
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
    }

    // View function to see pending Paws on frontend.
    function pendingReward(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accPawsPerShare = pool.accPawsPerShare;
        uint256 lpSupply = pool.totalLp;

        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(
                pool.lastRewardBlock,
                block.number
            );
            uint256 pawsReward = multiplier
                .mul(pawsPerBlock)
                .mul(pool.allocPoint)
                .div(totalAllocPoint);
            accPawsPerShare = accPawsPerShare.add(
                pawsReward.mul(1e12).div(lpSupply)
            );
        }

        return user.amount.mul(accPawsPerShare).div(1e12).sub(user.rewardDebt);
    }

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }

        uint256 lpSupply = pool.totalLp;
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }

        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 pawsReward = multiplier
            .mul(pawsPerBlock)
            .mul(pool.allocPoint)
            .div(totalAllocPoint);

        paws.mint(address(this), pawsReward);

        pool.accPawsPerShare = pool.accPawsPerShare.add(
            pawsReward.mul(1e12).div(pool.totalLp)
        );
        pool.lastRewardBlock = block.number;

        if (isAddRewardPool(_pid)) {
            uint256 beforeBal = IERC20(pool.addRewardToken).balanceOf(
                address(this)
            );
            IMasterChef(pool.addRewardChef).deposit(pool.addRewardChefPid, 0);
            uint256 afterBal = IERC20(pool.addRewardToken).balanceOf(
                address(this)
            );
            uint256 addReward = afterBal.sub(beforeBal);
            pool.accAddRewardsPerShare = pool.accAddRewardsPerShare.add(
                addReward.mul(1e12).div(pool.totalLp)
            );
        }
    }

    // Deposit LP tokens to MasterChef for Paws allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        require(
            block.number >= startBlock,
            "PawsChef: Can not deposit before start"
        );

        updatePool(_pid);

        payPendingPaws(_pid);

        if (isAddRewardPool(_pid)) {
            _depositWithReward(_pid, _amount);
        } else {
            _depositWithoutReward(_pid, _amount);
        }

        emit Deposit(_msgSender(), _pid, _amount);
    }

    function _depositWithoutReward(uint256 _pid, uint256 _amount) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        if (_amount > 0) {
            uint256 beforeDeposit = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(_msgSender(), address(this), _amount);
            uint256 afterDeposit = pool.lpToken.balanceOf(address(this));

            _amount = afterDeposit.sub(beforeDeposit);

            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);

                _amount = _amount.sub(depositFee);
            }

            user.amount = user.amount.add(_amount);
            pool.totalLp = pool.totalLp.add(_amount);

            if (address(pool.lpToken) == address(paws)) {
                totalPawsInPools = totalPawsInPools.add(_amount);
            }
        }

        user.rewardDebt = user.amount.mul(pool.accPawsPerShare).div(1e12);
    }

    function _depositWithReward(uint256 _pid, uint256 _amount) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        if (_amount > 0) {
            uint256 beforeDeposit = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(_msgSender(), address(this), _amount);
            uint256 afterDeposit = pool.lpToken.balanceOf(address(this));

            _amount = afterDeposit.sub(beforeDeposit);

            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);

                _amount = _amount.sub(depositFee);
            }

            (uint256 beforeChefDeposit, ) = IMasterChef(pool.addRewardChef)
                .userInfo(pool.addRewardChefPid, address(this));
            IMasterChef(pool.addRewardChef).deposit(
                pool.addRewardChefPid,
                _amount
            );
            (uint256 afterChefDeposit, ) = IMasterChef(pool.addRewardChef)
                .userInfo(pool.addRewardChefPid, address(this));
            _amount = afterChefDeposit.sub(beforeChefDeposit);

            user.amount = user.amount.add(_amount);
            pool.totalLp = pool.totalLp.add(_amount);

            if (address(pool.lpToken) == address(paws)) {
                totalPawsInPools = totalPawsInPools.add(_amount);
            }
        }

        user.rewardDebt = user.amount.mul(pool.accPawsPerShare).div(1e12);
        user.addRewardDebt = user.amount.mul(pool.accAddRewardsPerShare).div(
            1e12
        );
    }

    // Withdraw tokens
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        require(
            block.number >= startBlock,
            "PawsChef: Can not withdraw before start"
        );

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        //this will make sure that user can only withdraw from his pool
        require(user.amount >= _amount, "Withdraw: User amount not enough");

        //Cannot withdraw more than pool's balance
        require(pool.totalLp >= _amount, "Withdraw: Pool total not enough");

        updatePool(_pid);

        payPendingPaws(_pid);

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalLp = pool.totalLp.sub(_amount);
            if (address(pool.lpToken) == address(paws)) {
                totalPawsInPools = totalPawsInPools.sub(_amount);
            }
            if (isAddRewardPool(_pid)) {
                uint256 beforeWithdraw = pool.lpToken.balanceOf(address(this));
                IMasterChef(pool.addRewardChef).withdraw(
                    pool.addRewardChefPid,
                    _amount
                );
                uint256 afterWithdraw = pool.lpToken.balanceOf(address(this));
                _amount = afterWithdraw.sub(beforeWithdraw);

                pool.lpToken.safeTransfer(_msgSender(), _amount);
            } else {
                pool.lpToken.safeTransfer(_msgSender(), _amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accPawsPerShare).div(1e12);
        user.addRewardDebt = user.amount.mul(pool.accAddRewardsPerShare).div(
            1e12
        );
        emit Withdraw(_msgSender(), _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];
        uint256 amount = user.amount;

        //Cannot withdraw more than pool's balance
        require(
            pool.totalLp >= amount,
            "EmergencyWithdraw: Pool total not enough"
        );

        user.amount = 0;
        user.rewardDebt = 0;
        user.addRewardDebt = 0;
        pool.totalLp = pool.totalLp.sub(amount);

        if (address(pool.lpToken) == address(paws)) {
            totalPawsInPools = totalPawsInPools.sub(amount);
        }
        if (isAddRewardPool(_pid)) {
            uint256 beforeWithdraw = pool.lpToken.balanceOf(address(this));
            IMasterChef(pool.addRewardChef).withdraw(
                pool.addRewardChefPid,
                amount
            );
            uint256 afterWithdraw = pool.lpToken.balanceOf(address(this));
            amount = afterWithdraw.sub(beforeWithdraw);

            pool.lpToken.safeTransfer(_msgSender(), amount);
        } else {
            pool.lpToken.safeTransfer(_msgSender(), amount);
        }

        emit EmergencyWithdraw(_msgSender(), _pid, amount);
    }

    // Pay pending Paws.
    function payPendingPaws(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        uint256 pending = user.amount.mul(pool.accPawsPerShare).div(1e12).sub(
            user.rewardDebt
        );
        if (pending > 0) {
            // send rewards
            safePawsTransfer(_msgSender(), pending);
        }

        if (isAddRewardPool(_pid)) {
            uint256 addPending = user
                .amount
                .mul(pool.accAddRewardsPerShare)
                .div(1e12)
                .sub(user.addRewardDebt);
            if (addPending > 0) {
                safeAddRewardsTransfer(
                    pool.addRewardToken,
                    _msgSender(),
                    addPending
                );
            }
        }
    }

    // Safe Paws transfer function, just in case if rounding error causes pool do not have enough Paws.
    function safePawsTransfer(address _to, uint256 _amount) internal {
        if (paws.balanceOf(address(this)) > totalPawsInPools) {
            //PawsBal = total Paws in PawsChef - total Paws in Paws pools, this will make sure that PawsChef never transfer rewards from deposited Paws pools
            uint256 pawsBal = paws.balanceOf(address(this)).sub(
                totalPawsInPools
            );
            if (_amount >= pawsBal) {
                paws.transfer(_to, pawsBal);
            } else if (_amount > 0) {
                paws.transfer(_to, _amount);
            }
        }
    }

    function safeAddRewardsTransfer(
        address _addToken,
        address _to,
        uint256 _amount
    ) internal {
        uint256 addBal = IERC20(_addToken).balanceOf(address(this));
        if (_amount >= addBal) {
            IERC20(_addToken).safeTransfer(_to, addBal);
        } else if (_amount > 0) {
            IERC20(_addToken).safeTransfer(_to, _amount);
        }
    }

    function setFeeAddress(address _feeAddress) public {
        require(_msgSender() == feeAddress, "setFeeAddress: FORBIDDEN");
        require(_feeAddress != address(0), "setFeeAddress: ZERO");

        emit FeeAddressChanged(_msgSender(), feeAddress, _feeAddress);

        feeAddress = _feeAddress;
    }

    // Pancake has to add hidden dummy pools in order to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _pawsPerBlock) public onlyOperator {
        massUpdatePools();

        emit EmissionRateUpdated(msg.sender, pawsPerBlock, _pawsPerBlock);
        pawsPerBlock = _pawsPerBlock;
    }

    function updateAllocPoint(
        uint256 _pid,
        uint256 _allocPoint,
        bool _withUpdate
    ) public onlyOperator {
        if (_withUpdate) {
            massUpdatePools();
        }

        emit AllocPointsUpdated(
            _msgSender(),
            poolInfo[_pid].allocPoint,
            _allocPoint
        );

        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(
            _allocPoint
        );
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    function isAddRewardPool(uint256 _pid) public view returns (bool) {
        PoolInfo storage pool = poolInfo[_pid];
        return
            pool.addRewardChef != address(0x0) &&
            pool.addRewardToken != address(0x0) &&
            pool.addRewardChefPid >= 0;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract KittyPaws","name":"_paws","type":"address"},{"internalType":"uint256","name":"_pawsPerBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"AllocPointsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"EmissionRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":false,"internalType":"address","name":"newAddress","type":"address"}],"name":"FeeAddressChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MAXIMUM_DEPOSIT_FEE_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"},{"internalType":"address","name":"_addRewardChef","type":"address"},{"internalType":"uint256","name":"_addRewardChefPid","type":"uint256"},{"internalType":"address","name":"_addRewardToken","type":"address"}],"name":"addWithAddReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"isAddRewardPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paws","outputs":[{"internalType":"contract KittyPaws","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pawsPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accPawsPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"totalLp","type":"uint256"},{"internalType":"address","name":"addRewardChef","type":"address"},{"internalType":"uint256","name":"addRewardChefPid","type":"uint256"},{"internalType":"address","name":"addRewardToken","type":"address"},{"internalType":"uint256","name":"accAddRewardsPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startFarming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalPawsInPools","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"updateAllocPoint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pawsPerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"addRewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000006714cd1e19363dc613154ebe440172e41575c4690000000000000000000000000000000000000000000000000041ca7e961012f6

-----Decoded View---------------
Arg [0] : _paws (address): 0x6714Cd1e19363dc613154EbE440172e41575c469
Arg [1] : _pawsPerBlock (uint256): 18518518518518518

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000006714cd1e19363dc613154ebe440172e41575c469
Arg [1] : 0000000000000000000000000000000000000000000000000041ca7e961012f6

41604:20947:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46238:95;46310:8;:15;46238:95;;;16297:25:1;;;16285:2;16270:18;46238:95:0;;;;;;;;61505:224;;;;;;:::i;:::-;;:::i;:::-;;43296:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;6377:15:1;;;6359:34;;6424:2;6409:18;;6402:34;;;;6452:18;;6445:34;;;;6510:2;6495:18;;6488:34;;;;6571:6;6559:19;;;6553:3;6538:19;;6531:48;6610:3;6595:19;;6588:35;;;;6660:15;;6654:3;6639:19;;6632:44;6707:3;6692:19;;6685:35;6757:15;;;;6751:3;6736:19;;6729:44;6804:3;6789:19;;6782:35;;;;6285:3;6270:19;43296:26:0;5888:935:1;43541:34:0;;;;;;45497:304;;;;;;:::i;:::-;;:::i;43061:25::-;;;;;-1:-1:-1;;;;;43061:25:0;;;;;;-1:-1:-1;;;;;4592:55:1;;;4574:74;;4562:2;4547:18;43061:25:0;4428:226:1;55899:1782:0;;;;;;:::i;:::-;;:::i;43634:25::-;;;;;;51093:1380;;;;;;:::i;:::-;;:::i;57752:1269::-;;;;;;:::i;:::-;;:::i;45175:85::-;45243:9;;-1:-1:-1;;;;;45243:9:0;45175:85;;50837:180;;;:::i;47578:1520::-;;;;;;:::i;:::-;;:::i;43133:27::-;;;;;;17480:94;;;:::i;43725:35::-;;;;;;62265:283;;;;;;:::i;:::-;;:::i;:::-;;;5861:14:1;;5854:22;5836:41;;5824:2;5809:18;62265:283:0;5696:187:1;43207:54:0;;43257:4;43207:54;;;;;16132:6:1;16120:19;;;16102:38;;16090:2;16075:18;43207:54:0;15958:188:1;46546:1024:0;;;;;;:::i;:::-;;:::i;61060:312::-;;;;;;:::i;:::-;;:::i;16829:87::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;16829:87;;45336:153;;;;;;:::i;:::-;;:::i;43380:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17351:25:1;;;17407:2;17392:18;;17385:34;;;;17435:18;;;17428:34;17339:2;17324:18;43380:64:0;17149:319:1;49847:907:0;;;;;;:::i;:::-;;:::i;45855:375::-;;;:::i;61737:520::-;;;;;;:::i;:::-;;:::i;49210:574::-;;;;;;:::i;:::-;;:::i;52542:485::-;;;;;;:::i;:::-;;:::i;17729:192::-;;;;;;:::i;:::-;;:::i;42803:21::-;;;;;-1:-1:-1;;;;;42803:21:0;;;61505:224;44623:9;;-1:-1:-1;;;;;44623:9:0;44636:10;44623:23;44601:109;;;;-1:-1:-1;;;44601:109:0;;15755:2:1;44601:109:0;;;15737:21:1;15794:2;15774:18;;;15767:30;15833:34;15813:18;;;15806:62;-1:-1:-1;;;15884:18:1;;;15877:34;15928:19;;44601:109:0;;;;;;;;;61587:17:::1;:15;:17::i;:::-;61654:12;::::0;61622:60:::1;::::0;;16817:25:1;;;16873:2;16858:18;;16851:34;;;61642:10:0::1;::::0;61622:60:::1;::::0;16790:18:1;61622:60:0::1;;;;;;;61693:12;:28:::0;61505:224::o;43296:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;43296:26:0;;;;-1:-1:-1;43296:26:0;;;;;;;;;;;;;;;;;;;;;;;;:::o;45497:304::-;44623:9;;-1:-1:-1;;;;;44623:9:0;44636:10;44623:23;44601:109;;;;-1:-1:-1;;;44601:109:0;;15755:2:1;44601:109:0;;;15737:21:1;15794:2;15774:18;;;15767:30;15833:34;15813:18;;;15806:62;-1:-1:-1;;;15884:18:1;;;15877:34;15928:19;;44601:109:0;15553:400:1;44601:109:0;-1:-1:-1;;;;;45597:25:0;::::1;45575:125;;;::::0;-1:-1:-1;;;45575:125:0;;13788:2:1;45575:125:0::1;::::0;::::1;13770:21:1::0;13827:2;13807:18;;;13800:30;13866:34;13846:18;;;13839:62;13937:20;13917:18;;;13910:48;13975:19;;45575:125:0::1;13586:414:1::0;45575:125:0::1;45736:9;::::0;45716:43:::1;::::0;-1:-1:-1;;;;;45716:43:0;;::::1;::::0;45736:9:::1;::::0;45716:43:::1;::::0;45736:9:::1;::::0;45716:43:::1;45770:9;:23:::0;;-1:-1:-1;;;;;;45770:23:0::1;-1:-1:-1::0;;;;;45770:23:0;;;::::1;::::0;;;::::1;::::0;;45497:304::o;55899:1782::-;19864:1;20460:7;;:19;;20452:63;;;;-1:-1:-1;;;20452:63:0;;14972:2:1;20452:63:0;;;14954:21:1;15011:2;14991:18;;;14984:30;15050:33;15030:18;;;15023:61;15101:18;;20452:63:0;14770:355:1;20452:63:0;19864:1;20593:7;:18;56017:10:::1;::::0;56001:12:::1;:26;;55979:115;;;::::0;-1:-1:-1;;;55979:115:0;;11492:2:1;55979:115:0::1;::::0;::::1;11474:21:1::0;11531:2;11511:18;;;11504:30;11570:34;11550:18;;;11543:62;11641:9;11621:18;;;11614:37;11668:19;;55979:115:0::1;11290:403:1::0;55979:115:0::1;56107:21;56131:8;56140:4;56131:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;56180;;;:8:::1;:14:::0;;;;;;56131::::1;::::0;;::::1;;::::0;-1:-1:-1;56131:14:0;56195:12:::1;15691:10:::0;;15611:98;56195:12:::1;-1:-1:-1::0;;;;;56180:28:0::1;-1:-1:-1::0;;;;;56180:28:0::1;;;;;;;;;;;;56156:52;;56317:7;56302:4;:11;;;:22;;56294:67;;;::::0;-1:-1:-1;;;56294:67:0;;8434:2:1;56294:67:0::1;::::0;::::1;8416:21:1::0;;;8453:18;;;8446:30;8512:34;8492:18;;;8485:62;8564:18;;56294:67:0::1;8232:356:1::0;56294:67:0::1;56450:7;56434:4;:12;;;:23;;56426:67;;;::::0;-1:-1:-1;;;56426:67:0;;9558:2:1;56426:67:0::1;::::0;::::1;9540:21:1::0;9597:2;9577:18;;;9570:30;9636:33;9616:18;;;9609:61;9687:18;;56426:67:0::1;9356:355:1::0;56426:67:0::1;56506:16;56517:4;56506:10;:16::i;:::-;56535:20;56550:4;56535:14;:20::i;:::-;56572:11:::0;;56568:868:::1;;56614:11:::0;;:24:::1;::::0;56630:7;56614:15:::1;:24::i;:::-;56600:38:::0;;56668:12:::1;::::0;::::1;::::0;:25:::1;::::0;56685:7;56668:16:::1;:25::i;:::-;56653:12;::::0;::::1;:40:::0;56745:4:::1;::::0;56720:12;;-1:-1:-1;;;;;56720:12:0;;::::1;56745:4:::0;::::1;56712:38;56708:127;;;56790:16;::::0;:29:::1;::::0;56811:7;56790:20:::1;:29::i;:::-;56771:16;:48:::0;56708:127:::1;56853:21;56869:4;56853:15;:21::i;:::-;56849:576;;;56920:12:::0;;:37:::1;::::0;-1:-1:-1;;;56920:37:0;;56951:4:::1;56920:37;::::0;::::1;4574:74:1::0;56895:22:0::1;::::0;-1:-1:-1;;;;;56920:12:0::1;::::0;:22:::1;::::0;4547:18:1;;56920:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56988:18;::::0;::::1;::::0;57039:21:::1;::::0;::::1;::::0;56976:133:::1;::::0;-1:-1:-1;;;56976:133:0;;::::1;::::0;::::1;16817:25:1::0;;;;16858:18;;;16851:34;;;56895:62:0;;-1:-1:-1;;;;;;56988:18:0::1;::::0;56976:40:::1;::::0;16790:18:1;;56976:133:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;57152:12:0;;:37:::1;::::0;-1:-1:-1;;;57152:37:0;;57183:4:::1;57152:37;::::0;::::1;4574:74:1::0;57128:21:0::1;::::0;-1:-1:-1;;;;;;57152:12:0;;::::1;::::0;-1:-1:-1;57152:22:0::1;::::0;4547:18:1;;57152:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57128:61:::0;-1:-1:-1;57218:33:0::1;57128:61:::0;57236:14;57218:17:::1;:33::i;:::-;57208:43:::0;-1:-1:-1;57272:48:0::1;15691:10:::0;57272:12;;-1:-1:-1;;;;;57272:12:0::1;::::0;57312:7;57272:25:::1;:48::i;:::-;56876:460;;56849:576;;;57361:48;15691:10:::0;57361:12;;-1:-1:-1;;;;;57361:12:0::1;::::0;57401:7;57361:25:::1;:48::i;:::-;57480:20;::::0;::::1;::::0;57464:11;;:47:::1;::::0;57506:4:::1;::::0;57464:37:::1;::::0;:15:::1;:37::i;:::-;:41:::0;::::1;:47::i;:::-;57446:15;::::0;::::1;:65:::0;57559:26:::1;::::0;::::1;::::0;57543:11;;:77:::1;::::0;57605:4:::1;::::0;57543:43:::1;::::0;:15:::1;:43::i;:77::-;57522:18;::::0;::::1;:98:::0;57636:37:::1;::::0;16297:25:1;;;57659:4:0;;15691:10;;57636:37:::1;::::0;16285:2:1;16270:18;57636:37:0::1;;;;;;;;-1:-1:-1::0;;19820:1:0;20772:22;;-1:-1:-1;;55899:1782:0:o;51093:1380::-;51145:21;51169:8;51178:4;51169:14;;;;;;;;:::i;:::-;;;;;;;;;;;51145:38;;51214:4;:20;;;51198:12;:36;51194:75;;51251:7;51093:1380;:::o;51194:75::-;51300:12;;;;51327:13;;;:37;;-1:-1:-1;51344:15:0;;;;:20;51327:37;51323:126;;;-1:-1:-1;51404:12:0;51381:20;;;;:35;-1:-1:-1;51093:1380:0:o;51323:126::-;51461:18;51482:49;51496:4;:20;;;51518:12;51482:13;:49::i;:::-;51461:70;;51542:18;51563:112;51659:15;;51563:77;51624:4;:15;;;51563:42;51592:12;;51563:10;:28;;:42;;;;:::i;:::-;:60;;:77::i;:112::-;51688:4;;:36;;;;;51706:4;51688:36;;;5568:74:1;5658:18;;;5651:34;;;51542:133:0;;-1:-1:-1;;;;;;51688:4:0;;:9;;5541:18:1;;51688:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;51824:12:0;;;;51760:88;;-1:-1:-1;51799:38:0;;:20;:10;51814:4;51799:14;:20::i;:38::-;51760:20;;;;;:24;:88::i;:::-;51737:20;;;:111;51882:12;51859:20;;;:35;51911:21;51927:4;51911:15;:21::i;:::-;51907:559;;;51976:19;;;;51969:84;;-1:-1:-1;;;51969:84:0;;52033:4;51969:84;;;4574:74:1;51949:17:0;;-1:-1:-1;;;;;51976:19:0;;51969:37;;4547:18:1;;51969:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52080:18;;;;52108:21;;;;52068:65;;-1:-1:-1;;;52068:65:0;;;;;16817:25:1;;;;52080:18:0;16858::1;;;16851:34;51949:104:0;;-1:-1:-1;;;;;;52080:18:0;;52068:39;;16790:18:1;;52068:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;52174:19:0;;;;52167:84;;-1:-1:-1;;;52167:84:0;;52231:4;52167:84;;;4574:74:1;52148:16:0;;-1:-1:-1;;;;;52174:19:0;;52167:37;;4547:18:1;;52167:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52148:103;-1:-1:-1;52266:17:0;52286:23;52148:103;52299:9;52286:12;:23::i;:::-;52266:43;;52353:101;52402:37;52426:4;:12;;;52402:19;52416:4;52402:9;:13;;:19;;;;:::i;:37::-;52353:26;;;;;:30;:101::i;:::-;52324:26;;;:130;-1:-1:-1;;;51907:559:0;51134:1339;;;;51093:1380;:::o;57752:1269::-;19864:1;20460:7;;:19;;20452:63;;;;-1:-1:-1;;;20452:63:0;;14972:2:1;20452:63:0;;;14954:21:1;15011:2;14991:18;;;14984:30;15050:33;15030:18;;;15023:61;15101:18;;20452:63:0;14770:355:1;20452:63:0;19864:1;20593:7;:18;;;;57824:21:::1;57848:8;57857:4;57848:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;57897;;;:8:::1;:14:::0;;;;;;57848::::1;::::0;;::::1;;::::0;-1:-1:-1;57848:14:0;57912:12:::1;15691:10:::0;;15611:98;57912:12:::1;-1:-1:-1::0;;;;;57897:28:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;57897:28:0;57953:11;;58051:12:::1;::::0;::::1;::::0;57897:28;;-1:-1:-1;57953:11:0;58051:22;-1:-1:-1;58051:22:0::1;58029:112;;;::::0;-1:-1:-1;;;58029:112:0;;12668:2:1;58029:112:0::1;::::0;::::1;12650:21:1::0;12707:2;12687:18;;;12680:30;12746:34;12726:18;;;12719:62;12817:10;12797:18;;;12790:38;12845:19;;58029:112:0::1;12466:404:1::0;58029:112:0::1;58168:1;58154:15:::0;;;58180::::1;::::0;::::1;:19:::0;;;58210:18:::1;::::0;::::1;:22:::0;58258:12:::1;::::0;::::1;::::0;:24:::1;::::0;58275:6;58258:16:::1;:24::i;:::-;58243:12;::::0;::::1;:39:::0;58332:4:::1;::::0;58307:12;;-1:-1:-1;;;;;58307:12:0;;::::1;58332:4:::0;::::1;58299:38;58295:118;;;58373:16;::::0;:28:::1;::::0;58394:6;58373:20:::1;:28::i;:::-;58354:16;:47:::0;58295:118:::1;58427:21;58443:4;58427:15;:21::i;:::-;58423:528;;;58490:12:::0;;:37:::1;::::0;-1:-1:-1;;;58490:37:0;;58521:4:::1;58490:37;::::0;::::1;4574:74:1::0;58465:22:0::1;::::0;-1:-1:-1;;;;;58490:12:0::1;::::0;:22:::1;::::0;4547:18:1;;58490:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58554:18;::::0;::::1;::::0;58601:21:::1;::::0;::::1;::::0;58542:120:::1;::::0;-1:-1:-1;;;58542:120:0;;::::1;::::0;::::1;16817:25:1::0;;;;16858:18;;;16851:34;;;58465:62:0;;-1:-1:-1;;;;;;58554:18:0::1;::::0;58542:40:::1;::::0;16790:18:1;;58542:120:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;58701:12:0;;:37:::1;::::0;-1:-1:-1;;;58701:37:0;;58732:4:::1;58701:37;::::0;::::1;4574:74:1::0;58677:21:0::1;::::0;-1:-1:-1;;;;;;58701:12:0;;::::1;::::0;-1:-1:-1;58701:22:0::1;::::0;4547:18:1;;58701:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58677:61:::0;-1:-1:-1;58762:33:0::1;58677:61:::0;58780:14;58762:17:::1;:33::i;:::-;58753:42:::0;-1:-1:-1;58812:47:0::1;15691:10:::0;58812:12;;-1:-1:-1;;;;;58812:12:0::1;::::0;58852:6;58812:25:::1;:47::i;:::-;58450:421;;58423:528;;;58892:47;15691:10:::0;58892:12;;-1:-1:-1;;;;;58892:12:0::1;::::0;58932:6;58892:25:::1;:47::i;:::-;58968:45;::::0;16297:25:1;;;59000:4:0;;15691:10;;58968:45:::1;::::0;16285:2:1;16270:18;58968:45:0::1;16151:177:1::0;50837:180:0;50899:8;:15;50882:14;50925:85;50953:6;50947:3;:12;50925:85;;;50983:15;50994:3;50983:10;:15::i;:::-;50961:5;;;:::i;:::-;;;50925:85;;;;50871:146;50837:180::o;47578:1520::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;15691:10;17049:23;17041:68;;;;-1:-1:-1;;;17041:68:0;;12307:2:1;17041:68:0;;;12289:21:1;;;12326:18;;;12319:30;12385:34;12365:18;;;12358:62;12437:18;;17041:68:0;12105:356:1;17041:68:0;43257:4:::1;47878:41;::::0;::::1;;;47856:129;;;::::0;-1:-1:-1;;;47856:129:0;;10678:2:1;47856:129:0::1;::::0;::::1;10660:21:1::0;10717:2;10697:18;;;10690:30;10756:34;10736:18;;;10729:62;10827:8;10807:18;;;10800:36;10853:19;;47856:129:0::1;10476:402:1::0;47856:129:0::1;-1:-1:-1::0;;;;;48018:30:0;::::1;47996:123;;;::::0;-1:-1:-1;;;47996:123:0;;9918:2:1;47996:123:0::1;::::0;::::1;9900:21:1::0;9957:2;9937:18;;;9930:30;9996:34;9976:18;;;9969:62;10067:13;10047:18;;;10040:41;10098:19;;47996:123:0::1;9716:407:1::0;47996:123:0::1;-1:-1:-1::0;;;;;48152:31:0;::::1;48130:125;;;::::0;-1:-1:-1;;;48130:125:0;;7667:2:1;48130:125:0::1;::::0;::::1;7649:21:1::0;7706:2;7686:18;;;7679:30;7745:34;7725:18;;;7718:62;7816:14;7796:18;;;7789:42;7848:19;;48130:125:0::1;7465:408:1::0;48130:125:0::1;48270:11;48266:61;;;48298:17;:15;:17::i;:::-;48337:23;48378:10;;48363:12;:25;:79;;48432:10;;48363:79;;;48404:12;48363:79;48471:15;::::0;48337:105;;-1:-1:-1;48471:32:0::1;::::0;48491:11;48471:19:::1;:32::i;:::-;48453:15;:50:::0;48542:461:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;48542:461:0;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;48542:461:0;;;;;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;;::::1;::::0;;;;;;;;;;;;;;::::1;::::0;;;;;;;;;;;;48514:8:::1;:500:::0;;::::1;::::0;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;::::1;-1:-1:-1::0;;;;;;48514:500:0;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::1;-1:-1:-1::0;;48514:500:0;;::::1;;::::0;;;;;;;;;;;;;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;::::1;::::0;::::1;;::::0;;;;;;;;;;;;;49027:63:::1;::::0;48826:14;49072:17:::1;49027:28;:63::i;:::-;47845:1253;47578:1520:::0;;;;;;;:::o;17480:94::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;15691:10;17049:23;17041:68;;;;-1:-1:-1;;;17041:68:0;;12307:2:1;17041:68:0;;;12289:21:1;;;12326:18;;;12319:30;12385:34;12365:18;;;12358:62;12437:18;;17041:68:0;12105:356:1;17041:68:0;17545:21:::1;17563:1;17545:9;:21::i;:::-;17480:94::o:0;62265:283::-;62325:4;62342:21;62366:8;62375:4;62366:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;62411:18;;;;62366:14;;-1:-1:-1;;;;;;62411:18:0;:34;;;;:86;;-1:-1:-1;62462:19:0;;;;-1:-1:-1;;;;;62462:19:0;:35;;62411:86;:129;;;;-1:-1:-1;62514:26:0;62411:129;62391:149;62265:283;-1:-1:-1;;;62265:283:0:o;46546:1024::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;15691:10;17049:23;17041:68;;;;-1:-1:-1;;;17041:68:0;;12307:2:1;17041:68:0;;;12289:21:1;;;12326:18;;;12319:30;12385:34;12365:18;;;12358:62;12437:18;;17041:68:0;12105:356:1;17041:68:0;43257:4:::1;46730:41;::::0;::::1;;;46708:116;;;::::0;-1:-1:-1;;;46708:116:0;;14618:2:1;46708:116:0::1;::::0;::::1;14600:21:1::0;14657:2;14637:18;;;14630:30;14696:27;14676:18;;;14669:55;14741:18;;46708:116:0::1;14416:349:1::0;46708:116:0::1;46839:11;46835:61;;;46867:17;:15;:17::i;:::-;46906:23;46947:10;;46932:12;:25;:79;;47001:10;;46932:79;;;46973:12;46932:79;47040:15;::::0;46906:105;;-1:-1:-1;47040:32:0::1;::::0;47060:11;47040:19:::1;:32::i;:::-;47022:15;:50:::0;47111:440:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;47111:440:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;47111:440:0;;;;;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47083:8:::1;:479:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;47083:479:0;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47083:479:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;;;;;;;;-1:-1:-1;46546:1024:0:o;61060:312::-;61146:10;;-1:-1:-1;;;;;61146:10:0;15691;-1:-1:-1;;;;;61130:26:0;;61122:63;;;;-1:-1:-1;;;61122:63:0;;13435:2:1;61122:63:0;;;13417:21:1;13474:2;13454:18;;;13447:30;13513:26;13493:18;;;13486:54;13557:18;;61122:63:0;13233:348:1;61122:63:0;-1:-1:-1;;;;;61204:25:0;;61196:57;;;;-1:-1:-1;;;61196:57:0;;10330:2:1;61196:57:0;;;10312:21:1;10369:2;10349:18;;;10342:30;10408:21;10388:18;;;10381:49;10447:18;;61196:57:0;10128:343:1;61196:57:0;61303:10;;61271:56;;;-1:-1:-1;;;;;61303:10:0;;;4894:34:1;;4964:15;;;4959:2;4944:18;;4937:43;61271:56:0;;15691:10;;61271:56;;;;;;;;;61340:10;:24;;-1:-1:-1;;;;;;61340:24:0;-1:-1:-1;;;;;61340:24:0;;;;;;;;;;61060:312::o;45336:153::-;45435:7;45467:14;:3;45475:5;45467:7;:14::i;49847:907::-;49949:7;49974:21;49998:8;50007:4;49998:14;;;;;;;;:::i;:::-;;;;;;;;;50047;;;:8;:14;;;;;;-1:-1:-1;;;;;50047:21:0;;;;;;;;;50105:20;49998:14;;;;;;;50105:20;;;;50155:12;;;;50199:20;;;;49998:14;;-1:-1:-1;50105:20:0;;50184:12;:35;:52;;;;-1:-1:-1;50223:13:0;;;50184:52;50180:484;;;50253:18;50274:98;50306:4;:20;;;50345:12;50274:13;:98::i;:::-;50253:119;;50387:18;50408:124;50516:15;;50408:85;50477:4;:15;;;50408:46;50441:12;;50408:10;:32;;:46;;;;:::i;:124::-;50387:145;-1:-1:-1;50565:87:0;50603:34;50628:8;50603:20;50387:145;50618:4;50603:14;:20::i;:34::-;50565:15;;:19;:87::i;:::-;50547:105;;50238:426;;50180:484;50683:63;50730:4;:15;;;50683:42;50720:4;50683:32;50699:15;50683:4;:11;;;:15;;:32;;;;:::i;:42::-;:46;;:63::i;:::-;50676:70;49847:907;-1:-1:-1;;;;;;;49847:907:0:o;45855:375::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;15691:10;17049:23;17041:68;;;;-1:-1:-1;;;17041:68:0;;12307:2:1;17041:68:0;;;12289:21:1;;;12326:18;;;12319:30;12385:34;12365:18;;;12358:62;12437:18;;17041:68:0;12105:356:1;17041:68:0;45930:10:::1;;45915:12;:25;45907:65;;;::::0;-1:-1:-1;;;45907:65:0;;9202:2:1;45907:65:0::1;::::0;::::1;9184:21:1::0;9241:2;9221:18;;;9214:30;9280:29;9260:18;;;9253:57;9327:18;;45907:65:0::1;9000:351:1::0;45907:65:0::1;46002:8;:15:::0;45985:14:::1;46028:157;46056:6;46050:3;:12;46028:157;;;46086:21;46110:8;46119:3;46110:13;;;;;;;;:::i;:::-;;;;;;;;;;;46086:37;;46161:12;46138:4;:20;;:35;;;;46071:114;46064:5;;;;:::i;:::-;;;46028:157;;;-1:-1:-1::0;;46210:12:0::1;46197:10;:25:::0;45855:375::o;61737:520::-;44623:9;;-1:-1:-1;;;;;44623:9:0;44636:10;44623:23;44601:109;;;;-1:-1:-1;;;44601:109:0;;15755:2:1;44601:109:0;;;15737:21:1;15794:2;15774:18;;;15767:30;15833:34;15813:18;;;15806:62;-1:-1:-1;;;15884:18:1;;;15877:34;15928:19;;44601:109:0;15553:400:1;44601:109:0;61885:11:::1;61881:61;;;61913:17;:15;:17::i;:::-;15691:10:::0;-1:-1:-1;;;;;61959:122:0::1;;62019:8;62028:4;62019:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;62059:11;61959:122;;;;;;16817:25:1::0;;;16873:2;16858:18;;16851:34;16805:2;16790:18;;16635:256;61959:122:0::1;;;;;;;;62112:87;62177:11;62112:46;62132:8;62141:4;62132:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;62112:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:87::i;:::-;62094:15;:105;;;;62238:11;62210:8;62219:4;62210:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;61737:520:::0;;;:::o;49210:574::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;15691:10;17049:23;17041:68;;;;-1:-1:-1;;;17041:68:0;;12307:2:1;17041:68:0;;;12289:21:1;;;12326:18;;;12319:30;12385:34;12365:18;;;12358:62;12437:18;;17041:68:0;12105:356:1;17041:68:0;43257:4:::1;49391:41;::::0;::::1;;;49369:116;;;::::0;-1:-1:-1;;;49369:116:0;;8080:2:1;49369:116:0::1;::::0;::::1;8062:21:1::0;8119:2;8099:18;;;8092:30;8158:27;8138:18;;;8131:55;8203:18;;49369:116:0::1;7878:349:1::0;49369:116:0::1;49500:11;49496:61;;;49528:17;:15;:17::i;:::-;49585:87;49650:11;49585:46;49605:8;49614:4;49605:14;;;;;;;;:::i;49585:87::-;49567:15;:105;;;;49711:11;49683:8;49692:4;49683:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;49763:13;49733:8;49742:4;49733:14;;;;;;;;:::i;:::-;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;49210:574:::0;;;;:::o;52542:485::-;19864:1;20460:7;;:19;;20452:63;;;;-1:-1:-1;;;20452:63:0;;14972:2:1;20452:63:0;;;14954:21:1;15011:2;14991:18;;;14984:30;15050:33;15030:18;;;15023:61;15101:18;;20452:63:0;14770:355:1;20452:63:0;19864:1;20593:7;:18;52659:10:::1;::::0;52643:12:::1;:26;;52621:114;;;::::0;-1:-1:-1;;;52621:114:0;;11900:2:1;52621:114:0::1;::::0;::::1;11882:21:1::0;11939:2;11919:18;;;11912:30;11978:34;11958:18;;;11951:62;12049:8;12029:18;;;12022:36;12075:19;;52621:114:0::1;11698:402:1::0;52621:114:0::1;52748:16;52759:4;52748:10;:16::i;:::-;52777:20;52792:4;52777:14;:20::i;:::-;52814:21;52830:4;52814:15;:21::i;:::-;52810:156;;;52852:33;52871:4;52877:7;52852:18;:33::i;:::-;52810:156;;;52918:36;52940:4;52946:7;52918:21;:36::i;:::-;52983;::::0;16297:25:1;;;53005:4:0;;15691:10;;52983:36:::1;::::0;16285:2:1;16270:18;52983:36:0::1;;;;;;;-1:-1:-1::0;;19820:1:0;20772:22;;52542:485::o;17729:192::-;16875:7;16902:6;-1:-1:-1;;;;;16902:6:0;15691:10;17049:23;17041:68;;;;-1:-1:-1;;;17041:68:0;;12307:2:1;17041:68:0;;;12289:21:1;;;12326:18;;;12319:30;12385:34;12365:18;;;12358:62;12437:18;;17041:68:0;12105:356:1;17041:68:0;-1:-1:-1;;;;;17818:22:0;::::1;17810:73;;;::::0;-1:-1:-1;;;17810:73:0;;8795:2:1;17810:73:0::1;::::0;::::1;8777:21:1::0;8834:2;8814:18;;;8807:30;8873:34;8853:18;;;8846:62;8944:8;8924:18;;;8917:36;8970:19;;17810:73:0::1;8593:402:1::0;17810:73:0::1;17894:19;17904:8;17894:9;:19::i;:::-;17729:192:::0;:::o;59055:868::-;59113:21;59137:8;59146:4;59137:14;;;;;;;;:::i;:::-;;;;;;;;;59186;;;:8;:14;;;;;;59137;;;;;;-1:-1:-1;59137:14:0;59201:12;15691:10;;15611:98;59201:12;-1:-1:-1;;;;;59186:28:0;-1:-1:-1;;;;;59186:28:0;;;;;;;;;;;;59162:52;;59227:15;59245:92;59311:4;:15;;;59245:47;59287:4;59245:37;59261:4;:20;;;59245:4;:11;;;:15;;:37;;;;:::i;:92::-;59227:110;-1:-1:-1;59352:11:0;;59348:112;;59409:39;15691:10;59440:7;59409:16;:39::i;:::-;59476:21;59492:4;59476:15;:21::i;:::-;59472:444;;;59514:18;59535:149;59665:4;:18;;;59535:107;59637:4;59535:79;59587:4;:26;;;59535:4;:29;;;:51;;:79;;;;:::i;:149::-;59514:170;-1:-1:-1;59703:14:0;;59699:206;;59783:19;;;;59738:151;;-1:-1:-1;;;;;59783:19:0;15691:10;59860;59738:22;:151::i;59472:444::-;59102:821;;;59055:868;:::o;23990:98::-;24048:7;24075:5;24079:1;24075;:5;:::i;11682:211::-;11826:58;;-1:-1:-1;;;;;5586:55:1;;11826:58:0;;;5568:74:1;5658:18;;;5651:34;;;11799:86:0;;11819:5;;-1:-1:-1;;;11849:23:0;5541:18:1;;11826:58:0;;;;-1:-1:-1;;11826:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;11799:19;:86::i;:::-;11682:211;;;:::o;24347:98::-;24405:7;24432:5;24436:1;24432;:5;:::i;24746:98::-;24804:7;24831:5;24835:1;24831;:5;:::i;23609:98::-;23667:7;23694:5;23698:1;23694;:5;:::i;12418:616::-;12782:10;;;12781:62;;-1:-1:-1;12798:39:0;;;;;12822:4;12798:39;;;4894:34:1;-1:-1:-1;;;;;4964:15:1;;;4944:18;;;4937:43;12798:15:0;;;;;4806:18:1;;12798:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;12781:62;12759:166;;;;-1:-1:-1;;;12759:166:0;;15332:2:1;12759:166:0;;;15314:21:1;15371:2;15351:18;;;15344:30;15410:34;15390:18;;;15383:62;15481:24;15461:18;;;15454:52;15523:19;;12759:166:0;15130:418:1;12759:166:0;12963:62;;-1:-1:-1;;;;;5586:55:1;;12963:62:0;;;5568:74:1;5658:18;;;5651:34;;;12936:90:0;;12956:5;;12986:22;;5541:18:1;;12963:62:0;5394:297:1;17929:173:0;17985:16;18004:6;;-1:-1:-1;;;;;18021:17:0;;;-1:-1:-1;;;;;;18021:17:0;;;;;;18054:40;;18004:6;;;;;;;18054:40;;17985:16;18054:40;17974:128;17929:173;:::o;54159:1708::-;54238:21;54262:8;54271:4;54262:14;;;;;;;;:::i;:::-;;;;;;;;;54311;;;:8;:14;;;;;;54262;;;;;;-1:-1:-1;54262:14:0;54326:12;15691:10;;15611:98;54326:12;-1:-1:-1;;;;;54311:28:0;;;;;;;;;;;;-1:-1:-1;54311:28:0;;-1:-1:-1;54356:11:0;;54352:1321;;54408:12;;:37;;-1:-1:-1;;;54408:37:0;;54439:4;54408:37;;;4574:74:1;54384:21:0;;-1:-1:-1;;;;;54408:12:0;;:22;;4547:18:1;;54408:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54384:61;-1:-1:-1;54460:67:0;15691:10;54490:12;54460;;-1:-1:-1;;;;;54460:12:0;;54512:4;54519:7;54460:29;:67::i;:::-;54565:12;;:37;;-1:-1:-1;;;54565:37:0;;54596:4;54565:37;;;4574:74:1;54542:20:0;;-1:-1:-1;;;;;54565:12:0;;:22;;4547:18:1;;54565:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54542:60;-1:-1:-1;54629:31:0;54542:60;54646:13;54629:16;:31::i;:::-;54681:17;;;;54619:41;;-1:-1:-1;54681:17:0;;:21;54677:246;;54756:17;;;;54723:18;;54744:41;;54779:5;;54744:30;;:7;;54756:17;;54744:11;:30::i;:41::-;54830:10;;54804:12;;54723:62;;-1:-1:-1;54804:49:0;;-1:-1:-1;;;;;54804:12:0;;;;54830:10;54723:62;54804:25;:49::i;:::-;54884:23;:7;54896:10;54884:11;:23::i;:::-;54874:33;;54704:219;54677:246;54983:18;;;;55030:21;;;;54971:96;;-1:-1:-1;;;54971:96:0;;;;;16507:25:1;;;;55061:4:0;16548:18:1;;;16541:83;54940:25:0;;-1:-1:-1;;;;;54983:18:0;;54971:58;;16480:18:1;;54971:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;55094:18:0;;;;55140:21;;;;55082:120;;-1:-1:-1;;;55082:120:0;;;;;16817:25:1;;;;16858:18;;;16851:34;;;54939:128:0;;-1:-1:-1;;;;;;55094:18:0;;55082:39;;16790:18:1;;55082:120:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;55260:18:0;;;;55307:21;;;;55248:96;;-1:-1:-1;;;55248:96:0;;;;;16507:25:1;;;;55338:4:0;16548:18:1;;;16541:83;55218:24:0;;-1:-1:-1;;;;;55260:18:0;;55248:58;;16480:18:1;;55248:96:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;55217:127:0;-1:-1:-1;55369:39:0;55217:127;55390:17;55369:20;:39::i;:::-;55439:11;;55359:49;;-1:-1:-1;55439:24:0;;55359:49;55439:15;:24::i;:::-;55425:38;;55493:12;;;;:25;;55510:7;55493:16;:25::i;:::-;55478:12;;;:40;55572:4;;55547:12;;-1:-1:-1;;;;;55547:12:0;;;55572:4;;55539:38;55535:127;;;55617:16;;:29;;55638:7;55617:20;:29::i;:::-;55598:16;:48;55535:127;54369:1304;;;;54352:1321;55719:20;;;;55703:11;;:47;;55745:4;;55703:37;;:15;:37::i;:47::-;55685:15;;;:65;55798:26;;;;55782:11;;:77;;55844:4;;55782:43;;:15;:43::i;:77::-;55761:18;;;;:98;-1:-1:-1;;;54159:1708:0:o;53035:1116::-;53117:21;53141:8;53150:4;53141:14;;;;;;;;:::i;:::-;;;;;;;;;53190;;;:8;:14;;;;;;53141;;;;;;-1:-1:-1;53141:14:0;53205:12;15691:10;;15611:98;53205:12;-1:-1:-1;;;;;53190:28:0;;;;;;;;;;;;-1:-1:-1;53190:28:0;;-1:-1:-1;53235:11:0;;53231:835;;53287:12;;:37;;-1:-1:-1;;;53287:37:0;;53318:4;53287:37;;;4574:74:1;53263:21:0;;-1:-1:-1;;;;;53287:12:0;;:22;;4547:18:1;;53287:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53263:61;-1:-1:-1;53339:67:0;15691:10;53369:12;15611:98;53339:67;53444:12;;:37;;-1:-1:-1;;;53444:37:0;;53475:4;53444:37;;;4574:74:1;53421:20:0;;-1:-1:-1;;;;;53444:12:0;;:22;;4547:18:1;;53444:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53421:60;-1:-1:-1;53508:31:0;53421:60;53525:13;53508:16;:31::i;:::-;53560:17;;;;53498:41;;-1:-1:-1;53560:17:0;;:21;53556:246;;53635:17;;;;53602:18;;53623:41;;53658:5;;53623:30;;:7;;53635:17;;53623:11;:30::i;:41::-;53709:10;;53683:12;;53602:62;;-1:-1:-1;53683:49:0;;-1:-1:-1;;;;;53683:12:0;;;;53709:10;53602:62;53683:25;:49::i;:::-;53763:23;:7;53775:10;53763:11;:23::i;:::-;53753:33;;53583:219;53556:246;53832:11;;:24;;53848:7;53832:15;:24::i;:::-;53818:38;;53886:12;;;;:25;;53903:7;53886:16;:25::i;:::-;53871:12;;;:40;53965:4;;53940:12;;-1:-1:-1;;;;;53940:12:0;;;53965:4;;53932:38;53928:127;;;54010:16;;:29;;54031:7;54010:20;:29::i;:::-;53991:16;:48;53928:127;53248:818;;53231:835;54112:20;;;;54096:11;;:47;;54138:4;;54096:37;;:15;:37::i;:47::-;54078:15;;;;:65;-1:-1:-1;;;53035:1116:0:o;60036:609::-;60148:16;;60116:4;;:29;;-1:-1:-1;;;60116:29:0;;60139:4;60116:29;;;4574:74:1;-1:-1:-1;;;;;60116:4:0;;;;:14;;4547:18:1;;60116:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:48;60112:526;;;60410:16;;60358:4;;:29;;-1:-1:-1;;;60358:29:0;;60381:4;60358:29;;;4574:74:1;60340:15:0;;60358:83;;60410:16;;-1:-1:-1;;;;;60358:4:0;;;;:14;;4547:18:1;;60358:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:83::-;60340:101;;60471:7;60460;:18;60456:171;;60499:4;;:27;;-1:-1:-1;;;60499:27:0;;-1:-1:-1;;;;;5586:55:1;;;60499:27:0;;;5568:74:1;5658:18;;;5651:34;;;60499:4:0;;;;:13;;5541:18:1;;60499:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;60456:171::-;60552:11;;60548:79;;60584:4;;:27;;-1:-1:-1;;;60584:27:0;;-1:-1:-1;;;;;5586:55:1;;;60584:27:0;;;5568:74:1;5658:18;;;5651:34;;;60584:4:0;;;;:13;;5541:18:1;;60584:27:0;5394:297:1;60653:399:0;60805:42;;-1:-1:-1;;;60805:42:0;;60841:4;60805:42;;;4574:74:1;60788:14:0;;-1:-1:-1;;;;;60805:27:0;;;;;4547:18:1;;60805:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60788:59;;60873:6;60862:7;:17;60858:187;;60896:43;-1:-1:-1;;;;;60896:30:0;;60927:3;60932:6;60896:30;:43::i;:::-;60858:187;;;60961:11;;60957:88;;60989:44;-1:-1:-1;;;;;60989:30:0;;61020:3;61025:7;60989:30;:44::i;14255:716::-;14679:23;14705:69;14733:4;14705:69;;;;;;;;;;;;;;;;;14713:5;-1:-1:-1;;;;;14705:27:0;;;:69;;;;;:::i;:::-;14789:17;;14679:95;;-1:-1:-1;14789:21:0;14785:179;;14886:10;14875:30;;;;;;;;;;;;:::i;:::-;14867:85;;;;-1:-1:-1;;;14867:85:0;;14207:2:1;14867:85:0;;;14189:21:1;14246:2;14226:18;;;14219:30;14285:34;14265:18;;;14258:62;14356:12;14336:18;;;14329:40;14386:19;;14867:85:0;14005:406:1;11901:248:0;12072:68;;-1:-1:-1;;;;;5272:15:1;;;12072:68:0;;;5254:34:1;5324:15;;5304:18;;;5297:43;5356:18;;;5349:34;;;12045:96:0;;12065:5;;12095:27;;5166:18:1;;12072:68:0;4991:398:1;6522:229:0;6659:12;6691:52;6713:6;6721:4;6727:1;6730:12;6691:21;:52::i;:::-;6684:59;6522:229;-1:-1:-1;;;;6522:229:0:o;7642:510::-;7812:12;7870:5;7845:21;:30;;7837:81;;;;-1:-1:-1;;;7837:81:0;;11085:2:1;7837:81:0;;;11067:21:1;11124:2;11104:18;;;11097:30;11163:34;11143:18;;;11136:62;11234:8;11214:18;;;11207:36;11260:19;;7837:81:0;10883:402:1;7837:81:0;4039:20;;7929:60;;;;-1:-1:-1;;;7929:60:0;;13077:2:1;7929:60:0;;;13059:21:1;13116:2;13096:18;;;13089:30;13155:31;13135:18;;;13128:59;13204:18;;7929:60:0;12875:353:1;7929:60:0;8003:12;8017:23;8044:6;-1:-1:-1;;;;;8044:11:0;8063:5;8070:4;8044:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8002:73;;;;8093:51;8110:7;8119:10;8131:12;10478;10507:7;10503:530;;;-1:-1:-1;10538:10:0;10531:17;;10503:530;10652:17;;:21;10648:374;;10850:10;10844:17;10911:15;10898:10;10894:2;10890:19;10883:44;10648:374;10993:12;10986:20;;-1:-1:-1;;;10986:20:0;;;;;;;;:::i;14:159:1:-;81:20;;141:6;130:18;;120:29;;110:57;;163:1;160;153:12;110:57;14:159;;;:::o;178:247::-;237:6;290:2;278:9;269:7;265:23;261:32;258:52;;;306:1;303;296:12;258:52;345:9;332:23;364:31;389:5;364:31;:::i;430:245::-;497:6;550:2;538:9;529:7;525:23;521:32;518:52;;;566:1;563;556:12;518:52;598:9;592:16;617:28;639:5;617:28;:::i;680:180::-;739:6;792:2;780:9;771:7;767:23;763:32;760:52;;;808:1;805;798:12;760:52;-1:-1:-1;831:23:1;;680:180;-1:-1:-1;680:180:1:o;865:184::-;935:6;988:2;976:9;967:7;963:23;959:32;956:52;;;1004:1;1001;994:12;956:52;-1:-1:-1;1027:16:1;;865:184;-1:-1:-1;865:184:1:o;1054:315::-;1122:6;1130;1183:2;1171:9;1162:7;1158:23;1154:32;1151:52;;;1199:1;1196;1189:12;1151:52;1235:9;1222:23;1212:33;;1295:2;1284:9;1280:18;1267:32;1308:31;1333:5;1308:31;:::i;:::-;1358:5;1348:15;;;1054:315;;;;;:::o;1374:536::-;1469:6;1477;1485;1493;1546:3;1534:9;1525:7;1521:23;1517:33;1514:53;;;1563:1;1560;1553:12;1514:53;1599:9;1586:23;1576:33;;1659:2;1648:9;1644:18;1631:32;1672:31;1697:5;1672:31;:::i;:::-;1722:5;-1:-1:-1;1746:37:1;1779:2;1764:18;;1746:37;:::i;:::-;1736:47;;1835:2;1824:9;1820:18;1807:32;1848:30;1870:7;1848:30;:::i;:::-;1374:536;;;;-1:-1:-1;1374:536:1;;-1:-1:-1;;1374:536:1:o;1915:889::-;2037:6;2045;2053;2061;2069;2077;2085;2138:3;2126:9;2117:7;2113:23;2109:33;2106:53;;;2155:1;2152;2145:12;2106:53;2191:9;2178:23;2168:33;;2251:2;2240:9;2236:18;2223:32;2264:31;2289:5;2264:31;:::i;:::-;2314:5;-1:-1:-1;2338:37:1;2371:2;2356:18;;2338:37;:::i;:::-;2328:47;;2427:2;2416:9;2412:18;2399:32;2440:30;2462:7;2440:30;:::i;:::-;2489:7;-1:-1:-1;2548:3:1;2533:19;;2520:33;2562;2520;2562;:::i;:::-;2614:7;-1:-1:-1;2668:3:1;2653:19;;2640:33;;-1:-1:-1;2725:3:1;2710:19;;2697:33;2739;2697;2739;:::i;:::-;2791:7;2781:17;;;1915:889;;;;;;;;;;:::o;2809:248::-;2877:6;2885;2938:2;2926:9;2917:7;2913:23;2909:32;2906:52;;;2954:1;2951;2944:12;2906:52;-1:-1:-1;;2977:23:1;;;3047:2;3032:18;;;3019:32;;-1:-1:-1;2809:248:1:o;3062:245::-;3141:6;3149;3202:2;3190:9;3181:7;3177:23;3173:32;3170:52;;;3218:1;3215;3208:12;3170:52;-1:-1:-1;;3241:16:1;;3297:2;3282:18;;;3276:25;3241:16;;3276:25;;-1:-1:-1;3062:245:1:o;3312:377::-;3386:6;3394;3402;3455:2;3443:9;3434:7;3430:23;3426:32;3423:52;;;3471:1;3468;3461:12;3423:52;3507:9;3494:23;3484:33;;3564:2;3553:9;3549:18;3536:32;3526:42;;3618:2;3607:9;3603:18;3590:32;3631:28;3653:5;3631:28;:::i;:::-;3678:5;3668:15;;;3312:377;;;;;:::o;3694:450::-;3776:6;3784;3792;3800;3853:3;3841:9;3832:7;3828:23;3824:33;3821:53;;;3870:1;3867;3860:12;3821:53;3906:9;3893:23;3883:33;;3963:2;3952:9;3948:18;3935:32;3925:42;;3986:37;4019:2;4008:9;4004:18;3986:37;:::i;4149:274::-;4278:3;4316:6;4310:13;4332:53;4378:6;4373:3;4366:4;4358:6;4354:17;4332:53;:::i;:::-;4401:16;;;;;4149:274;-1:-1:-1;;4149:274:1:o;7077:383::-;7226:2;7215:9;7208:21;7189:4;7258:6;7252:13;7301:6;7296:2;7285:9;7281:18;7274:34;7317:66;7376:6;7371:2;7360:9;7356:18;7351:2;7343:6;7339:15;7317:66;:::i;:::-;7444:2;7423:15;-1:-1:-1;;7419:29:1;7404:45;;;;7451:2;7400:54;;7077:383;-1:-1:-1;;7077:383:1:o;17473:128::-;17513:3;17544:1;17540:6;17537:1;17534:13;17531:39;;;17550:18;;:::i;:::-;-1:-1:-1;17586:9:1;;17473:128::o;17606:274::-;17646:1;17672;17662:189;;-1:-1:-1;;;17704:1:1;17697:88;17808:4;17805:1;17798:15;17836:4;17833:1;17826:15;17662:189;-1:-1:-1;17865:9:1;;17606:274::o;17885:168::-;17925:7;17991:1;17987;17983:6;17979:14;17976:1;17973:21;17968:1;17961:9;17954:17;17950:45;17947:71;;;17998:18;;:::i;:::-;-1:-1:-1;18038:9:1;;17885:168::o;18058:125::-;18098:4;18126:1;18123;18120:8;18117:34;;;18131:18;;:::i;:::-;-1:-1:-1;18168:9:1;;18058:125::o;18188:258::-;18260:1;18270:113;18284:6;18281:1;18278:13;18270:113;;;18360:11;;;18354:18;18341:11;;;18334:39;18306:2;18299:10;18270:113;;;18401:6;18398:1;18395:13;18392:48;;;-1:-1:-1;;18436:1:1;18418:16;;18411:27;18188:258::o;18451:135::-;18490:3;-1:-1:-1;;18511:17:1;;18508:43;;;18531:18;;:::i;:::-;-1:-1:-1;18578:1:1;18567:13;;18451:135::o;18591:184::-;-1:-1:-1;;;18640:1:1;18633:88;18740:4;18737:1;18730:15;18764:4;18761:1;18754:15;18780:184;-1:-1:-1;;;18829:1:1;18822:88;18929:4;18926:1;18919:15;18953:4;18950:1;18943:15;18969:154;-1:-1:-1;;;;;19048:5:1;19044:54;19037:5;19034:65;19024:93;;19113:1;19110;19103:12;19128:118;19214:5;19207:13;19200:21;19193:5;19190:32;19180:60;;19236:1;19233;19226:12

ipfs://d422efa628ea7f0637f26e0d3fa0e4a52b6360f16471db58b5e24c3d166e654a