Contract 0x1D227F7e283D653a60F94d2350CAB7a49bB85C6f

/**
 *Submitted for verification at BscScan.com on 2020-10-19
*/

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);
    function mint(address account, uint amount) external;
    /**
     * @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/math/SafeMath.sol



pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

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

// File: @openzeppelin/contracts/utils/Address.sol



pragma solidity ^0.6.2;

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

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

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

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

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

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

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

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

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

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

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

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



pragma solidity ^0.6.0;




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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/EnumerableSet.sol



pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// File: contracts/interfaces/INarCardFactory.sol

pragma solidity 0.6.12;

interface INarCardFactory {
    function getNarCard(uint256 tokenId)
        external view
        returns (
            uint8 types,
            uint256 powers
        );
}

// File: @openzeppelin/contracts/introspection/IERC165.sol



pragma solidity ^0.6.0;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol



pragma solidity ^0.6.2;


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

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

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

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

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

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

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

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

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

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

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

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

// File: contracts/interfaces/INarCardToken.sol

pragma solidity 0.6.12;


interface INarCardToken is IERC721 {
    function mint(address to, uint256 tokenId) external returns (bool) ;
    function burn(uint256 tokenId) external;
}

// File: contracts/libraries/Math.sol

pragma solidity 0.6.12;

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

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

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

// File: contracts/interfaces/Governance.sol

pragma solidity 0.6.12;

contract Governance {

    address public _governance;

    constructor() public {
        _governance = tx.origin;
    }

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

    modifier onlyGovernance {
        require(msg.sender == _governance, "not governance");
        _;
    }

    function setGovernance(address governance)  public  onlyGovernance
    {
        require(governance != address(0), "new governance the zero address");
        emit GovernanceTransferred(_governance, governance);
        _governance = governance;
    }


}

// File: contracts/interfaces/IPool.sol

pragma solidity 0.6.12;


interface IPool {
    function totalSupply( ) external view returns (uint256);
    function balanceOf( address player ) external view returns (uint256);
}

// File: contracts/interfaces/IPowerStrategy.sol

pragma solidity 0.6.12;


interface IPowerStrategy {
    function lpIn(address sender, uint256 amount) external;
    function lpOut(address sender, uint256 amount) external;
    
    function getRule(address sender) view  external returns (uint8);
}

// File: contracts/libraries/LPTokenWrapper.sol

pragma solidity 0.6.12;






contract LPTokenWrapper is IPool, Governance{
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    IERC20 public lpToken;

    uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

    mapping(address => uint8) private _rules;
    
    address public _powerStrategy = address(0x0);

    function totalSupply() public override view returns (uint256) {
        return _totalSupply;
    }

    function setPowerStragegy(address strategy)  public onlyGovernance{
        _powerStrategy = strategy;
    }

    function balanceOf(address account) public override view returns (uint256) {
        return _balances[account];
    }

    function Rule(address account) public view returns (uint256) {
        return _rules[account];
    }

    function stake(uint256 amount) public virtual {
        
        _totalSupply = _totalSupply.add(amount);

        _balances[msg.sender] = _balances[msg.sender].add(amount);

        IPowerStrategy(_powerStrategy).lpIn(msg.sender, amount);

        _rules[msg.sender] = IPowerStrategy(_powerStrategy).getRule(msg.sender);

        lpToken.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraw(uint256 amount) public virtual{
        require(amount > 0, "amout > 0");

        _totalSupply = _totalSupply.sub(amount);

        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        
        IPowerStrategy(_powerStrategy).lpOut(msg.sender, amount);

        _rules[msg.sender] = IPowerStrategy(_powerStrategy).getRule(msg.sender);

        lpToken.safeTransfer( msg.sender, amount);
    }
}

// File: contracts/NarwhalRewardV2.sol

pragma solidity 0.6.12;









contract NarwhalRewardV2 is LPTokenWrapper{
    using SafeERC20 for IERC20;

    IERC20 public nar;
    IERC20 public rnlp;
    INarCardFactory public _narcardFactory = INarCardFactory(0x0);
    INarCardToken public _narcardToken = INarCardToken(0x0);

    address public teamWallet;
    address public burnPool = 0x7777777777777777777777777777777777777777;

    uint256 public constant DURATION = 7 days;

    uint256 public _initReward = 2100000 * 1e18;
    uint256 public _startTime =  now + 365 days;
    uint256 public _periodFinish = 0;
    uint256 public _rewardRate = 0;
    uint256 public _lastUpdateTime;
    uint256 public _rewardPerTokenStored;

    uint256[3] public _maxBuffRate = [9000, 15000, 3000];
    uint256 public _growthBuffRate = 50;

    uint256 public _teamRewardRate = 1000;
    uint256 public _baseRate = 10000;

    struct UserInfo {
        uint256 userRewardPerTokenPaid; 
        uint256 rewards; 
        uint256 currentBuffrate;
        uint256 currentPower;
        uint256 timeStamp;
    }

    mapping(address => UserInfo) public userInfo;

    mapping(address => uint256) public reportTime;
    
    uint256 public _initBuffrate = 2000;

    uint256 public _totalPower = 0;

    struct CardInfo {
        uint256 tokenIndex;
        uint256 powers;
        uint256 timeStamp;
    }

    // types 1 for increase init buffrate
    // types 2 for increase growth rate
    mapping(address => mapping(uint8 => CardInfo)) public rune; 

    bool public _hasStart = false;

    bool public _emergencyStop = false;

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
    event NFTReceived(address operator, address from, uint256 tokenId, bytes data);
    event SetRune(address indexed user, uint256 amount,uint256 types , uint256 power);
    event RemoveRune(address indexed user, uint256 amount,uint256 types , uint256 power);

    
    constructor(
        address _nar,
        address _rnlp,
        address _lpToken,
        address _teamWallet
    ) public {
        nar = IERC20(_nar);
        rnlp = IERC20(_rnlp);
        lpToken = IERC20(_lpToken);
        teamWallet = _teamWallet;
    }
    
    modifier updateReward(address account) {
            _rewardPerTokenStored = rewardPerToken();
            _lastUpdateTime = lastTimeRewardApplicable();
            if (account != address(0)) {
                userInfo[account].rewards = earned(account);
                userInfo[account].userRewardPerTokenPaid = _rewardPerTokenStored;
            }
        _;
    }

    modifier checkSetNFT() {
        require(_narcardFactory != INarCardFactory(0x0) && _narcardToken != INarCardToken(0x0),"no NFT");
        _;
    }

    function setNft(INarCardToken narcardToken,INarCardFactory narcardFactory)  public onlyGovernance{
         _narcardToken = narcardToken;
         _narcardFactory = narcardFactory;
    }

    function setEmergencyStop(bool stop,uint256 rewardRate) public onlyGovernance{
        _emergencyStop = stop;
        _rewardRate = rewardRate;
    }

    function setInitBuffrate ( uint256 initBuffrate) public onlyGovernance{
        _initBuffrate = initBuffrate;
    }

    function setGrowthBuffRate( uint256 growthBuffRate) public onlyGovernance{
        _growthBuffRate = growthBuffRate;
    }

    function setTeamRewardRate( uint256 teamRewardRate ) public onlyGovernance{
        _teamRewardRate = teamRewardRate;
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, _periodFinish);
    }

    function updateBuffRate(address account) updateReward(account)  public {
        uint256 daysCalculate = (now.sub(userInfo[account].timeStamp)).div(1 days);
        
        uint256 maxBuffRate = _maxBuffRate[Rule(account)];
        
        if(daysCalculate > 0 ){
            
            _totalPower = _totalPower.sub(userInfo[account].currentPower);

            uint256 buffrate = userInfo[account].currentBuffrate;
            
            uint256 growthBuffRate = getRuneRate(account,2);

            for(uint8 i=0; i < daysCalculate; i++){  
                buffrate = buffrate.add(growthBuffRate.mul(buffrate).div(100));
                if(maxBuffRate < buffrate) {
                    buffrate = maxBuffRate;
                    break;
                }            
            }

            userInfo[account].currentBuffrate = buffrate;
            userInfo[account].currentPower = buffrate.mul(balanceOf(account));
            userInfo[account].timeStamp = userInfo[account].timeStamp.add(daysCalculate.mul(1 days));
            
            _totalPower = _totalPower.add(userInfo[account].currentPower);
        }     
    } 

    function buffRateReporter(address account) updateReward(account)  public {
        require(msg.sender != account ,"!your account");
        uint256 maxBuffRate = _maxBuffRate[Rule(account)];
        uint256 maxReporter = _maxBuffRate[Rule(msg.sender)];

        if( maxBuffRate < userInfo[account].currentBuffrate  ){

            uint256 prize = userInfo[msg.sender].currentBuffrate.mul(110).div(100);
            if(maxReporter < prize &&  (now.sub(reportTime[msg.sender])).div(12 hours) > 0){
                _totalPower = _totalPower.sub(userInfo[msg.sender].currentPower);
                userInfo[msg.sender].currentBuffrate = prize;
                userInfo[msg.sender].currentPower =  prize.mul(balanceOf(msg.sender));
                reportTime[msg.sender] = now;
                _totalPower = _totalPower.add(userInfo[msg.sender].currentPower);
            }

            _totalPower = _totalPower.sub(userInfo[account].currentPower);
            userInfo[account].currentBuffrate = maxBuffRate.mul(90).div(100);
            userInfo[account].currentPower =  userInfo[account].currentBuffrate.mul(balanceOf(account));
            userInfo[account].timeStamp = now.sub(12 hours);
            _totalPower = _totalPower.add(userInfo[account].currentPower);
        }

    }

    function rewardPerToken() public view returns (uint256) {
        if (_totalPower == 0) {
            return _rewardPerTokenStored;
        }
        return
            _rewardPerTokenStored.add(
                lastTimeRewardApplicable()
                    .sub(_lastUpdateTime)
                    .mul(_rewardRate)
                    .mul(1e18)
                    .div(_totalPower.div(1e3))
                    
            );
    }

    function seize(IERC20 token, uint256 amount) external onlyGovernance{
        require(token != lpToken, "stake");
        token.safeTransfer(_governance, amount);
    }

    function earned(address account) public view returns (uint256) {
        return
            getPower(account)
                .mul(rewardPerToken().sub(userInfo[account].userRewardPerTokenPaid))
                .div(1e21)
                .add(userInfo[account].rewards);
    }

    function getPower(address account) public view returns (uint256){
         return userInfo[account].currentPower;
    }

    function setRune(uint256 nftId) checkSetNFT checkStart public
    {
        uint8 types;
        uint256 power;
        (types,power) = _narcardFactory.getNarCard(nftId);
        
        if(rune[msg.sender][types].tokenIndex != 0){
            _narcardToken.safeTransferFrom(address(this), msg.sender, rune[msg.sender][types].tokenIndex);
        }

        rune[msg.sender][types].tokenIndex = nftId;
        rune[msg.sender][types].powers = power;
        rune[msg.sender][types].timeStamp = now;

        _narcardToken.safeTransferFrom(msg.sender, address(this), nftId);

        emit SetRune(msg.sender, nftId , types , power);
    }

    function removeRune(uint256 nftId) checkSetNFT checkStart public {

        uint8 types;
        uint256 power;
        (types,power) = _narcardFactory.getNarCard(nftId);

        rune[msg.sender][types].tokenIndex = 0;
        rune[msg.sender][types].powers = 0;
        rune[msg.sender][types].timeStamp = 0;

        _narcardToken.safeTransferFrom(address(this), msg.sender, nftId);

         emit RemoveRune(msg.sender, nftId , types , power);
    }

    // stake visibility is public as overriding LPTokenWrapper's stake() function
    function stake(uint256 amount)
        public
        override
        updateReward(msg.sender)
        checkHalve
        checkStart
    {
        require(amount > 0, "Cannot stake 0");
        
        uint256 oldBalance = balanceOf(msg.sender);

        super.stake(amount);
        
        rnlp.mint(msg.sender,amount);
        
        uint256 initBuffRate = getRuneRate(msg.sender,1);

        if(oldBalance == 0){
            uint256 power =  amount.mul(initBuffRate);

            _setUserInfo(msg.sender,now,initBuffRate);

            _totalPower = _totalPower.add(power);
        }
        else{
            _totalPower = _totalPower.sub(userInfo[msg.sender].currentPower);
            uint256 averageBuffRate = (userInfo[msg.sender].currentBuffrate.mul(oldBalance)).add((amount).mul(initBuffRate));
            uint256 newBuffRate = averageBuffRate.div(balanceOf(msg.sender));

            _setUserInfo(msg.sender,now,newBuffRate);

            _totalPower = _totalPower.add(userInfo[msg.sender].currentPower);
        }
                            
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount)
        public
        override
        updateReward(msg.sender)
        checkHalve
        checkStart
    {
        require(amount > 0, "Cannot withdraw 0");

        require(rnlp.balanceOf(msg.sender) >= amount);
        
        super.withdraw(amount);
        
        rnlp.safeTransferFrom(msg.sender, burnPool, amount);

        // reset buffrate start time to now 
        _totalPower = _totalPower.sub(userInfo[msg.sender].currentPower);
       
        uint256 initBuffRate = getRuneRate(msg.sender,1);

        _setUserInfo(msg.sender,now,initBuffRate);
        
        _totalPower = _totalPower.add(userInfo[msg.sender].currentPower);

        emit Withdrawn(msg.sender, amount);
    }

    function _setUserInfo(address account,uint256 timestamp ,uint256 buffrate) internal{
        userInfo[account].timeStamp = timestamp;
        userInfo[account].currentBuffrate = buffrate;
        userInfo[account].currentPower = balanceOf(msg.sender).mul(buffrate);
    }

    function exit(uint256 amount) external {
        withdraw(amount);
        getReward();
    }

    function emergencyWithdraw() external {
        withdraw(balanceOf(msg.sender));
    }

    function getPowerOfRune(address account,uint8 types) view public returns (uint256){
        if(rune[account][types].tokenIndex > 0 && now.sub(rune[account][types].timeStamp).div(1 days) > 0){
            return rune[account][types].powers;
        }
        return 0;
    }

    // types 1
    function getRuneRate(address account,uint8 types) view public returns (uint256){
        uint256 runeRate = _initBuffrate;
        if(types == 2){
            runeRate = _growthBuffRate;
        }
        if(_narcardFactory != INarCardFactory(0x0) && _narcardToken != INarCardToken(0x0)){
                uint256 runePower= getPowerOfRune(account,types);
                if(runePower > 0){
                    runeRate = runePower;
                }
        }
        return runeRate;
    }

    function getReward() public updateReward(msg.sender) checkHalve checkStart {
        require(_emergencyStop != true, "reward has stopped");
        uint256 reward = earned(msg.sender);
        if (reward > 0 ) {
            
            userInfo[msg.sender].rewards  = 0;
            
            uint256 teamReward = reward.mul(_teamRewardRate).div(_baseRate);
            
            if(teamReward>0){
                nar.safeTransfer(teamWallet, teamReward);
            }

            uint256 leftReward = reward.sub(teamReward);

            if(leftReward>0){
                nar.safeTransfer(msg.sender, leftReward );
            }
            // reset buffrate start time to now 
            _totalPower = _totalPower.sub(userInfo[msg.sender].currentPower);

             uint256 initBuffRate = getRuneRate(msg.sender,1);
            
             _setUserInfo(msg.sender,now,initBuffRate);
            
            _totalPower = _totalPower.add(userInfo[msg.sender].currentPower);
            
            emit RewardPaid(msg.sender, reward);
        }
    }

    modifier checkHalve() {
        if (block.timestamp >= _periodFinish) {

            _initReward = _initReward.mul(50).div(100);

            nar.mint(address(this), _initReward);

            _rewardRate = _initReward.div(DURATION);
            _periodFinish = block.timestamp.add(DURATION);

            emit RewardAdded(_initReward);
        }
        _;
    }
       
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) public returns (bytes4) {
        if(_hasStart == false) {
            return 0;
        }

        emit NFTReceived(operator, from, tokenId, data);
        return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
    }

    modifier checkStart() {
        require(block.timestamp > _startTime, "not start");
        _;
    }

    // set fix time to start reward
    function startReward(uint256 startTime) external onlyGovernance updateReward(address(0)) {
        require(_hasStart == false, "has started");
        _hasStart = true;
        
        _startTime = startTime;

        _rewardRate = _initReward.div(DURATION); 
        nar.mint(address(this), _initReward);

        _lastUpdateTime = _startTime;
        _periodFinish = _startTime.add(DURATION);

        emit RewardAdded(_initReward);
    }

    //for extra reward
    function notifyRewardAmount(uint256 reward) external onlyGovernance updateReward(address(0)) {
        IERC20(nar).safeTransferFrom(msg.sender, address(this), reward);
        if (block.timestamp >= _periodFinish) {
            _rewardRate = reward.div(DURATION);
        } else {
            uint256 remaining = _periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(_rewardRate);
            _rewardRate = reward.add(leftover).div(DURATION);
        }
        _lastUpdateTime = block.timestamp;
        _periodFinish = block.timestamp.add(DURATION);
        emit RewardAdded(reward);
    }
}

[{"inputs":[{"internalType":"address","name":"_nar","type":"address"},{"internalType":"address","name":"_rnlp","type":"address"},{"internalType":"address","name":"_lpToken","type":"address"},{"internalType":"address","name":"_teamWallet","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"GovernanceTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"NFTReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"types","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"power","type":"uint256"}],"name":"RemoveRune","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"types","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"power","type":"uint256"}],"name":"SetRune","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"Rule","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_baseRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_emergencyStop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_growthBuffRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_hasStart","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_initBuffrate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_initReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_maxBuffRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_narcardFactory","outputs":[{"internalType":"contract INarCardFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_narcardToken","outputs":[{"internalType":"contract INarCardToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_powerStrategy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_teamRewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_totalPower","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"buffRateReporter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getPower","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint8","name":"types","type":"uint8"}],"name":"getPowerOfRune","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint8","name":"types","type":"uint8"}],"name":"getRuneRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nar","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"nftId","type":"uint256"}],"name":"removeRune","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"reportTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rnlp","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint8","name":"","type":"uint8"}],"name":"rune","outputs":[{"internalType":"uint256","name":"tokenIndex","type":"uint256"},{"internalType":"uint256","name":"powers","type":"uint256"},{"internalType":"uint256","name":"timeStamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"seize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"stop","type":"bool"},{"internalType":"uint256","name":"rewardRate","type":"uint256"}],"name":"setEmergencyStop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"growthBuffRate","type":"uint256"}],"name":"setGrowthBuffRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"initBuffrate","type":"uint256"}],"name":"setInitBuffrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract INarCardToken","name":"narcardToken","type":"address"},{"internalType":"contract INarCardFactory","name":"narcardFactory","type":"address"}],"name":"setNft","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"strategy","type":"address"}],"name":"setPowerStragegy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"nftId","type":"uint256"}],"name":"setRune","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"teamRewardRate","type":"uint256"}],"name":"setTeamRewardRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"startReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"teamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"updateBuffRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"userRewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"},{"internalType":"uint256","name":"currentBuffrate","type":"uint256"},{"internalType":"uint256","name":"currentPower","type":"uint256"},{"internalType":"uint256","name":"timeStamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000a1303e6199b319a891b79685f0537d289af1fc830000000000000000000000006451571cb5bee9fd575ad98506e96f3d09c66f91000000000000000000000000b6b0ba4e208ab93602be7a81f1400a7c7daad1f2000000000000000000000000507bdd06aca5facd19aa4b77037d3b9d48be2fb9

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000a1303e6199b319a891b79685f0537d289af1fc83
Arg [1] : 0000000000000000000000006451571cb5bee9fd575ad98506e96f3d09c66f91
Arg [2] : 000000000000000000000000b6b0ba4e208ab93602be7a81f1400a7c7daad1f2
Arg [3] : 000000000000000000000000507bdd06aca5facd19aa4b77037d3b9d48be2fb9

36075:14887:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43003:282;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;37531:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39607:125;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36712:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36599:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49348:340;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;34668:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;37139:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36449:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;33109:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;35021:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;38993:189;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37250:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47041:278;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45794:756;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36208:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;50330:629;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47853:1096;;;:::i;:::-;;39350:117;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36183:18;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;36816:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47343:502;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36340:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;43293:121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;37294:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43422:655;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;34443:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;36757:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;37637:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;36638:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36675;;;:::i;:::-;;;;;;;;;;;;;;;;;;;34894:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46841:96;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39740:132;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36159:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;44085:466;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36904:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36372:68;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;44642:1144;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;34776:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;33423:256;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37192:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39880:1165;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;49844:454;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42365:451;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36276:55;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;46945:88;;;:::i;:::-;;41054:1303;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37599:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;39475:124;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42824:171;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36860:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;34615:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;39190:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36549:43;;;:::i;:::-;;;;;;;;;;;;;;;;;;;36499;;;:::i;:::-;;;;;;;;;;;;;;;;;;;43003:282;43057:7;43097:180;43251:8;:17;43260:7;43251:17;;;;;;;;;;;;;;;:25;;;43097:131;43223:4;43097:103;43137:62;43158:8;:17;43167:7;43158:17;;;;;;;;;;;;;;;:40;;;43137:16;:14;:16::i;:::-;:20;;:62;;;;:::i;:::-;43097:17;43106:7;43097:8;:17::i;:::-;:39;;:103;;;;:::i;:::-;:125;;:131;;;;:::i;:::-;:153;;:180;;;;:::i;:::-;43077:200;;43003:282;;;:::o;37531:58::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;39607:125::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39710:14:::1;39692:15;:32;;;;39607:125:::0;:::o;36712:36::-;;;;:::o;36599:32::-;;;;:::o;49348:340::-;49458:6;49493:5;49480:18;;:9;;;;;;;;;;;:18;;;49477:58;;;49522:1;49515:8;;;;;;49477:58;49552:42;49564:8;49574:4;49580:7;49589:4;49552:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49619:60;49605:75;;49348:340;;;;;;;:::o;34668:100::-;34721:7;34748:12;;34741:19;;34668:100;:::o;37139:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;36449:41::-;36484:6;36449:41;:::o;33109:26::-;;;;;;;;;;;;:::o;35021:102::-;35073:7;35100:6;:15;35107:7;35100:15;;;;;;;;;;;;;;;;;;;;;;;;;35093:22;;;;35021:102;;;:::o;38993:189::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39118:12:::1;39102:13;;:28;;;;;;;;;;;;;;;;;;39160:14;39142:15;;:32;;;;;;;;;;;;;;;;;;38993:189:::0;;:::o;37250:35::-;;;;:::o;47041:278::-;47115:7;47171:1;47137:4;:13;47142:7;47137:13;;;;;;;;;;;;;;;:20;47151:5;47137:20;;;;;;;;;;;;;;;:31;;;:35;:94;;;;;47230:1;47176:51;47220:6;47176:39;47184:4;:13;47189:7;47184:13;;;;;;;;;;;;;;;:20;47198:5;47184:20;;;;;;;;;;;;;;;:30;;;47176:3;:7;;:39;;;;:::i;:::-;:43;;:51;;;;:::i;:::-;:55;47137:94;47134:159;;;47254:4;:13;47259:7;47254:13;;;;;;;;;;;;;;;:20;47268:5;47254:20;;;;;;;;;;;;;;;:27;;;47247:34;;;;47134:159;47310:1;47303:8;;47041:278;;;;;:::o;45794:756::-;45884:10;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;49013:13:::1;;48994:15;:32;48990:324;;49059:28;49083:3;49059:19;49075:2;49059:11;;:15;;:19;;;;:::i;:::-;:23;;:28;;;;:::i;:::-;49045:11;:42;;;;49104:3;;;;;;;;;;;:8;;;49121:4;49128:11;;49104:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49171:25;36484:6;49171:11;;:15;;:25;;;;:::i;:::-;49157:11;:39;;;;49227:29;36484:6;49227:15;:19;;:29;;;;:::i;:::-;49211:13;:45;;;;49278:24;49290:11;;49278:24;;;;;;;;;;;;;;;;;;48990:324;49755:10:::2;;49737:15;:28;49729:50;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;45969:1:::3;45960:6;:10;45952:40;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;46043:6;46013:4;;;;;;;;;;;:14;;;46028:10;46013:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;:36;;46005:45;;;::::0;::::3;;46071:22;46086:6;46071:14;:22::i;:::-;46114:51;46136:10;46148:8;;;;;;;;;;;46158:6;46114:4;;;;;;;;;;;:21;;;;:51;;;;;;:::i;:::-;46238:50;46254:8;:20;46263:10;46254:20;;;;;;;;;;;;;;;:33;;;46238:11;;:15;;:50;;;;:::i;:::-;46224:11;:64;;;;46308:20;46331:25;46343:10;46354:1;46331:11;:25::i;:::-;46308:48;;46369:41;46382:10;46393:3;46397:12;46369;:41::i;:::-;46445:50;46461:8;:20;46470:10;46461:20;;;;;;;;;;;;;;;:33;;;46445:11;;:15;;:50;;;;:::i;:::-;46431:11;:64;;;;46523:10;46513:29;;;46535:6;46513:29;;;;;;;;;;;;;;;;;;49790:1;45794:756:::0;;:::o;36208:61::-;;;;;;;;;;;;;:::o;50330:629::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50419:1:::1;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;50434:63:::2;50463:10;50483:4;50490:6;50441:3;;;;;;;;;;;50434:28;;;;:63;;;;;;:::i;:::-;50531:13;;50512:15;:32;50508:309;;50575:20;36484:6;50575;:10;;:20;;;;:::i;:::-;50561:11;:34;;;;50508:309;;;50628:17;50648:34;50666:15;50648:13;;:17;;:34;;;;:::i;:::-;50628:54;;50697:16;50716:26;50730:11;;50716:9;:13;;:26;;;;:::i;:::-;50697:45;;50771:34;36484:6;50771:20;50782:8;50771:6;:10;;:20;;;;:::i;:::-;:24;;:34;;;;:::i;:::-;50757:11;:48;;;;50508:309;;;50845:15;50827;:33;;;;50887:29;36484:6;50887:15;:19;;:29;;;;:::i;:::-;50871:13;:45;;;;50932:19;50944:6;50932:19;;;;;;;;;;;;;;;;;;33406:1:::1;50330:629:::0;:::o;47853:1096::-;47894:10;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;49013:13:::1;;48994:15;:32;48990:324;;49059:28;49083:3;49059:19;49075:2;49059:11;;:15;;:19;;;;:::i;:::-;:23;;:28;;;;:::i;:::-;49045:11;:42;;;;49104:3;;;;;;;;;;;:8;;;49121:4;49128:11;;49104:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49171:25;36484:6;49171:11;;:15;;:25;;;;:::i;:::-;49157:11;:39;;;;49227:29;36484:6;49227:15;:19;;:29;;;;:::i;:::-;49211:13;:45;;;;49278:24;49290:11;;49278:24;;;;;;;;;;;;;;;;;;48990:324;49755:10:::2;;49737:15;:28;49729:50;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;47965:4:::3;47947:22;;:14;;;;;;;;;;;:22;;;;47939:53;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;48003:14;48020:18;48027:10;48020:6;:18::i;:::-;48003:35;;48062:1;48053:6;:10;48049:893;;;48127:1;48095:8;:20;48104:10;48095:20;;;;;;;;;;;;;;;:28;;:33;;;;48157:18;48178:42;48210:9;;48178:27;48189:15;;48178:6;:10;;:27;;;;:::i;:::-;:31;;:42;;;;:::i;:::-;48157:63;;48263:1;48252:10;:12;48249:91;;;48284:40;48301:10;;;;;;;;;;;48313;48284:3;;;;;;;;;;;:16;;;;:40;;;;;:::i;:::-;48249:91;48356:18;48377:22;48388:10;48377:6;:10;;:22;;;;:::i;:::-;48356:43;;48430:1;48419:10;:12;48416:92;;;48451:41;48468:10;48480;48451:3;;;;;;;;;;;:16;;;;:41;;;;;:::i;:::-;48416:92;48586:50;48602:8;:20;48611:10;48602:20;;;;;;;;;;;;;;;:33;;;48586:11;;:15;;:50;;;;:::i;:::-;48572:11;:64;;;;48654:20;48677:25;48689:10;48700:1;48677:11;:25::i;:::-;48654:48;;48732:41;48745:10;48756:3;48760:12;48732;:41::i;:::-;48816:50;48832:8;:20;48841:10;48832:20;;;;;;;;;;;;;;;:33;;;48816:11;;:15;;:50;;;;:::i;:::-;48802:11;:64;;;;48911:10;48900:30;;;48923:6;48900:30;;;;;;;;;;;;;;;;;;48049:893;;;;49790:1;47853:1096:::0;:::o;39350:117::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39447:12:::1;39431:13;:28;;;;39350:117:::0;:::o;36183:18::-;;;;;;;;;;;;;:::o;36816:35::-;;;;:::o;47343:502::-;47414:7;47433:16;47452:13;;47433:32;;47488:1;47479:5;:10;;;47476:67;;;47516:15;;47505:26;;47476:67;47591:3;47556:39;;:15;;;;;;;;;;;:39;;;;:78;;;;;47630:3;47599:35;;:13;;;;;;;;;;;:35;;;;47556:78;47553:259;;;47654:17;47673:29;47688:7;47696:5;47673:14;:29::i;:::-;47654:48;;47736:1;47724:9;:13;47721:80;;;47772:9;47761:20;;47721:80;47553:259;;47829:8;47822:15;;;47343:502;;;;:::o;36340:25::-;;;;;;;;;;;;;:::o;43293:121::-;43349:7;43376:8;:17;43385:7;43376:17;;;;;;;;;;;;;;;:30;;;43369:37;;43293:121;;;:::o;37294:30::-;;;;:::o;43422:655::-;38912:3;38877:39;;:15;;;;;;;;;;;:39;;;;:78;;;;;38951:3;38920:35;;:13;;;;;;;;;;;:35;;;;38877:78;38869:96;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49755:10:::1;;49737:15;:28;49729:50;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;43500:11:::2;43522:13:::0;43562:15:::2;;;;;;;;;;;:26;;;43589:5;43562:33;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;43546:49;;;;;;;;43657:1;43619:4;:16;43624:10;43619:16;;;;;;;;;;;;;;;:23;43636:5;43619:23;;;;;;;;;;;;;;;:34;;;:39;43616:163;;43674:13;;;;;;;;;;;:30;;;43713:4;43720:10;43732:4;:16;43737:10;43732:16;;;;;;;;;;;;;;;:23;43749:5;43732:23;;;;;;;;;;;;;;;:34;;;43674:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;43616:163;43828:5;43791:4;:16;43796:10;43791:16;;;;;;;;;;;;;;;:23;43808:5;43791:23;;;;;;;;;;;;;;;:34;;:42;;;;43877:5;43844:4;:16;43849:10;43844:16;;;;;;;;;;;;;;;:23;43861:5;43844:23;;;;;;;;;;;;;;;:30;;:38;;;;43929:3;43893:4;:16;43898:10;43893:16;;;;;;;;;;;;;;;:23;43910:5;43893:23;;;;;;;;;;;;;;;:33;;:39;;;;43945:13;;;;;;;;;;;:30;;;43976:10;43996:4;44003:5;43945:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;44035:10;44027:42;;;44047:5;44055;44063;44027:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49790:1;;43422:655:::0;:::o;34443:21::-;;;;;;;;;;;;;:::o;36757:52::-;;;;;;;;;;;;;;;;;;:::o;37637:34::-;;;;;;;;;;;;;:::o;36638:30::-;;;;:::o;36675:::-;;;;:::o;34894:119::-;34960:7;34987:9;:18;34997:7;34987:18;;;;;;;;;;;;;;;;34980:25;;34894:119;;;:::o;46841:96::-;46891:16;46900:6;46891:8;:16::i;:::-;46918:11;:9;:11::i;:::-;46841:96;:::o;39740:132::-;39797:7;39824:40;39833:15;39850:13;;39824:8;:40::i;:::-;39817:47;;39740:132;:::o;36159:17::-;;;;;;;;;;;;;:::o;44085:466::-;38912:3;38877:39;;:15;;;;;;;;;;;:39;;;;:78;;;;;38951:3;38920:35;;:13;;;;;;;;;;;:35;;;;38877:78;38869:96;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49755:10:::1;;49737:15;:28;49729:50;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;44163:11:::2;44185:13:::0;44225:15:::2;;;;;;;;;;;:26;;;44252:5;44225:33;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;44209:49;;;;;;;;44308:1;44271:4;:16;44276:10;44271:16;;;;;;;;;;;;;;;:23;44288:5;44271:23;;;;;;;;;;;;;;;:34;;:38;;;;44353:1;44320:4;:16;44325:10;44320:16;;;;;;;;;;;;;;;:23;44337:5;44320:23;;;;;;;;;;;;;;;:30;;:34;;;;44401:1;44365:4;:16;44370:10;44365:16;;;;;;;;;;;;;;;:23;44382:5;44365:23;;;;;;;;;;;;;;;:33;;:37;;;;44415:13;;;;;;;;;;;:30;;;44454:4;44461:10;44473:5;44415:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;44509:10;44498:45;;;44521:5;44529;44537;44498:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49790:1;;44085:466:::0;:::o;36904:32::-;;;;:::o;36372:68::-;;;;;;;;;;;;;:::o;44642:1144::-;44729:10;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;49013:13:::1;;48994:15;:32;48990:324;;49059:28;49083:3;49059:19;49075:2;49059:11;;:15;;:19;;;;:::i;:::-;:23;;:28;;;;:::i;:::-;49045:11;:42;;;;49104:3;;;;;;;;;;;:8;;;49121:4;49128:11;;49104:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49171:25;36484:6;49171:11;;:15;;:25;;;;:::i;:::-;49157:11;:39;;;;49227:29;36484:6;49227:15;:19;;:29;;;;:::i;:::-;49211:13;:45;;;;49278:24;49290:11;;49278:24;;;;;;;;;;;;;;;;;;48990:324;49755:10:::2;;49737:15;:28;49729:50;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;44814:1:::3;44805:6;:10;44797:37;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;44855:18;44876:21;44886:10;44876:9;:21::i;:::-;44855:42;;44910:19;44922:6;44910:11;:19::i;:::-;44950:4;;;;;;;;;;;:9;;;44960:10;44971:6;44950:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;44999:20;45022:25;45034:10;45045:1;45022:11;:25::i;:::-;44999:48;;45077:1;45063:10;:15;45060:647;;;45094:13;45111:24;45122:12;45111:6;:10;;:24;;;;:::i;:::-;45094:41;;45152;45165:10;45176:3;45180:12;45152;:41::i;:::-;45224:22;45240:5;45224:11;;:15;;:22;;;;:::i;:::-;45210:11;:36;;;;45060:647;;;;45301:50;45317:8;:20;45326:10;45317:20;;;;;;;;;;;;;;;:33;;;45301:11;;:15;;:50;;;;:::i;:::-;45287:11;:64;;;;45366:23;45392:86;45451:26;45464:12;45452:6;45451:12;;:26;;;;:::i;:::-;45393:52;45434:10;45393:8;:20;45402:10;45393:20;;;;;;;;;;;;;;;:36;;;:40;;:52;;;;:::i;:::-;45392:58;;:86;;;;:::i;:::-;45366:112;;45493:19;45515:42;45535:21;45545:10;45535:9;:21::i;:::-;45515:15;:19;;:42;;;;:::i;:::-;45493:64;;45574:40;45587:10;45598:3;45602:11;45574:12;:40::i;:::-;45645:50;45661:8;:20;45670:10;45661:20;;;;;;;;;;;;;;;:33;;;45645:11;;:15;;:50;;;;:::i;:::-;45631:11;:64;;;;45060:647;;;45759:10;45752:26;;;45771:6;45752:26;;;;;;;;;;;;;;;;;;49790:1;;44642:1144:::0;;:::o;34776:110::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34870:8:::1;34853:14;;:25;;;;;;;;;;;;;;;;;;34776:110:::0;:::o;33423:256::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33536:1:::1;33514:24;;:10;:24;;;;33506:68;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;33625:10;33590:46;;33612:11;::::0;::::1;;;;;;;;33590:46;;;;;;;;;;;;33661:10;33647:11;::::0;:24:::1;;;;;;;;;;;;;;;;;;33423:256:::0;:::o;37192:45::-;;;;;;;;;;;;;;;;;:::o;39880:1165::-;39934:7;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;39962:21:::1;39986:50;40029:6;39987:36;39995:8;:17;40004:7;39995:17;;;;;;;;;;;;;;;:27;;;39987:3;:7;;:36;;;;:::i;:::-;39986:42;;:50;;;;:::i;:::-;39962:74;;40057:19;40079:12;40092:13;40097:7;40092:4;:13::i;:::-;40079:27;;;;;;;;;40057:49;;40146:1;40130:13;:17;40127:906;;;40192:47;40208:8;:17;40217:7;40208:17;;;;;;;;;;;;;;;:30;;;40192:11;;:15;;:47;;;;:::i;:::-;40178:11;:61;;;;40256:16;40275:8;:17;40284:7;40275:17;;;;;;;;;;;;;;;:33;;;40256:52;;40337:22;40362;40374:7;40382:1;40362:11;:22::i;:::-;40337:47;;40405:7;40401:287;40420:13;40416:1;:17;;;40401:287;;;40471:51;40484:37;40517:3;40484:28;40503:8;40484:14;:18;;:28;;;;:::i;:::-;:32;;:37;;;;:::i;:::-;40471:8;:12;;:51;;;;:::i;:::-;40460:62;;40558:8;40544:11;:22;40541:120;;;40602:11;40591:22;;40636:5;;40541:120;40435:3;;;;;;;40401:287;;;;40740:8;40704;:17;40713:7;40704:17;;;;;;;;;;;;;;;:33;;:44;;;;40796:32;40809:18;40819:7;40809:9;:18::i;:::-;40796:8;:12;;:32;;;;:::i;:::-;40763:8;:17;40772:7;40763:17;;;;;;;;;;;;;;;:30;;:65;;;;40873:58;40905:25;40923:6;40905:13;:17;;:25;;;;:::i;:::-;40873:8;:17;40882:7;40873:17;;;;;;;;;;;;;;;:27;;;:31;;:58;;;;:::i;:::-;40843:8;:17;40852:7;40843:17;;;;;;;;;;;;;;;:27;;:88;;;;40974:47;40990:8;:17;40999:7;40990:17;;;;;;;;;;;;;;;:30;;;40974:11;;:15;;:47;;;;:::i;:::-;40960:11;:61;;;;40127:906;;;38818:1;;39880:1165:::0;;:::o;49844:454::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49929:1:::1;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;49965:5:::2;49952:18;;:9;;;;;;;;;;;:18;;;49944:42;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;50009:4;49997:9;;:16;;;;;;;;;;;;;;;;;;50047:9;50034:10;:22;;;;50083:25;36484:6;50083:11;;:15;;:25;;;;:::i;:::-;50069:11;:39;;;;50120:3;;;;;;;;;;;:8;;;50137:4;50144:11;;50120:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;50187:10;;50169:15;:28;;;;50224:24;36484:6;50224:10;;:14;;:24;;;;:::i;:::-;50208:13;:40;;;;50266:24;50278:11;;50266:24;;;;;;;;;;;;;;;;;;33406:1:::1;49844:454:::0;:::o;42365:451::-;42412:7;42451:1;42436:11;;:16;42432:77;;;42476:21;;42469:28;;;;42432:77;42539:269;42583:188;42750:20;42766:3;42750:11;;:15;;:20;;;;:::i;:::-;42583:140;42718:4;42583:108;42679:11;;42583:69;42636:15;;42583:26;:24;:26::i;:::-;:52;;:69;;;;:::i;:::-;:95;;:108;;;;:::i;:::-;:134;;:140;;;;:::i;:::-;:166;;:188;;;;:::i;:::-;42539:21;;:25;;:269;;;;:::i;:::-;42519:289;;42365:451;;:::o;36276:55::-;;;;;;;;;;;;;:::o;46945:88::-;46994:31;47003:21;47013:10;47003:9;:21::i;:::-;46994:8;:31::i;:::-;46945:88::o;41054:1303::-;41110:7;38530:16;:14;:16::i;:::-;38506:21;:40;;;;38579:26;:24;:26::i;:::-;38561:15;:44;;;;38643:1;38624:21;;:7;:21;;;38620:188;;38694:15;38701:7;38694:6;:15::i;:::-;38666:8;:17;38675:7;38666:17;;;;;;;;;;;;;;;:25;;:43;;;;38771:21;;38728:8;:17;38737:7;38728:17;;;;;;;;;;;;;;;:40;;:64;;;;38620:188;41160:7:::1;41146:21;;:10;:21;;;;41138:47;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;41196:19;41218:12;41231:13;41236:7;41231:4;:13::i;:::-;41218:27;;;;;;;;;41196:49;;41256:19;41278:12;41291:16;41296:10;41291:4;:16::i;:::-;41278:30;;;;;;;;;41256:52;;41339:8;:17;41348:7;41339:17;;;;;;;;;;;;;;;:33;;;41325:11;:47;41321:1027;;;41392:13;41408:54;41458:3;41408:45;41449:3;41408:8;:20;41417:10;41408:20;;;;;;;;;;;;;;;:36;;;:40;;:45;;;;:::i;:::-;:49;;:54;;;;:::i;:::-;41392:70;;41494:5;41480:11;:19;:75;;;;;41554:1;41504:47;41542:8;41505:31;41513:10;:22;41524:10;41513:22;;;;;;;;;;;;;;;;41505:3;:7;;:31;;;;:::i;:::-;41504:37;;:47;;;;:::i;:::-;:51;41480:75;41477:459;;;41589:50;41605:8;:20;41614:10;41605:20;;;;;;;;;;;;;;;:33;;;41589:11;;:15;;:50;;;;:::i;:::-;41575:11;:64;;;;41697:5;41658:8;:20;41667:10;41658:20;;;;;;;;;;;;;;;:36;;:44;;;;41758:32;41768:21;41778:10;41768:9;:21::i;:::-;41758:5;:9;;:32;;;;:::i;:::-;41721:8;:20;41730:10;41721:20;;;;;;;;;;;;;;;:33;;:69;;;;41834:3;41809:10;:22;41820:10;41809:22;;;;;;;;;;;;;;;:28;;;;41870:50;41886:8;:20;41895:10;41886:20;;;;;;;;;;;;;;;:33;;;41870:11;;:15;;:50;;;;:::i;:::-;41856:11;:64;;;;41477:459;41966:47;41982:8;:17;41991:7;41982:17;;;;;;;;;;;;;;;:30;;;41966:11;;:15;;:47;;;;:::i;:::-;41952:11;:61;;;;42064:28;42088:3;42064:19;42080:2;42064:11;:15;;:19;;;;:::i;:::-;:23;;:28;;;;:::i;:::-;42028:8;:17;42037:7;42028:17;;;;;;;;;;;;;;;:33;;:64;;;;42141:57;42179:18;42189:7;42179:9;:18::i;:::-;42141:8;:17;42150:7;42141:17;;;;;;;;;;;;;;;:33;;;:37;;:57;;;;:::i;:::-;42107:8;:17;42116:7;42107:17;;;;;;;;;;;;;;;:30;;:91;;;;42243:17;42251:8;42243:3;:7;;:17;;;;:::i;:::-;42213:8;:17;42222:7;42213:17;;;;;;;;;;;;;;;:27;;:47;;;;42289;42305:8;:17;42314:7;42305:17;;;;;;;;;;;;;;;:30;;;42289:11;;:15;;:47;;;;:::i;:::-;42275:11;:61;;;;41321:1027;;38818:1;;41054:1303:::0;;:::o;37599:29::-;;;;;;;;;;;;;:::o;39475:124::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39577:14:::1;39559:15;:32;;;;39475:124:::0;:::o;42824:171::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42920:7:::1;;;;;;;;;;;42911:16;;:5;:16;;;;42903:34;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;42948:39;42967:11;::::0;::::1;;;;;;;;42980:6;42948:5;:18;;;;:39;;;;;:::i;:::-;42824:171:::0;;:::o;36860:37::-;;;;:::o;34615:44::-;;;;;;;;;;;;;:::o;39190:152::-;33365:11;;;;;;;;;;33351:25;;:10;:25;;;33343:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39295:4:::1;39278:14;;:21;;;;;;;;;;;;;;;;;;39324:10;39310:11;:24;;;;39190:152:::0;;:::o;36549:43::-;;;;:::o;36499:::-;;;;:::o;4280:136::-;4338:7;4365:43;4369:1;4372;4365:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4358:50;;4280:136;;;;:::o;5170:471::-;5228:7;5478:1;5473;:6;5469:47;;;5503:1;5496:8;;;;5469:47;5528:9;5544:1;5540;:5;5528:17;;5573:1;5568;5564;:5;;;;;;:10;5556:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5632:1;5625:8;;;5170:471;;;;;:::o;6117:132::-;6175:7;6202:39;6206:1;6209;6202:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;6195:46;;6117:132;;;;:::o;3816:181::-;3874:7;3894:9;3910:1;3906;:5;3894:17;;3935:1;3930;:6;;3922:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3988:1;3981:8;;;3816:181;;;;:::o;35547:436::-;35623:1;35614:6;:10;35606:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35666:24;35683:6;35666:12;;:16;;:24;;;;:::i;:::-;35651:12;:39;;;;35727:33;35753:6;35727:9;:21;35737:10;35727:21;;;;;;;;;;;;;;;;:25;;:33;;;;:::i;:::-;35703:9;:21;35713:10;35703:21;;;;;;;;;;;;;;;:57;;;;35796:14;;;;;;;;;;;35781:36;;;35818:10;35830:6;35781:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35886:14;;;;;;;;;;;35871:38;;;35910:10;35871:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35850:6;:18;35857:10;35850:18;;;;;;;;;;;;;;;;:71;;;;;;;;;;;;;;;;;;35934:41;35956:10;35968:6;35934:7;;;;;;;;;;;:20;;;;:41;;;;;:::i;:::-;35547:436;:::o;15166:205::-;15267:96;15287:5;15317:27;;;15346:4;15352:2;15356:5;15294:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15267:19;:96::i;:::-;15166:205;;;;:::o;46558:275::-;46682:9;46652:8;:17;46661:7;46652:17;;;;;;;;;;;;;;;:27;;:39;;;;46738:8;46702;:17;46711:7;46702:17;;;;;;;;;;;;;;;:33;;:44;;;;46790:35;46816:8;46790:21;46800:10;46790:9;:21::i;:::-;:25;;:35;;;;:::i;:::-;46757:8;:17;46766:7;46757:17;;;;;;;;;;;;;;;:30;;:68;;;;46558:275;;;:::o;14981:177::-;15064:86;15084:5;15114:23;;;15139:2;15143:5;15091:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15064:19;:86::i;:::-;14981:177;;;:::o;32580:106::-;32638:7;32669:1;32665;:5;:13;;32677:1;32665:13;;;32673:1;32665:13;32658:20;;32580:106;;;;:::o;35131:408::-;35213:24;35230:6;35213:12;;:16;;:24;;;;:::i;:::-;35198:12;:39;;;;35274:33;35300:6;35274:9;:21;35284:10;35274:21;;;;;;;;;;;;;;;;:25;;:33;;;;:::i;:::-;35250:9;:21;35260:10;35250:21;;;;;;;;;;;;;;;:57;;;;35335:14;;;;;;;;;;;35320:35;;;35356:10;35368:6;35320:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35424:14;;;;;;;;;;;35409:38;;;35448:10;35409:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35388:6;:18;35395:10;35388:18;;;;;;;;;;;;;;;;:71;;;;;;;;;;;;;;;;;;35472:59;35497:10;35517:4;35524:6;35472:7;;;;;;;;;;;:24;;;;:59;;;;;;:::i;:::-;35131:408;:::o;4719:192::-;4805:7;4838:1;4833;:6;;4841:12;4825:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4865:9;4881:1;4877;:5;4865:17;;4902:1;4895:8;;;4719:192;;;;;:::o;6745:278::-;6831:7;6863:1;6859;:5;6866:12;6851:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6890:9;6906:1;6902;:5;;;;;;6890:17;;7014:1;7007:8;;;6745:278;;;;;:::o;17286:761::-;17710:23;17736:69;17764:4;17736:69;;;;;;;;;;;;;;;;;17744:5;17736:27;;;;:69;;;;;:::i;:::-;17710:95;;17840:1;17820:10;:17;:21;17816:224;;;17962:10;17951:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17943:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17816:224;17286:761;;;:::o;11960:196::-;12063:12;12095:53;12118:6;12126:4;12132:1;12135:12;12095:22;:53::i;:::-;12088:60;;11960:196;;;;;:::o;13337:979::-;13467:12;13500:18;13511:6;13500:10;:18::i;:::-;13492:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13626:12;13640:23;13667:6;:11;;13687:8;13698:4;13667:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13625:78;;;;13718:7;13714:595;;;13749:10;13742:17;;;;;;13714:595;13883:1;13863:10;:17;:21;13859:439;;;14126:10;14120:17;14187:15;14174:10;14170:2;14166:19;14159:44;14074:148;14269:12;14262:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13337:979;;;;;;;:::o;9042:422::-;9102:4;9310:12;9421:7;9409:20;9401:28;;9455:1;9448:4;:8;9441:15;;;9042:422;;;:::o

ipfs://83e0d53ebaa8fa770def555e02cbae24c4bff0ada6c45342c004692828891fbc