Contract 0xd64126eb7c597b72c26ce78925666a50d776e330

/**
 *Submitted for verification at polygonscan.com on 2023-05-25
*/

// File: contracts/Admin/data/GachaStruct.sol


pragma solidity ^0.8.18;

    enum GachaType {
        None,
        Character,
        FateCore
    }

    struct InputGachaInfo {
        uint256 tokenId;
        string name;
        uint256[] tierRatio;
        uint256[][] gachaGradeRatio;
        uint256[] gachaFateCoreRatio;
        uint256[] gachaFateCoreList;
        GachaType gachaType;
        bool isValid;
    }

    struct GachaInfo {
        uint256 tokenId;
        string name;
        uint256[] tierRatio;
        uint256[][] gachaGradeRatio;
        bool isValid;
    }

    struct FateCoreGachaInfo {
        uint256 tokenId;
        string name;
        uint256[] gachaFateCoreRatio;
        uint256[] gachaFateCoreList;
        bool isValid;
    }
// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

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 generally not needed starting with Solidity 0.8, since 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 subtraction 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: contracts/Admin/data/PeriodQuestStructV2.sol


pragma solidity ^0.8.18;

    enum CalculateType {
        NONE,
        SET,
        ADD,
        SUB
    }

    enum ConditionType {
        NONE,
        CHARACTER,
        CHARACTER_TIER,
        PACK,
        CHARACTER_ELEMENT,
        CHARACTER_NATION
    }

    enum QuestCategory {
        NONE,
        MISSION,
        REWARD
    }

    enum MissionType {
        NONE,
        BURN,
        STAKE,
        REGIST
    }

    enum TokenType {
        NONE,
        ERC20,
        ERC721,
        ERC1155
    }

    enum QuestType {
        NONE,
        MAIN,
        HIDDEN,
        DAILY,
        WEEKLY,
        PREMIUM,
        GLOBAL
    }

    enum LimitType {
        NONE,
        LIMIT,
        INFINITE
    }

    struct BurnWaitInfo {
        uint256 tokenId;
        uint256 amount;
        uint256 conditionType;
        uint256 slotNo;
    }

    struct StakeInfo {
        uint256 tokenId;
        uint256 amount;
        uint256 conditionType;
    }

    struct Quest {
        uint256 questNo;
        string name;
        uint256 requireQuest;
        uint256 questCategory;
        uint256 stakingTime;
        Reward[] rewards;
        QuestConditionSlot[] questConditionSlot;
    }

    struct Reward {
        uint256 rewardType;
        uint256 reward;
        uint256 rewardAmount;
    }

    struct QuestConditionSlot {
        uint256 questType;       // 미션 타입
        uint256 conditionType;   // 미션 조건 타입
        uint256 conditionValue;  // 미션 조건 값
        uint256 conditionAmount; // 개수
        uint256 subConditionType;
        uint256 subConditionValue;
    }

    struct PeriodQuestInfo {
        uint256 id;
        uint256 requireId;
        uint256 questType;
        uint256 questId;
        uint256 startAt;
        uint256 endAt;
        LimitType userLimitType;
        uint256 userLimit;
        LimitType limitType;
        uint256 limit;
        uint256 finishId;
        bool isValid;
    }

    struct QuestInfo {
        uint256 questNo;
        uint256 startAt;
        uint256 endAt;
        QuestSlotInfo[] slotData;
    }

    struct QuestSlotInfo {
        uint256 tokenId;
        uint256 amount;
        bool isValid;
    }

    struct Dashboard {
        uint256 id;
        uint256 clearCount;
        uint256 userClearCount;
        QuestInfo userQuestInfo;
        BurnWaitInfo[] burnInfo;
        StakeInfo[] stakeInfo;
    }

    struct RewardInfo {
        uint256 goodsType;
        uint256 tokenType;
        address tokenAddress;
        bool isValid;
    }

    struct GetQuestInfos {
        uint256 userClearCount;
        uint256 totalClearCount;
        QuestInfo userQuestInfo;
        Quest questData;
    }

    struct UserClearCount {
        uint256 id;
        uint256 clearCount;
        bool isOpen;
    }

    struct CharacterOwner {
        uint256 id;
        bool isOwner;
    }
// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

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


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

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() {
        _transferOwnership(_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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: contracts/Admin/data/ActorData.sol


pragma solidity ^0.8.18;


contract DspActorData is Ownable {
    event SetGachaTypeById(uint256 indexed id, uint256 indexed gachaType);
    event SetGachaTypeByName(string indexed name, uint256 indexed gachaType);

    struct InputGachaTypeById {
        uint256 id;
        uint256 gachaType;
    }

    struct InputGachaTypeByName {
        string name;
        uint256 gachaType;
    }

    // id => type
    mapping(uint256 => uint256) private gachaTypeById;
    // fate core id => name
    mapping(string => uint256) private gachaTypeByName;


    function getGachaTypeById(uint256 _id) public view returns(uint256) {
        return gachaTypeById[_id];
    }

    function getGachaTypeByName(string memory _name) public view returns(uint256) {
        return gachaTypeByName[_name];
    }

    function getGachaTypeByIds(uint256[] memory _ids) public view returns(uint256[] memory) {
        uint256[] memory gachaTypes = new uint256[](_ids.length);
        for (uint256 i = 0; i < _ids.length; i++) {
            gachaTypes[i] = gachaTypeById[_ids[i]];
        }
        return gachaTypes;
    }

    function getGachaTypeByNames(string[] memory _names) public view returns(uint256[] memory) {
        uint256[] memory gachaTypes = new uint256[](_names.length);
        for (uint256 i = 0; i < _names.length; i++) {
            gachaTypes[i] = gachaTypeByName[_names[i]];
        }
        return gachaTypes;
    }

    function setGachaTypeById(InputGachaTypeById memory _inputGachaTypeById) external onlyOwner {
        gachaTypeById[_inputGachaTypeById.id] = _inputGachaTypeById.gachaType;
        emit SetGachaTypeById(_inputGachaTypeById.id, _inputGachaTypeById.gachaType);
    }

    function setGachaTypeByIds(InputGachaTypeById[] memory _inputGachaTypeByIds) external onlyOwner {
        for (uint256 i = 0; i < _inputGachaTypeByIds.length; i++) {
            gachaTypeById[_inputGachaTypeByIds[i].id] = _inputGachaTypeByIds[i].gachaType;
            emit SetGachaTypeById(_inputGachaTypeByIds[i].id, _inputGachaTypeByIds[i].gachaType);
        }
    }

    function setGachaTypeByName(InputGachaTypeByName memory _inputGachaTypeByName) external onlyOwner {
        gachaTypeByName[_inputGachaTypeByName.name] = _inputGachaTypeByName.gachaType;
        emit SetGachaTypeByName(_inputGachaTypeByName.name, _inputGachaTypeByName.gachaType);
    }

    function setGachaTypeByNames(InputGachaTypeByName[] memory _inputGachaTypeByNames) external onlyOwner {
        for (uint256 i = 0; i < _inputGachaTypeByNames.length; i++) {
            gachaTypeByName[_inputGachaTypeByNames[i].name] = _inputGachaTypeByNames[i].gachaType;
            emit SetGachaTypeByName(_inputGachaTypeByNames[i].name, _inputGachaTypeByNames[i].gachaType);
        }
    }
}
// File: contracts/Admin/LuxOnService.sol


pragma solidity ^0.8.15;


contract LuxOnService is Ownable {
    mapping(address => bool) isInspection;

    event Inspection(address contractAddress, uint256 timestamp, bool live);

    function isLive(address contractAddress) public view returns (bool) {
        return !isInspection[contractAddress];
    }

    function setInspection(address[] memory contractAddresses, bool _isInspection) external onlyOwner {
        for (uint256 i = 0; i < contractAddresses.length; i++) {
            isInspection[contractAddresses[i]] = _isInspection;
            emit Inspection(contractAddresses[i], block.timestamp, _isInspection);
        }
    }
}
// File: contracts/LUXON/utils/LuxOnLive.sol


pragma solidity ^0.8.16;



contract LuxOnLive is Ownable {
    address private luxOnService;

    event SetLuxOnService(address indexed luxOnService);

    constructor(
        address _luxOnService
    ) {
        luxOnService = _luxOnService;
    }

    function getLuxOnService() public view returns (address) {
        return luxOnService;
    }

    function setLuxOnService(address _luxOnService) external onlyOwner {
        luxOnService = _luxOnService;
        emit SetLuxOnService(_luxOnService);
    }

    modifier isLive() {
        require(LuxOnService(luxOnService).isLive(address(this)), "LuxOnLive: not live");
        _;
    }
}
// File: contracts/Admin/data/QuestCalendarV2.sol


pragma solidity ^0.8.18;



contract QuestCalendar is Ownable {
    uint256 public lastId = 0;
    // id => type
    mapping(uint256 => PeriodQuestInfo) public calendars;

    function getLsatId() public view returns (uint256) {
        return lastId;
    }

    function getQuestCalendar(uint256 id) public view returns (PeriodQuestInfo memory) {
        return calendars[id];
    }

    function getQuestCalendars(uint256[] memory ids) public view returns (PeriodQuestInfo[] memory) {
        PeriodQuestInfo[] memory _calendars = new PeriodQuestInfo[](ids.length);
        for (uint256 i = 0; i < ids.length; i++) {
            _calendars[i] = calendars[ids[i]];
        }
        return _calendars;
    }

    function setQuestInfos(PeriodQuestInfo[] memory periodQuestInfos) external onlyOwner {
        for (uint256 i = 0; i < periodQuestInfos.length; i++) {
            calendars[periodQuestInfos[i].id] = periodQuestInfos[i];
            if (lastId < periodQuestInfos[i].id) {
                lastId = periodQuestInfos[i].id;
            }
        }
    }

    function setQuestInfo(PeriodQuestInfo memory periodQuestInfo) external onlyOwner {
        calendars[periodQuestInfo.id] = periodQuestInfo;
        if (lastId < periodQuestInfo.id) {
            lastId = periodQuestInfo.id;
        }
    }
}
// File: contracts/Admin/data/PeriodQuestDataV2.sol


pragma solidity ^0.8.18;



contract PeriodQuestData is Ownable {
    // quest id => quest
    mapping(uint256 => Quest) questConditionMap;

    function getQuest(uint256 questNo) public view returns (Quest memory) {
        return questConditionMap[questNo];
    }

    function getQuests(uint256[] memory questNo) public view returns (Quest[] memory) {
        Quest[] memory quests = new Quest[](questNo.length);
        for (uint256 i = 0; i < questNo.length; i++) {
            quests[i] = questConditionMap[questNo[i]];
        }
        return quests;
    }

    function setQuestDataMany(Quest[] memory _questData) external onlyOwner {
        for (uint i = 0; i < _questData.length; i++) {
            uint questNo = _questData[i].questNo;
            delete questConditionMap[questNo];
            Quest storage quest_ = questConditionMap[questNo];

            quest_.questNo = questNo;
            quest_.name = _questData[i].name;
            quest_.requireQuest = _questData[i].requireQuest;
            quest_.questCategory = _questData[i].questCategory;
            quest_.stakingTime = _questData[i].stakingTime;
            for (uint j = 0; j < _questData[i].rewards.length; j++) {
                quest_.rewards.push(
                    Reward(
                        _questData[i].rewards[j].rewardType,
                        _questData[i].rewards[j].reward,
                        _questData[i].rewards[j].rewardAmount
                    )
                );
            }

            for (uint j = 0; j < _questData[i].questConditionSlot.length; j++) {
                quest_.questConditionSlot.push(QuestConditionSlot(
                        _questData[i].questConditionSlot[j].questType,
                        _questData[i].questConditionSlot[j].conditionType,
                        _questData[i].questConditionSlot[j].conditionValue,
                        _questData[i].questConditionSlot[j].conditionAmount,
                        _questData[i].questConditionSlot[j].subConditionType,
                        _questData[i].questConditionSlot[j].subConditionValue
                    ));
            }
        }
    }

    function setQuestData(Quest memory _questData) external onlyOwner {
        delete questConditionMap[_questData.questNo];
        Quest storage quest_ = questConditionMap[_questData.questNo];

        quest_.questNo = _questData.questNo;
        quest_.name = _questData.name;
        quest_.requireQuest = _questData.requireQuest;
        quest_.questCategory = _questData.questCategory;
        quest_.stakingTime = _questData.stakingTime;

        for (uint j = 0; j < _questData.rewards.length; j++) {
            quest_.rewards.push(
                Reward(
                    _questData.rewards[j].rewardType,
                    _questData.rewards[j].reward,
                    _questData.rewards[j].rewardAmount
                )
            );
        }

        for (uint j = 0; j < _questData.questConditionSlot.length; j++) {
            quest_.questConditionSlot.push(QuestConditionSlot(
                    _questData.questConditionSlot[j].questType,
                    _questData.questConditionSlot[j].conditionType,
                    _questData.questConditionSlot[j].conditionValue,
                    _questData.questConditionSlot[j].conditionAmount,
                    _questData.questConditionSlot[j].subConditionType,
                    _questData.questConditionSlot[j].subConditionValue
                ));
        }
    }
}
// File: contracts/Admin/data/FateCoreData.sol


pragma solidity ^0.8.18;


contract DspFateCoreData is Ownable {
    event SetFateCoreData(string indexed name, uint256 indexed tier, uint256 indexed gachaGrade, uint256 classType, uint256 nation, uint256 element, bool isValid);
    event DeleteFateCoreData(string indexed name, uint256 indexed tier, uint256 indexed gachaGrade, uint256 classType, uint256 nation, uint256 element, bool isValid);
    event SetFateCoreName(uint256 indexed id, string indexed name);

    struct FateCoreInfo {
        string name;
        uint256 tier;
        uint256 gachaGrade;
        uint256 classType;
        uint256 nation;
        uint256 element;
        uint256 rootId;
        bool isValid;
    }

    struct FateCoreName {
        uint256 id;
        string name;
    }

    // fate core id => name
    mapping(uint256 => string) private fateCoreName;
    // name => fate core info
    mapping(string => FateCoreInfo) private fateCoreData;
    // tier => gacha grade => name[]
    mapping(uint256 => mapping(uint256 => string[])) private fateCoreInfoTable;

    uint256 private fateCoreCount;

    function getFateCoreInfo(string memory name) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, bool) {
        return (fateCoreData[name].tier, fateCoreData[name].gachaGrade, fateCoreData[name].classType, fateCoreData[name].nation, fateCoreData[name].element, fateCoreData[name].rootId, fateCoreData[name].isValid);
    }

    function getFateCoreInfoIsValid(string memory name) public view returns(bool) {
        return fateCoreData[name].isValid;
    }

    function getFateCoreName(uint256 id) public view returns (string memory) {
        return fateCoreName[id];
    }

    function setFateCoreName(FateCoreName[] memory _fateCoreName) external onlyOwner {
        for (uint256 i = 0; i < _fateCoreName.length; i++) {
            fateCoreName[_fateCoreName[i].id] = _fateCoreName[i].name;
            emit SetFateCoreName(_fateCoreName[i].id, _fateCoreName[i].name);
        }
    }

    function setFateCoreData(FateCoreInfo[] memory _fateCoreData) external onlyOwner {
        for (uint256 i = 0; i < _fateCoreData.length; i++) {
            require(_fateCoreData[i].isValid, "isValid false use delete");
            if (!fateCoreData[_fateCoreData[i].name].isValid) {
                fateCoreCount++;
            } else if (fateCoreData[_fateCoreData[i].name].tier != _fateCoreData[i].tier) {
                uint256 index;
                uint256 _tier = fateCoreData[_fateCoreData[i].name].tier;
                uint256 _gachaGrade = fateCoreData[_fateCoreData[i].name].gachaGrade;
                for (uint256 j = 0; j < fateCoreInfoTable[_tier][_gachaGrade].length; j++) {
                    if (keccak256(abi.encodePacked(fateCoreInfoTable[_tier][_gachaGrade][j])) == keccak256(abi.encodePacked(_fateCoreData[i].name))) {
                        index = j;
                        break;
                    }
                }
                for (uint256 j = index; j < fateCoreInfoTable[_tier][_gachaGrade].length - 1; j++) {
                    fateCoreInfoTable[_tier][_gachaGrade][j] = fateCoreInfoTable[_tier][_gachaGrade][j + 1];
                }
                fateCoreInfoTable[_tier][_gachaGrade].pop();
            }
            fateCoreInfoTable[_fateCoreData[i].tier][_fateCoreData[i].gachaGrade].push(_fateCoreData[i].name);
            fateCoreData[_fateCoreData[i].name] = _fateCoreData[i];

            emit SetFateCoreData(_fateCoreData[i].name, _fateCoreData[i].tier, _fateCoreData[i].gachaGrade, _fateCoreData[i].classType, _fateCoreData[i].nation, _fateCoreData[i].element, _fateCoreData[i].isValid);
        }
    }

    function deleteFateCoreData(string[] memory names) external onlyOwner {
        for (uint256 i = 0; i < names.length; i++) {
            uint256 _tier = fateCoreData[names[i]].tier;
            uint256 _gachaGrade = fateCoreData[names[i]].gachaGrade;

            uint256 index;
            for (uint256 j = 0; j < fateCoreInfoTable[_tier][_gachaGrade].length; j++) {
                if (keccak256(abi.encodePacked(fateCoreInfoTable[_tier][_gachaGrade][j])) == keccak256(abi.encodePacked(fateCoreData[names[i]].name))) {
                    index = j;
                    break;
                }
            }
            for (uint256 j = index; j < fateCoreInfoTable[_tier][_gachaGrade].length - 1; j++) {
                fateCoreInfoTable[_tier][_gachaGrade][j] = fateCoreInfoTable[_tier][_gachaGrade][j + 1];
            }
            fateCoreInfoTable[_tier][_gachaGrade].pop();
            fateCoreCount--;

            emit DeleteFateCoreData(fateCoreData[names[i]].name, fateCoreData[names[i]].tier, fateCoreData[names[i]].gachaGrade, fateCoreData[names[i]].classType, fateCoreData[names[i]].nation, fateCoreData[names[i]].element, fateCoreData[names[i]].isValid);
            delete fateCoreData[names[i]];
        }
    }

    function getFateCoreCount() public view returns (uint256) {
        return fateCoreCount;
    }

    function getFateCoreCountByTireAndGachaGrade(uint256 _tier, uint256 _gachaGrade) public view returns (uint256) {
        return fateCoreInfoTable[_tier][_gachaGrade].length;
    }

    function getFateCoreInfoByTireAndIndex(uint256 _tier, uint256 _gachaGrade, uint index) public view returns (string memory) {
        return fateCoreInfoTable[_tier][_gachaGrade][index];
    }
}
// File: contracts/Admin/data/ValueChipData.sol


pragma solidity ^0.8.16;


contract DspValueChipData is Ownable {
    event SetValueChipInfo(uint256 indexed tokenId, string indexed name, uint256 indexed valueChipsType, string characterName, uint256 gameEnumByValueChipsType);
    event RemoveValueChipInfo(uint256 indexed tokenId);

    enum ValueChipsType { None, Hero, Class, Nation, Element }
    uint256 private valueChipCount;

    struct InputValueChipInfo {
        uint256 tokenId;
        string name;
        ValueChipsType valueChipsType;
        string characterName;
        uint256 gameEnumByValueChipsType;
        bool isValid;
    }

    struct ValueChipInfo {
        string name;
        ValueChipsType valueChipsType;
        string characterName;
        uint256 gameEnumByValueChipsType;
        bool isValid;
    }

    // tokenId => ValueChipInfo
    mapping(uint256 => ValueChipInfo) private valueChipInfo;
    uint256[] private valueChipTokenIdList;

    function getValueChipCount() public view returns (uint256) {
        return valueChipCount;
    }

    function getValueChipInfo(uint256 _tokenId) public view returns (string memory, uint32, string memory, uint256, bool) {
        return (
        valueChipInfo[_tokenId].name,
        uint32(valueChipInfo[_tokenId].valueChipsType),
        valueChipInfo[_tokenId].characterName,
        valueChipInfo[_tokenId].gameEnumByValueChipsType,
        valueChipInfo[_tokenId].isValid
        );
    }

    function getValueChipsIsValid(uint256 _tokenId) public view returns (bool) {
        return valueChipInfo[_tokenId].isValid;
    }

    function getValueChipValueChipsType(uint256 _tokenId) public view returns (uint32) {
        return uint32(valueChipInfo[_tokenId].valueChipsType);
    }

    function getValueChipTokenIdList() public view returns (uint256[] memory) {
        return valueChipTokenIdList;
    }

    function setValueChipInfo(InputValueChipInfo memory _valueChipInfo) external onlyOwner {
        require(_valueChipInfo.tokenId != 0, "value chip id not valid");
        require(_valueChipInfo.isValid, "value chip not valid");
        if (!valueChipInfo[_valueChipInfo.tokenId].isValid) {
            valueChipCount++;
        }
        valueChipInfo[_valueChipInfo.tokenId] =
        ValueChipInfo(
            _valueChipInfo.name,
            _valueChipInfo.valueChipsType,
            _valueChipInfo.characterName,
            _valueChipInfo.gameEnumByValueChipsType,
            _valueChipInfo.isValid
        );
        emit SetValueChipInfo(_valueChipInfo.tokenId, _valueChipInfo.name, uint256(_valueChipInfo.valueChipsType), _valueChipInfo.characterName, _valueChipInfo.gameEnumByValueChipsType);
    }

    function setValueChipInfos(InputValueChipInfo[] memory _valueChipInfos) external onlyOwner {
        for (uint256 i = 0; i < _valueChipInfos.length; i++) {
            require(_valueChipInfos[i].tokenId != 0, "value chip id not valid");
            require(_valueChipInfos[i].isValid, "value chip not valid");
            if (!valueChipInfo[_valueChipInfos[i].tokenId].isValid) {
                valueChipCount++;
                valueChipTokenIdList.push(_valueChipInfos[i].tokenId);
            }
            valueChipInfo[_valueChipInfos[i].tokenId] =
            ValueChipInfo(
                _valueChipInfos[i].name,
                _valueChipInfos[i].valueChipsType,
                _valueChipInfos[i].characterName,
                _valueChipInfos[i].gameEnumByValueChipsType,
                _valueChipInfos[i].isValid
            );
            emit SetValueChipInfo(_valueChipInfos[i].tokenId, _valueChipInfos[i].name, uint256(_valueChipInfos[i].valueChipsType), _valueChipInfos[i].characterName, _valueChipInfos[i].gameEnumByValueChipsType);
        }
    }

    function removeValueChipInfo(uint256 _tokenId) external onlyOwner {
        require(_tokenId != 0, "gacha ticket id not valid");
        if (valueChipInfo[_tokenId].isValid) {
            valueChipCount--;
            uint256 index;
            for (uint256 i = 0; i < valueChipTokenIdList.length; i++) {
                if (valueChipTokenIdList[i] == _tokenId) {
                    index = i;
                }
            }
            for (uint256 i = index; i < valueChipTokenIdList.length - 1; i++) {
                valueChipTokenIdList[i] = valueChipTokenIdList[i + 1];
            }
            valueChipTokenIdList.pop();
        }
        emit RemoveValueChipInfo(_tokenId);
        delete valueChipInfo[_tokenId];
    }
}
// File: contracts/Admin/LuxOnAdmin.sol


pragma solidity ^0.8.16;


contract LuxOnAdmin is Ownable {

    mapping(string => mapping(address => bool)) private _superOperators;

    event SuperOperator(string operator, address superOperator, bool enabled);

    function setSuperOperator(string memory operator, address[] memory _operatorAddress, bool enabled) external onlyOwner {
        for (uint256 i = 0; i < _operatorAddress.length; i++) {
            _superOperators[operator][_operatorAddress[i]] = enabled;
            emit SuperOperator(operator, _operatorAddress[i], enabled);
        }
    }

    function isSuperOperator(string memory operator, address who) public view returns (bool) {
        return _superOperators[operator][who];
    }
}
// File: contracts/LUXON/utils/LuxOnSuperOperators.sol


pragma solidity ^0.8.16;



contract LuxOnSuperOperators is Ownable {

    event SetLuxOnAdmin(address indexed luxOnAdminAddress);
    event SetOperator(string indexed operator);

    address private luxOnAdminAddress;
    string private operator;

    constructor(
        string memory _operator,
        address _luxOnAdminAddress
    ) {
        operator = _operator;
        luxOnAdminAddress = _luxOnAdminAddress;
    }

    modifier onlySuperOperator() {
        require(LuxOnAdmin(luxOnAdminAddress).isSuperOperator(operator, msg.sender), "LuxOnSuperOperators: not super operator");
        _;
    }

    function getLuxOnAdmin() public view returns (address) {
        return luxOnAdminAddress;
    }

    function getOperator() public view returns (string memory) {
        return operator;
    }

    function setLuxOnAdmin(address _luxOnAdminAddress) external onlyOwner {
        luxOnAdminAddress = _luxOnAdminAddress;
        emit SetLuxOnAdmin(_luxOnAdminAddress);
    }

    function setOperator(string memory _operator) external onlyOwner {
        operator = _operator;
        emit SetOperator(_operator);
    }

    function isSuperOperator(address spender) public view returns (bool) {
        return LuxOnAdmin(luxOnAdminAddress).isSuperOperator(operator, spender);
    }
}
// File: contracts/Admin/data/DataAddress.sol


pragma solidity ^0.8.16;


contract DspDataAddress is Ownable {

    event SetDataAddress(string indexed name, address indexed dataAddress, bool indexed isValid);

    struct DataAddressInfo {
        string name;
        address dataAddress;
        bool isValid;
    }

    mapping(string => DataAddressInfo) private dataAddresses;

    function getDataAddress(string memory _name) public view returns (address) {
        require(dataAddresses[_name].isValid, "this data address is not valid");
        return dataAddresses[_name].dataAddress;
    }

    function setDataAddress(DataAddressInfo memory _dataAddressInfo) external onlyOwner {
        dataAddresses[_dataAddressInfo.name] = _dataAddressInfo;
        emit SetDataAddress(_dataAddressInfo.name, _dataAddressInfo.dataAddress, _dataAddressInfo.isValid);
    }

    function setDataAddresses(DataAddressInfo[] memory _dataAddressInfos) external onlyOwner {
        for (uint256 i = 0; i < _dataAddressInfos.length; i++) {
            dataAddresses[_dataAddressInfos[i].name] = _dataAddressInfos[i];
            emit SetDataAddress(_dataAddressInfos[i].name, _dataAddressInfos[i].dataAddress, _dataAddressInfos[i].isValid);
        }
    }
}
// File: contracts/LUXON/utils/LuxOnData.sol


pragma solidity ^0.8.16;



contract LuxOnData is Ownable {
    address private luxonData;
    event SetLuxonData(address indexed luxonData);

    constructor(
        address _luxonData
    ) {
        luxonData = _luxonData;
    }

    function getLuxOnData() public view returns (address) {
        return luxonData;
    }

    function setLuxOnData(address _luxonData) external onlyOwner {
        luxonData = _luxonData;
        emit SetLuxonData(_luxonData);
    }

    function getDataAddress(string memory _name) public view returns (address) {
        return DspDataAddress(luxonData).getDataAddress(_name);
    }
}
// File: contracts/LUXON/quest/PeriodQuestStorageV2.sol


pragma solidity ^0.8.18;







contract PeriodQuestStorage is LuxOnSuperOperators, LuxOnData {
    event SetStakeInfo(address indexed userAddress, uint256 indexed id, uint256 indexed tokenId, uint256 amt, uint256 conditionType);
    event SetBurnWaitList(address indexed userAddress, uint256 indexed id, uint256 indexed tokenId, uint256 amt, uint256 questType, uint256 idx);
    event SetSlotData(address indexed userAddress, uint256 indexed id, uint256 indexed tokenId, uint256 amt, uint256 idx);
    event SetClear(address indexed userAddress, uint256 indexed id);
    event CancelQuest(address indexed userAddress, uint256 indexed id);
    event SoldOut(uint256 indexed questType, uint256 indexed id, uint256 indexed remainCount);

    using SafeMath for uint256;

    // address => quest id
    mapping(address => uint256[]) public userQuestClearInfo;
    mapping(address => mapping(uint256 => bool)) public userQuestClearState;
    // address => id => count
    mapping(address => mapping(uint256 => uint256)) public userClearCount;
    // address => type => clear
    mapping(address => mapping(uint256 => uint256[])) public userPeriodClearInfo;
    mapping(address => mapping(uint256 => uint256)) public userPeriodClearTime;

    // id => count
    mapping(uint256 => uint256) public questClearCount;
    // address => id => quest info
    mapping(address => mapping(uint256 => QuestInfo)) public userQuestInfo;
    mapping(address => mapping(uint256 => StakeInfo[])) public userStakeInfo;
    mapping(address => mapping(uint256 => BurnWaitInfo[])) public userBurnWaitList;
    uint256 constant HOUR = 3600;

    uint256 public soldOutCount = 3;

    constructor(
        address dataAddress,
        string memory operator,
        address luxOnAdmin
    ) LuxOnData(dataAddress) LuxOnSuperOperators(operator, luxOnAdmin) {}

    function getQuestCount(uint256 id) public view returns (uint256) {
        //PeriodQuestInfo memory periodQuestInfo = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendar(id);
        return questClearCount[id];
    }

    function getQuestCounts(uint256[] memory ids) public view returns (uint256[] memory) {
        uint256[] memory counts = new uint256[](ids.length);
        //PeriodQuestInfo[] memory periodQuestInfos = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendars(ids);
        for (uint256 i = 0; i < ids.length; i++) {
            counts[i] = questClearCount[ids[i]];
        }
        return counts;
    }

    function getClearState(address _address, uint256 id) public view returns (bool) {
        return userQuestClearState[_address][id];
    }

    function getClearCount(address _address, uint256 id) public view returns (uint256) {
        return userClearCount[_address][id];
    }

    function getQuestStorage(address _address, uint256 id) public view returns (QuestInfo memory) {
        return userQuestInfo[_address][id];
    }

    function getBurnInfo(address _address, uint256 id) public view returns(BurnWaitInfo[] memory) {
        return userBurnWaitList[_address][id];
    }

    function getStakingInfo(address _address, uint256 id) public view returns (StakeInfo[] memory) {
        return userStakeInfo[_address][id];
    }

    function getClearQuestList(address _address) public view returns (uint256[] memory) {
        return userQuestClearInfo[_address];
    }

    function getUserPeriodClearInfo(address _address, uint256 questType) public view returns (uint256[] memory) {
        return userPeriodClearInfo[_address][questType];
    }

    function getUserPeriodClearTime(address _address, uint256 questType) public view returns (uint256) {
        return userPeriodClearTime[_address][questType];
    }

    function getClearCondition(address user, uint256 currentId, uint256 requireId, uint256 finishId) public view returns (uint256, uint256, uint256, uint256) {
        return (
        getQuestCount(finishId),
        getClearCount(user, currentId),
        getClearCount(user, requireId),
        getClearCount(user, finishId)
        );
    }

    function resetUserPeriodClearInfo(address _address, uint256 questType) external onlySuperOperator {
        if (0 != userPeriodClearInfo[_address][questType].length) {
            delete userPeriodClearInfo[_address][questType];
        }
    }

    function setSoldOutCount(uint256 _soldOutCount) external onlySuperOperator {
        soldOutCount = _soldOutCount;
    }

    function setClearQuestList(address _address, uint256[] memory ids, uint256 questType, bool isClear) external onlySuperOperator {
        // PeriodQuestInfo[] memory calendars = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendars(ids);
        for (uint256 i = 0; i < ids.length; i++) {
            if (isClear) {
                if (!userQuestClearState[_address][ids[i]]) {
                    userQuestClearInfo[_address].push(ids[i]);
                    userPeriodClearInfo[_address][questType].push(ids[i]);
                    userQuestClearState[_address][ids[i]] = true;
                }
                userPeriodClearTime[_address][questType] = block.timestamp;
                userClearCount[_address][ids[i]]++;
                questClearCount[ids[i]]++;
            } else if (!isClear && 0 != userClearCount[_address][ids[i]]) {
                for (uint256 j = 0; j < userQuestClearInfo[_address].length; j++) {
                    if (userQuestClearInfo[_address][j] == ids[i]) {
                        userQuestClearInfo[_address][j] = userQuestClearInfo[_address][userQuestClearInfo[_address].length - 1];
                        userQuestClearInfo[_address].pop();
                        break;
                    }
                }
                for (uint256 j = 0; j < userPeriodClearInfo[_address][questType].length; j++) {
                    if (userPeriodClearInfo[_address][questType][j] == ids[i]) {
                        userPeriodClearInfo[_address][questType][j] = userPeriodClearInfo[_address][questType][userPeriodClearInfo[_address][questType].length - 1];
                        userPeriodClearInfo[_address][questType].pop();
                        break;
                    }
                }
                userPeriodClearTime[_address][questType] = block.timestamp;
                userClearCount[_address][ids[i]]--;
                if (0 == userClearCount[_address][ids[i]]) {
                    userQuestClearState[_address][ids[i]] = false;
                }
                questClearCount[ids[i]]--;
            }
        }
    }

    function setClearCount(CalculateType setType, uint256 id, uint256 count) external onlySuperOperator {
        if (CalculateType.SET == setType) {
            questClearCount[id] = count;
        } else if (CalculateType.ADD == setType) {
            questClearCount[id] += count;
        } else if (CalculateType.SUB == setType) {
            questClearCount[id] -= count;
        }
    }

    function setStakeInfo(address _address, uint256 id, uint256 _tokenId, uint256 _amt, uint256 _conditionType) external onlySuperOperator {
        userStakeInfo[_address][id].push(StakeInfo(_tokenId, _amt, _conditionType));
        emit SetStakeInfo(_address, id, _tokenId, _amt, _conditionType);
    }

    function setBurnWaitList(address _address, uint256 id, uint256 _tokenId, uint256 _amt, uint256 _questType, uint256 _idx) external onlySuperOperator {
        userBurnWaitList[_address][id].push(BurnWaitInfo(_tokenId, _amt, _questType, _idx));
        emit SetBurnWaitList(_address, id, _tokenId, _amt, _questType, _idx);
    }

    function setSlotData(address _address, uint256 id, uint256 _tokenId, uint256 _amt, uint256 _idx) external onlySuperOperator {
        userQuestInfo[_address][id].slotData.push(QuestSlotInfo(_tokenId, _amt, true));
        emit SetSlotData(_address, id, _tokenId, _amt, _idx);
    }

    function setClear(address _address, uint256 id, uint256 finishId, uint256 questType) external onlySuperOperator {
        if (!userQuestClearState[_address][id]) {
            userQuestClearInfo[_address].push(id);
            userPeriodClearInfo[_address][questType].push(id);
            userQuestClearState[_address][id] = true;
        }
        userClearCount[_address][id]++;
        questClearCount[id]++;
        if (finishId == id) {
            PeriodQuestInfo memory calendar = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendar(id);
            if (LimitType.LIMIT == calendar.limitType && calendar.limit - soldOutCount < questClearCount[id]) {
                emit SoldOut(questType, id, calendar.limit - questClearCount[id]);
            }
        }
        userPeriodClearTime[_address][questType] = block.timestamp;
        deleteQuest(_address, id);
        emit SetClear(_address, id);
    }

    function cancelQuest(address _address, uint256 id) external onlySuperOperator {
        require(id == userQuestInfo[_address][id].questNo, "INVALID questNo");
        deleteQuest(_address, id);
        emit CancelQuest(_address, id);
    }

    function deleteQuest(address _address, uint256 id) private {
        delete userQuestInfo[_address][id];
        delete userBurnWaitList[_address][id];
        delete userStakeInfo[_address][id];
    }

    function startQuest(address _address, uint256 id, uint256 stakingTime) external onlySuperOperator {
        userQuestInfo[_address][id].questNo = id;
        userQuestInfo[_address][id].startAt = block.timestamp;
        userQuestInfo[_address][id].endAt = block.timestamp.add(HOUR.mul(stakingTime));
    }
}

// File: contracts/Admin/data/CharacterData.sol


pragma solidity ^0.8.16;




contract DspCharacterData is Ownable, LuxOnData {
    event SetCharacterData(string indexed name, uint256 indexed tier, uint256 indexed gachaGrade, uint256 classType, uint256 nation, uint256 element, bool isValid);
    event DeleteCharacterData(string indexed name, uint256 indexed tier, uint256 indexed gachaGrade, uint256 classType, uint256 nation, uint256 element, bool isValid);
    event SetCharacterName(uint256 indexed id, string indexed name);

    struct CharacterInfo {
        string name;
        uint256 tier;
        uint256 gachaGrade;
        uint256 classType;
        uint256 nation;
        uint256 element;
        uint256 rootId;
        bool isValid;
    }

    struct CharacterName {
        uint256 id;
        string name;
    }

    struct MatchValueChip {
        string name;
        uint256 valueChipId;
    }

    constructor(address dataAddress) LuxOnData(dataAddress) {}

    string public valueChipData = "DspValueChipData";

    // character id => name
    mapping(uint256 => string) private characterName;
    // name => character info
    mapping(string => CharacterInfo) private characterData;
    // tier => gacha grade => name[]
    mapping(uint256 => mapping(uint256 => string[])) private characterInfoTable;
    // name => value chip
    mapping(string => uint256) private matchValueChip;

    uint256 private characterCount;

    function getCharacterInfo(string memory name) public view returns(uint256, uint256, uint256, uint256, uint256, uint256, bool) {
        return (characterData[name].tier, characterData[name].gachaGrade, characterData[name].classType, characterData[name].nation, characterData[name].element, characterData[name].rootId, characterData[name].isValid);
    }

    function getCharacterInfoIsValid(string memory name) public view returns(bool) {
        return characterData[name].isValid;
    }

    function getCharacterName(uint256 id) public view returns (string memory) {
        return characterName[id];
    }

    function setMatchValueChip(MatchValueChip[] memory _matchValueChips) external onlyOwner {
        address valueChipAddress = getDataAddress(valueChipData);
        for (uint256 i = 0; i < _matchValueChips.length; i++) {
            ( , uint32 _valueChipsType, string memory _characterName, , bool _isValid) = DspValueChipData(valueChipAddress).getValueChipInfo(_matchValueChips[i].valueChipId);
            if (
                _isValid &&
                _valueChipsType == uint32(DspValueChipData.ValueChipsType.Hero) &&
                uint(keccak256(abi.encodePacked(_characterName))) == uint(keccak256(abi.encodePacked(_matchValueChips[i].name)))
            ) {
                matchValueChip[_matchValueChips[i].name] = _matchValueChips[i].valueChipId;
            }
        }
    }

    function setCharacterName(CharacterName[] memory _characterName) external onlyOwner {
        for (uint256 i = 0; i < _characterName.length; i++) {
            characterName[_characterName[i].id] = _characterName[i].name;
            emit SetCharacterName(_characterName[i].id, _characterName[i].name);
        }
    }

    function setCharacterData(CharacterInfo[] memory _characterData) external onlyOwner {
        for (uint256 i = 0; i < _characterData.length; i++) {
            require(_characterData[i].isValid, "isValid false use delete");
            if (!characterData[_characterData[i].name].isValid) {
                characterCount++;
            } else if (characterData[_characterData[i].name].tier != _characterData[i].tier) {
                uint256 index;
                uint256 _tier = characterData[_characterData[i].name].tier;
                uint256 _gachaGrade = characterData[_characterData[i].name].gachaGrade;
                for (uint256 j = 0; j < characterInfoTable[_tier][_gachaGrade].length; j++) {
                    if (keccak256(abi.encodePacked(characterInfoTable[_tier][_gachaGrade][j])) == keccak256(abi.encodePacked(_characterData[i].name))) {
                        index = j;
                        break;
                    }
                }
                for (uint256 j = index; j < characterInfoTable[_tier][_gachaGrade].length - 1; j++) {
                    characterInfoTable[_tier][_gachaGrade][j] = characterInfoTable[_tier][_gachaGrade][j + 1];
                }
                characterInfoTable[_tier][_gachaGrade].pop();
            }
            characterInfoTable[_characterData[i].tier][_characterData[i].gachaGrade].push(_characterData[i].name);
            characterData[_characterData[i].name] = _characterData[i];

            emit SetCharacterData(_characterData[i].name, _characterData[i].tier, _characterData[i].gachaGrade, _characterData[i].classType, _characterData[i].nation, _characterData[i].element, _characterData[i].isValid);
        }
    }

    function deleteCharacterData(string[] memory names) external onlyOwner {
        for (uint256 i = 0; i < names.length; i++) {
            uint256 _tier = characterData[names[i]].tier;
            uint256 _gachaGrade = characterData[names[i]].gachaGrade;

            uint256 index;
            for (uint256 j = 0; j < characterInfoTable[_tier][_gachaGrade].length; j++) {
                if (keccak256(abi.encodePacked(characterInfoTable[_tier][_gachaGrade][j])) == keccak256(abi.encodePacked(characterData[names[i]].name))) {
                    index = j;
                    break;
                }
            }
            for (uint256 j = index; j < characterInfoTable[_tier][_gachaGrade].length - 1; j++) {
                characterInfoTable[_tier][_gachaGrade][j] = characterInfoTable[_tier][_gachaGrade][j + 1];
            }
            characterInfoTable[_tier][_gachaGrade].pop();
            characterCount--;

            emit DeleteCharacterData(characterData[names[i]].name, characterData[names[i]].tier, characterData[names[i]].gachaGrade, characterData[names[i]].classType, characterData[names[i]].nation, characterData[names[i]].element, characterData[names[i]].isValid);
            delete characterData[names[i]];
        }
    }

    function getMatchValueChip(string memory _name) public view returns (uint256) {
        return matchValueChip[_name];
    }

    function getCharacterCount() public view returns (uint256) {
        return characterCount;
    }

    function getCharacterCountByTireAndGachaGrade(uint256 _tier, uint256 _gachaGrade) public view returns (uint256) {
        return characterInfoTable[_tier][_gachaGrade].length;
    }

    function getCharacterInfoByTireAndIndex(uint256 _tier, uint256 _gachaGrade, uint index) public view returns (string memory) {
        return characterInfoTable[_tier][_gachaGrade][index];
    }
}
// File: contracts/LUXON/utils/IERC20LUXON.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.16;

interface IERC20LUXON {
    function paybackFrom() external view returns (address);

    function addAllowanceIfNeeded(address owner, address spender, uint256 amountNeeded) external returns (bool success);
    function approveFor(address owner, address spender, uint256 amount) external returns (bool success);

    function paybackByMint(address to, uint256 amount) external;
    function paybackByTransfer(address to, uint256 amount) external;
    function burnFor(address owner, uint256 amount) external returns (bool);

    function decimals() external view returns (uint8);

    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);

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

// File: contracts/LUXON/utils/IERC1155LUXON.sol


pragma solidity ^0.8.16;

interface IERC1155LUXON {
    function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) external;
    function getValueChipType() external view returns(uint32);
    function mint(address account, uint256 id, uint256 amount, bytes memory data) external;
}
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * 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;

    /**
     * @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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @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);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: contracts/LUXON/utils/ERC721LUXON.sol


pragma solidity ^0.8.13;









    error ApprovalCallerNotOwnerNorApproved();
    error ApprovalQueryForNonexistentToken();
    error ApproveToCaller();
    error ApprovalToCurrentOwner();
    error BalanceQueryForZeroAddress();
    error MintToZeroAddress();
    error MintZeroQuantity();
    error OwnerQueryForNonexistentToken();
    error TransferCallerNotOwnerNorApproved();
    error TransferFromIncorrectOwner();
    error TransferToNonERC721ReceiverImplementer();
    error TransferToZeroAddress();
    error URIQueryForNonexistentToken();

contract ERC721LUXON is Context, ERC165, IERC721, IERC721Metadata, LuxOnSuperOperators {
    string private baseURI = "";

    constructor(
        string memory name_,
        string memory symbol_,
        string memory operator,
        address luxOnAdmin
    ) LuxOnSuperOperators(operator, luxOnAdmin) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
        bool burned;
    }

    struct AddressData {
        uint64 balance;
        uint64 numberMinted;
        uint64 numberBurned;
        uint64 aux;
    }

    uint256 internal _currentIndex;
    uint256 internal _burnCounter;
    string private _name;
    string private _symbol;
    mapping(uint256 => TokenOwnership) internal _ownerships;
    mapping(address => AddressData) private _addressData;
    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    function _startTokenId() internal pure returns (uint256) {
        return 1;
    }

    function totalSupply() public view returns (uint256) {
    unchecked {
        return _currentIndex - _burnCounter - _startTokenId();
    }
    }

    function _totalMinted() internal view returns (uint256) {
    unchecked {
        return _currentIndex - _startTokenId();
    }
    }

    function nextTokenId() public view returns (uint256) {
        return _currentIndex;
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
        return
        interfaceId == type(IERC721).interfaceId ||
        interfaceId == type(IERC721Metadata).interfaceId ||
        super.supportsInterface(interfaceId);
    }

    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

    unchecked {
        if (_startTokenId() <= curr && curr < _currentIndex) {
            TokenOwnership memory ownership = _ownerships[curr];
            if (!ownership.burned) {
                if (ownership.addr != address(0)) {
                    return ownership;
                }
                while (true) {
                    curr--;
                    ownership = _ownerships[curr];
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                }
            }
        }
    }
        revert OwnerQueryForNonexistentToken();
    }

    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    function name() public view override returns (string memory) {
        return _name;
    }

    function symbol() public view override returns (string memory) {
        return _symbol;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
    }

    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721LUXON.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    function setApprovalForAll(address operator, bool approved) public override {
        if (operator == _msgSender()) revert ApproveToCaller();

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    function isApprovedForAll(address owner, address operator) public view override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override {
        _transfer(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override {
        safeTransferFrom(from, to, tokenId, '');
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

    unchecked {
        _addressData[to].balance += uint64(quantity);
        _addressData[to].numberMinted += uint64(quantity);

        _ownerships[startTokenId].addr = to;
        _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

        uint256 updatedIndex = startTokenId;
        uint256 end = updatedIndex + quantity;

        if (safe && to.isContract()) {
            do {
                emit Transfer(address(0), to, updatedIndex);
                if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                    revert TransferToNonERC721ReceiverImplementer();
                }
            } while (updatedIndex != end);
            if (_currentIndex != startTokenId) revert();
        } else {
            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex != end);
        }
        _currentIndex = updatedIndex;
    }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
        isApprovedForAll(from, _msgSender()) ||
        getApproved(tokenId) == _msgSender() ||
        isSuperOperator(_msgSender()));

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        _approve(address(0), tokenId, from);

    unchecked {
        _addressData[from].balance -= 1;
        _addressData[to].balance += 1;

        TokenOwnership storage currSlot = _ownerships[tokenId];
        currSlot.addr = to;
        currSlot.startTimestamp = uint64(block.timestamp);

        uint256 _nextTokenId = tokenId + 1;
        TokenOwnership storage nextSlot = _ownerships[_nextTokenId];
        if (nextSlot.addr == address(0)) {
            if (_nextTokenId != _currentIndex) {
                nextSlot.addr = from;
                nextSlot.startTimestamp = prevOwnership.startTimestamp;
            }
        }
    }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    function _burn(uint256 tokenId) internal {
        _burn(tokenId, false);
    }

    function _burn(uint256 tokenId, bool approvalCheck) internal {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender() ||
            isSuperOperator(_msgSender()));

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        _approve(address(0), tokenId, from);

    unchecked {
        AddressData storage addressData = _addressData[from];
        addressData.balance -= 1;
        addressData.numberBurned += 1;

        TokenOwnership storage currSlot = _ownerships[tokenId];
        currSlot.addr = from;
        currSlot.startTimestamp = uint64(block.timestamp);
        currSlot.burned = true;

        uint256 _nextTokenId = tokenId + 1;
        TokenOwnership storage nextSlot = _ownerships[_nextTokenId];
        if (nextSlot.addr == address(0)) {
            if (_nextTokenId != _currentIndex) {
                nextSlot.addr = from;
                nextSlot.startTimestamp = prevOwnership.startTimestamp;
            }
        }
    }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

    unchecked {
        _burnCounter++;
    }
    }

    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal {}

    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal {}

    function setBaseURI(string memory baseURI_) external onlyOwner {
        baseURI = baseURI_;
    }

    function _baseURI() internal view returns (string memory) {
        return baseURI;
    }
}

// File: contracts/LUXON/myPage/character/LCT.sol


pragma solidity ^0.8.13;


contract LCT is ERC721LUXON {

    event MintByCharacterName(address indexed mintUser, uint256 indexed tokenId, string indexed name);
    event BurnCharacter(uint256 indexed tokenId, string indexed name);
    event SetCharacterName(uint256 indexed tokenId, string indexed name);

    struct Character {
        uint256 tokenId;
        string name;
    }

    constructor(
        string memory operator,
        address luxOnAdmin
    ) ERC721LUXON("Lux-On Character NFT", "LCT", operator, luxOnAdmin) {}

    mapping(uint256 => string) characterInfo;

    function mintByCharacterName(address mintUser, uint256 quantity, string[] memory characterName) external onlySuperOperator {
        require(characterName.length == quantity, "quantity != gacha count");
        uint256 tokenId = nextTokenId();
        for (uint8 i = 0; i < quantity; i++) {
            emit MintByCharacterName(mintUser, tokenId, characterName[i]);
            characterInfo[tokenId++] = characterName[i];
        }
        _safeMint(mintUser, quantity);
    }

    function mint(address mintUser, uint256 quantity) external onlySuperOperator {
        _safeMint(mintUser, quantity);
    }

    function getCharacterInfo(uint256 tokenId) public view returns (string memory) {
        return characterInfo[tokenId];
    }

    function getCharacterInfos(uint256[] memory tokenIds) public view returns (string[] memory) {
        string[] memory names = new string[](tokenIds.length);
        for (uint256 i = 0; i < tokenIds.length; i++) {
            names[i] = characterInfo[tokenIds[i]];
        }
        return names;
    }

    function burnCharacter(uint256 tokenId) external onlySuperOperator {
        _burn(tokenId);
        emit BurnCharacter(tokenId, characterInfo[tokenId]);
        delete characterInfo[tokenId];
    }

    function setCharacterName(Character[] memory _character) external onlySuperOperator {
        for (uint256 i = 0; i < _character.length; i++) {
            characterInfo[_character[i].tokenId] = _character[i].name;
            emit SetCharacterName(_character[i].tokenId, _character[i].name);
        }
    }
}
// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;


/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/token/ERC1155/utils/ERC1155Receiver.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)

pragma solidity ^0.8.0;



/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

// File: @openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.0;


/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

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 making 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: contracts/LUXON/quest/PeriodQuestV3.sol


pragma solidity ^0.8.18;
















contract PeriodQuest is ReentrancyGuard, LuxOnData, ERC1155Holder, LuxOnLive {
    event EnterQuest(address indexed user, uint256 indexed id);
    event ClearQuest(address indexed user, uint256 indexed id);
    event CancelQuest(address indexed user, uint256 indexed id);

    event SendReward(address indexed user, address indexed to, address indexed tokenAddress, uint256 tokenType, uint256 reward, uint256 rewardAmount);
    event TransferFromByType(address indexed from, address indexed to, address indexed tokenAddress, uint256 tokenId, uint256 amount, uint256 conditionType);

    address constant burnAddress = 0x000000000000000000000000000000000000dEaD;
    uint256 constant errorNo = 9999;

    address public lctAddress;
    address public gachaTicketAddress;
    PeriodQuestStorage public questStorage;

    // goods type => address
    mapping(uint256 => RewardInfo) public rewardAddresses;

    constructor(
        address dataAddress,
        address luxonService,
        address _lctAddress,
        address _gachaTicketAddress,
        address _questStorage
    ) LuxOnData(dataAddress) LuxOnLive(luxonService) {
        lctAddress = _lctAddress;
        gachaTicketAddress = _gachaTicketAddress;
        questStorage = PeriodQuestStorage(_questStorage);
    }

    function setRewardAddress(RewardInfo[] memory rewardInfos) external onlyOwner {
        for (uint256 i = 0; i < rewardInfos.length; i++) {
            rewardAddresses[rewardInfos[i].goodsType] = rewardInfos[i];
        }
    }

    function setQuestStorageAddress(address _questStorage) external onlyOwner {
        questStorage = PeriodQuestStorage(_questStorage);
    }

    function setLctAddress(address _lctAddress) external onlyOwner {
        lctAddress = _lctAddress;
    }
    function setGachaTicketAddress(address _gachaTicketAddress) external onlyOwner {
        gachaTicketAddress = _gachaTicketAddress;
    }

    function withdraw() external onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }

    function enterQuest(uint256 id, uint256[] memory _tokenIds) public nonReentrant isLive {
        PeriodQuestInfo memory pqi = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendar(id);
        checkEnterQuestValid(pqi);
        if (questStorage.getUserPeriodClearTime(msg.sender, pqi.questType) < pqi.startAt) {
            questStorage.resetUserPeriodClearInfo(msg.sender, pqi.questType);
        }
        Quest memory qD = PeriodQuestData(getDataAddress("PeriodQuestData")).getQuest(pqi.questId);
        require(qD.questConditionSlot.length == _tokenIds.length, "not valid token count");
        if (uint256(QuestCategory.REWARD) == qD.questCategory) {
            questStorage.setClear(msg.sender, id, pqi.finishId, pqi.questType);
            sendReward(msg.sender, qD.rewards);
        } else {
            address dspActerDataAddress = getDataAddress("DspActorData");
            address dspCharacterDataAddress = getDataAddress("DspCharacterData");
            address dspFateCoreDataAddress = getDataAddress("DspFateCoreData");
            questStorage.startQuest(msg.sender, id, qD.stakingTime);
            QuestInfo memory qI = questStorage.getQuestStorage(msg.sender, id);
            require(0 == qI.slotData.length, "Error : completion condition.");
            for (uint i = 0; i < _tokenIds.length; i++) {
                require(0 != _tokenIds[i], "INVALID tokenId");
                string memory name = LCT(lctAddress).getCharacterInfo(_tokenIds[i]);
                (uint256 _tier, , , uint256 nation, uint256 element, uint256 _rootId, ) = getConditionTokenInfo(dspActerDataAddress, dspCharacterDataAddress, dspFateCoreDataAddress, name);

                if (uint256(ConditionType.CHARACTER_TIER) == qD.questConditionSlot[i].conditionType) {
                    require(uint256(_tier) == uint256(qD.questConditionSlot[i].conditionValue), "Invalid Condition : This character does not match the tier conditions.");
                    if (0 != qD.questConditionSlot[i].subConditionType) {
                        checkSubCondition(qD.questConditionSlot[i].subConditionType, qD.questConditionSlot[i].subConditionValue, nation, element);
                    }
                } else if (uint256(ConditionType.CHARACTER) == qD.questConditionSlot[i].conditionType) {
                    require(uint256(_rootId) == uint256(qD.questConditionSlot[i].conditionValue), "Invalid Condition : This character does not match the condition");
                    if (0 != qD.questConditionSlot[i].subConditionType) {
                        checkSubCondition(qD.questConditionSlot[i].subConditionType, qD.questConditionSlot[i].subConditionValue, nation, element);
                    }
                } else if (uint256(ConditionType.PACK) == qD.questConditionSlot[i].conditionType) {
                    require(uint256(_tokenIds[i]) == uint256(qD.questConditionSlot[i].conditionValue), "Invalid Condition : This character does not match the pack conditions.");
                } else {
                    revert("INVALID condition type");
                }

                checkConditionAndTransfer(id, _tokenIds[i], qD.questConditionSlot[i], i);
            }
        }

        emit EnterQuest(msg.sender, id);
    }

    function checkEnterQuestValid(PeriodQuestInfo memory pqi) private view {
        require(pqi.isValid, "quest not valid");
        require(pqi.startAt <= block.timestamp && block.timestamp < pqi.endAt, "quest not open");
        (uint256 questCount, uint256 currentClearCount, uint256 requiredClearCount, uint256 finishClearCount) = questStorage.getClearCondition(msg.sender, pqi.id, pqi.requireId, pqi.finishId);
        require(currentClearCount == finishClearCount, "already clear this quest");
        if (0 != pqi.requireId) {
            require(currentClearCount < requiredClearCount, "haven't completed the previous quest yet");
        }
        if (LimitType.LIMIT == pqi.userLimitType) {
            require(currentClearCount < pqi.userLimit, "User: Got stuck in the limit of this quest.");
        }
        if (LimitType.LIMIT == pqi.limitType) {
            require(questCount < pqi.limit, "limit quest");
        }
    }

    function getConditionTokenInfo(address dspActerDataAddress, address dspCharacterDataAddress, address dspFateCoreDataAddress, string memory name) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, bool) {
        uint256 gachaType = DspActorData(dspActerDataAddress).getGachaTypeByName(name);
        if (uint256(GachaType.Character) == gachaType) {
            return DspCharacterData(dspCharacterDataAddress).getCharacterInfo(name);
        } else if (uint256(GachaType.FateCore) == gachaType) {
            return DspFateCoreData(dspFateCoreDataAddress).getFateCoreInfo(name);
        }
        revert("INVALID token info type");
    }

    function checkSubCondition(uint256 conditionType, uint256 conditionValue, uint256 nation, uint256 element) private pure {
        if (uint256(ConditionType.CHARACTER_ELEMENT) == conditionType) {
            require(uint256(element) == uint256(conditionValue), "Invalid Condition : This character does not match the element conditions.");
        } else if (uint256(ConditionType.CHARACTER_NATION) == conditionType) {
            require(uint256(nation) == uint256(conditionValue), "Invalid Condition : This character does not match the nation conditions.");
        } else {
            revert("INVALID sub condition type");
        }
    }

    function cancelQuest(uint256 id) public nonReentrant {
        PeriodQuestInfo memory pqi = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendar(id);
        checkCancelQuestValid(pqi);
        QuestInfo memory qI = questStorage.getQuestStorage(msg.sender, id);
        require(qI.questNo == id, "not valid clear id");
        StakeInfo[] memory stakeInfos = questStorage.getStakingInfo(msg.sender, id);
        for (uint256 i = 0; i < stakeInfos.length; i++) {
            _transferFromByType(address(questStorage), msg.sender, stakeInfos[i].tokenId, stakeInfos[i].amount, stakeInfos[i].conditionType);
        }

        BurnWaitInfo[] memory burnInfos = questStorage.getBurnInfo(msg.sender, id);
        for (uint i = 0; i < burnInfos.length; i++) {
            _transferFromByType(address(questStorage), msg.sender, burnInfos[i].tokenId, burnInfos[i].amount, burnInfos[i].conditionType);
        }

        questStorage.cancelQuest(msg.sender, id);

        emit CancelQuest(msg.sender, id);
    }

    function checkCancelQuestValid(PeriodQuestInfo memory pqi) private view {
        ( , uint256 currentClearCount, uint256 requiredClearCount, uint256 finishClearCount) = questStorage.getClearCondition(msg.sender, pqi.id, pqi.requireId, pqi.finishId);
        require(currentClearCount == finishClearCount, "already clear this quest");
        if (0 != pqi.requireId) {
            require(currentClearCount < requiredClearCount, "haven't completed the previous quest yet");
        }
    }

    function clearQuest(uint256 id) public nonReentrant isLive {
        PeriodQuestInfo memory pqi = QuestCalendar(getDataAddress("QuestCalendar")).getQuestCalendar(id);
        checkClearQuestValid(pqi);
        Quest memory qD = PeriodQuestData(getDataAddress("PeriodQuestData")).getQuest(pqi.questId);
        QuestInfo memory qI = questStorage.getQuestStorage(msg.sender, id);
        if (uint256(QuestCategory.REWARD) != qD.questCategory) {
            require(qI.questNo == id, "not valid clear id");
            for (uint256 i = 0; i < qI.slotData.length; i++) {
                require(true == qI.slotData[i].isValid, "Error : You are not satisfied with the completion condition.");
            }
            require(block.timestamp > qI.endAt, "Error : You are not satisfied with the staking time.");

            BurnWaitInfo[] memory burnInfos = questStorage.getBurnInfo(msg.sender, id);
            for (uint i = 0; i < burnInfos.length; i++) {
                _transferFromByType(address(questStorage), address(burnAddress), burnInfos[i].tokenId, burnInfos[i].amount, burnInfos[i].conditionType);
            }

            StakeInfo[] memory stakeInfos = questStorage.getStakingInfo(msg.sender, id);
            for (uint256 i = 0; i < stakeInfos.length; i++) {
                _transferFromByType(address(questStorage), msg.sender, stakeInfos[i].tokenId, stakeInfos[i].amount, stakeInfos[i].conditionType);
            }
        }
        questStorage.setClear(msg.sender, id, pqi.finishId, pqi.questType);
        sendReward(msg.sender, qD.rewards);

        emit ClearQuest(msg.sender, id);
    }

    function checkClearQuestValid(PeriodQuestInfo memory pqi) private view {
        require(pqi.isValid, "quest not valid");
        require(pqi.startAt <= block.timestamp && block.timestamp < pqi.endAt, "quest not open");
        (uint256 questCount, uint256 currentClearCount, uint256 requiredClearCount, uint256 finishClearCount) = questStorage.getClearCondition(msg.sender, pqi.id, pqi.requireId, pqi.finishId);
        require(currentClearCount == finishClearCount, "already clear this quest");
        if (0 != pqi.requireId) {
            require(currentClearCount < requiredClearCount, "haven't completed the previous quest yet");
        }
        if (LimitType.LIMIT == pqi.userLimitType) {
            require(currentClearCount < pqi.userLimit, "User: Got stuck in the limit of this quest.");
        }
        if (LimitType.LIMIT == pqi.limitType) {
            require(questCount < pqi.limit, "limit quest");
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    function checkConditionAndTransfer(uint256 id, uint256 _tokenId, QuestConditionSlot memory _questConditionSlot, uint256 _index) private {
        uint256 conditionType = _questConditionSlot.conditionType;
        uint256 questType = _questConditionSlot.questType;
        uint256 amount = _questConditionSlot.conditionAmount;
        if (uint256(MissionType.BURN) == questType) {
            questStorage.setBurnWaitList(msg.sender, id, _tokenId, amount, questType, _index);
            _transferFromByType(msg.sender, address(questStorage), _tokenId, amount, conditionType);
        } else if (uint256(MissionType.STAKE) == questType || uint256(MissionType.REGIST) == questType) {
            questStorage.setStakeInfo(msg.sender, id, _tokenId, amount, conditionType);
            _transferFromByType(msg.sender, address(questStorage), _tokenId, amount, conditionType);
        } else {
            revert("INVALID Mission type");
        }
        questStorage.setSlotData(msg.sender, id, _tokenId, amount, _index);
    }

    function sendReward(address _to, Reward[] memory _rewards) private {
        for (uint256 i = 0; i < _rewards.length; i++) {
            RewardInfo memory rewardInfo = rewardAddresses[_rewards[i].rewardType];
            require(rewardInfo.isValid, "reward not valid");
            if (uint256(TokenType.ERC1155) == rewardInfo.tokenType) {
                IERC1155LUXON(rewardInfo.tokenAddress).mint(_to, _rewards[i].reward, _rewards[i].rewardAmount,"");
            } else if (uint256(TokenType.ERC20) == rewardInfo.tokenType) {
                IERC20LUXON(rewardInfo.tokenAddress).transfer(_to, _rewards[i].rewardAmount);
            } else if (uint256(TokenType.ERC721) == rewardInfo.tokenType) {
                IERC721(rewardInfo.tokenAddress).transferFrom(address(this), _to, _rewards[i].reward);
            } else {
                revert("INVALID Reward type");
            }
            emit SendReward(msg.sender, _to, rewardInfo.tokenAddress, uint256(rewardInfo.tokenType), _rewards[i].reward, _rewards[i].rewardAmount);
        }
    }

    function _transferFromByType(address _from, address _to, uint256 _tokenId, uint256 _amount, uint256 _conditionType) private {
        if (uint256(ConditionType.CHARACTER) == _conditionType || uint256(ConditionType.CHARACTER_TIER) == _conditionType) {
            IERC721(lctAddress).transferFrom(_from, _to, _tokenId);
            emit TransferFromByType(_from, _to, lctAddress, _tokenId, _amount, _conditionType);
        } else if (uint256(ConditionType.PACK) == _conditionType) {
            IERC1155LUXON(gachaTicketAddress).safeTransferFrom(_from, _to, _tokenId, _amount, "");
            emit TransferFromByType(_from, _to, gachaTicketAddress, _tokenId, _amount, _conditionType);
        } else {
            revert("INVALID condition type");
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"dataAddress","type":"address"},{"internalType":"address","name":"luxonService","type":"address"},{"internalType":"address","name":"_lctAddress","type":"address"},{"internalType":"address","name":"_gachaTicketAddress","type":"address"},{"internalType":"address","name":"_questStorage","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"CancelQuest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"ClearQuest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"EnterQuest","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":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenType","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"SendReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"luxOnService","type":"address"}],"name":"SetLuxOnService","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"luxonData","type":"address"}],"name":"SetLuxonData","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"conditionType","type":"uint256"}],"name":"TransferFromByType","type":"event"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"cancelQuest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"clearQuest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"enterQuest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gachaTicketAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dspActerDataAddress","type":"address"},{"internalType":"address","name":"dspCharacterDataAddress","type":"address"},{"internalType":"address","name":"dspFateCoreDataAddress","type":"address"},{"internalType":"string","name":"name","type":"string"}],"name":"getConditionTokenInfo","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"}],"name":"getDataAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLuxOnData","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLuxOnService","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lctAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"questStorage","outputs":[{"internalType":"contract PeriodQuestStorage","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardAddresses","outputs":[{"internalType":"uint256","name":"goodsType","type":"uint256"},{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"bool","name":"isValid","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_gachaTicketAddress","type":"address"}],"name":"setGachaTicketAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lctAddress","type":"address"}],"name":"setLctAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_luxonData","type":"address"}],"name":"setLuxOnData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_luxOnService","type":"address"}],"name":"setLuxOnService","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_questStorage","type":"address"}],"name":"setQuestStorageAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"goodsType","type":"uint256"},{"internalType":"uint256","name":"tokenType","type":"uint256"},{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"bool","name":"isValid","type":"bool"}],"internalType":"struct RewardInfo[]","name":"rewardInfos","type":"tuple[]"}],"name":"setRewardAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000047e02786b3aefe45f4db89d296b5b9c5d7ed6c530000000000000000000000008186780f64aa472c16874464d21485f60826c60d000000000000000000000000241e78d45c0a7c263bf9d230a229f0bafb42cda300000000000000000000000046f9fff0252375dfe38f8e79c4983f85cc6e29ea000000000000000000000000d91423d48103eeba5ae45f179d549d6ed4fd70e9

-----Decoded View---------------
Arg [0] : dataAddress (address): 0x47e02786b3aefe45f4db89d296b5b9c5d7ed6c53
Arg [1] : luxonService (address): 0x8186780f64aa472c16874464d21485f60826c60d
Arg [2] : _lctAddress (address): 0x241e78d45c0a7c263bf9d230a229f0bafb42cda3
Arg [3] : _gachaTicketAddress (address): 0x46f9fff0252375dfe38f8e79c4983f85cc6e29ea
Arg [4] : _questStorage (address): 0xd91423d48103eeba5ae45f179d549d6ed4fd70e9

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000047e02786b3aefe45f4db89d296b5b9c5d7ed6c53
Arg [1] : 0000000000000000000000008186780f64aa472c16874464d21485f60826c60d
Arg [2] : 000000000000000000000000241e78d45c0a7c263bf9d230a229f0bafb42cda3
Arg [3] : 00000000000000000000000046f9fff0252375dfe38f8e79c4983f85cc6e29ea
Arg [4] : 000000000000000000000000d91423d48103eeba5ae45f179d549d6ed4fd70e9

97626:14919:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93503:223;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;93503:223:0;;;;;;;;104027:669;;;;;;:::i;:::-;;:::i;:::-;;;;4049:25:1;;;4105:2;4090:18;;4083:34;;;;4133:18;;;4126:34;;;;4191:2;4176:18;;4169:34;;;;4234:3;4219:19;;4212:35;4278:3;4263:19;;4256:35;4335:14;4328:22;4322:3;4307:19;;4300:51;4036:3;4021:19;104027:669:0;3740:617:1;98940:230:0;;;;;;:::i;:::-;;:::i;:::-;;49421:89;49493:9;;-1:-1:-1;;;;;49493:9:0;49421:89;;;-1:-1:-1;;;;;6392:32:1;;;6374:51;;6362:2;6347:18;49421:89:0;6228:203:1;98490:53:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;98490:53:0;;;-1:-1:-1;;;98490:53:0;;;;;;;;;;;;;;;6846:25:1;;;6902:2;6887:18;;6880:34;;;;-1:-1:-1;;;;;6950:32:1;6945:2;6930:18;;6923:60;7026:14;7019:22;7014:2;6999:18;;6992:50;6833:3;6818:19;;6621:427;106900:1636:0;;;;;;:::i;:::-;;:::i;99585:186::-;;;:::i;98413:38::-;;;;;-1:-1:-1;;;;;98413:38:0;;;49668:148;;;;;;:::i;:::-;;:::i;25246:103::-;;;:::i;30082:160::-;;;;;;:::i;:::-;;:::i;99779:3284::-;;;;;;:::i;:::-;;:::i;98373:33::-;;;;;-1:-1:-1;;;;;98373:33:0;;;29979:95;30054:12;;-1:-1:-1;;;;;30054:12:0;29979:95;;24595:87;24668:6;;-1:-1:-1;;;;;24668:6:0;24595:87;;98341:25;;;;;-1:-1:-1;;;;;98341:25:0;;;99439:138;;;;;;:::i;:::-;;:::i;94493:255::-;;;;;;:::i;:::-;-1:-1:-1;;;94493:255:0;;;;;;;;;;;-1:-1:-1;;;;;;10204:33:1;;;10186:52;;10174:2;10159:18;94493:255:0;10042:202:1;99327:106:0;;;;;;:::i;:::-;;:::i;99178:141::-;;;;;;:::i;:::-;;:::i;49518:142::-;;;;;;:::i;:::-;;:::i;94258:227::-;;;;;;:::i;:::-;-1:-1:-1;;;94258:227:0;;;;;;;;25504:201;;;;;;:::i;:::-;;:::i;105360:1030::-;;;;;;:::i;:::-;;:::i;93503:223::-;93605:4;-1:-1:-1;;;;;;93629:49:0;;-1:-1:-1;;;93629:49:0;;:89;;-1:-1:-1;;;;;;;;;;75526:40:0;;;93682:36;93622:96;93503:223;-1:-1:-1;;93503:223:0:o;104027:669::-;104193:7;104202;104211;104220;104229;104238;104247:4;104264:17;104297:19;-1:-1:-1;;;;;104284:52:0;;104337:4;104284:58;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;104264:78;-1:-1:-1;104264:78:0;104365:19;104357:41;104353:292;;104422:64;;-1:-1:-1;;;104422:64:0;;-1:-1:-1;;;;;104422:58:0;;;;;:64;;104481:4;;104422:64;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;104415:71;;;;;;;;;;;;;;;;;104353:292;104539:9;104516:18;104508:40;104504:141;;104572:61;;-1:-1:-1;;;104572:61:0;;-1:-1:-1;;;;;104572:55:0;;;;;:61;;104628:4;;104572:61;;;:::i;104504:141::-;104655:33;;-1:-1:-1;;;104655:33:0;;12925:2:1;104655:33:0;;;12907:21:1;12964:2;12944:18;;;12937:30;13003:25;12983:18;;;12976:53;13046:18;;104655:33:0;;;;;;;;104027:669;;;;;;;;;;;;;:::o;98940:230::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;99034:9:::1;99029:134;99053:11;:18;99049:1;:22;99029:134;;;99137:11;99149:1;99137:14;;;;;;;;:::i;:::-;;;;;;;99093:15;:41;99109:11;99121:1;99109:14;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;:24;99093:41;;;;::::1;::::0;;;;;;;;99109:24:::1;99093:41:::0;:58;;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;::::1;;-1:-1:-1::0;;;99093:58:0::1;-1:-1:-1::0;;;;;;99093:58:0;;;-1:-1:-1;;;;;99093:58:0;;::::1;::::0;;;;;;;::::1;::::0;;99073:3;::::1;::::0;::::1;:::i;:::-;;;;99029:134;;;;98940:230:::0;:::o;106900:1636::-;96567:1;97165:7;;:19;97157:63;;;;-1:-1:-1;;;97157:63:0;;;;;;;:::i;:::-;96567:1;97298:7;:18;30300:12:::1;::::0;30287:48:::1;::::0;-1:-1:-1;;;30287:48:0;;30329:4:::1;30287:48;::::0;::::1;6374:51:1::0;-1:-1:-1;;;;;30300:12:0;;::::1;::::0;30287:33:::1;::::0;6347:18:1;;30287:48:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30279:80;;;::::0;-1:-1:-1;;;30279:80:0;;14617:2:1;30279:80:0::1;::::0;::::1;14599:21:1::0;14656:2;14636:18;;;14629:30;-1:-1:-1;;;14675:18:1;;;14668:49;14734:18;;30279:80:0::1;14415:343:1::0;30279:80:0::1;106970:26:::2;107013:31;;;;;;;;;;;;;;-1:-1:-1::0;;;107013:31:0::2;;::::0;:14:::2;:31::i;:::-;-1:-1:-1::0;;;;;106999:63:0::2;;107063:2;106999:67;;;;;;;;;;;;;14909:25:1::0;;14897:2;14882:18;;14763:177;106999:67:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;106970:96;;107077:25;107098:3;107077:20;:25::i;:::-;107113:15;107147:33;;;;;;;;;;;;;;-1:-1:-1::0;;;107147:33:0::2;;::::0;:14:::2;:33::i;:::-;-1:-1:-1::0;;;;;107131:59:0::2;;107191:3;:11;;;107131:72;;;;;;;;;;;;;14909:25:1::0;;14897:2;14882:18;;14763:177;107131:72:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;107131:72:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;107236:12;::::0;:44:::2;::::0;-1:-1:-1;;;107236:44:0;;107113:90;;-1:-1:-1;107214:19:0::2;::::0;-1:-1:-1;;;;;107236:12:0;;::::2;::::0;:28:::2;::::0;:44:::2;::::0;107265:10:::2;::::0;107277:2;;107236:44:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;107236:44:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;107328:16;::::0;::::2;::::0;107214:66;;-1:-1:-1;107303:20:0::2;107295:49;107291:1072;;107369:10:::0;;:16;::::2;107361:47;;;::::0;-1:-1:-1;;;107361:47:0;;22671:2:1;107361:47:0::2;::::0;::::2;22653:21:1::0;22710:2;22690:18;;;22683:30;-1:-1:-1;;;22729:18:1;;;22722:48;22787:18;;107361:47:0::2;22469:342:1::0;107361:47:0::2;107428:9;107423:187;107447:2;:11;;;:18;107443:1;:22;107423:187;;;107507:2;:11;;;107519:1;107507:14;;;;;;;;:::i;:::-;;;;;;;:22;;;107499:30;;:4;:30;;;107491:103;;;::::0;-1:-1:-1;;;107491:103:0;;23018:2:1;107491:103:0::2;::::0;::::2;23000:21:1::0;23057:2;23037:18;;;23030:30;23096:34;23076:18;;;23069:62;23167:30;23147:18;;;23140:58;23215:19;;107491:103:0::2;22816:424:1::0;107491:103:0::2;107467:3:::0;::::2;::::0;::::2;:::i;:::-;;;;107423:187;;;;107650:2;:8;;;107632:15;:26;107624:91;;;::::0;-1:-1:-1;;;107624:91:0;;23447:2:1;107624:91:0::2;::::0;::::2;23429:21:1::0;23486:2;23466:18;;;23459:30;23525:34;23505:18;;;23498:62;-1:-1:-1;;;23576:18:1;;;23569:50;23636:19;;107624:91:0::2;23245:416:1::0;107624:91:0::2;107766:12;::::0;:40:::2;::::0;-1:-1:-1;;;107766:40:0;;107732:31:::2;::::0;-1:-1:-1;;;;;107766:12:0::2;::::0;:24:::2;::::0;:40:::2;::::0;107791:10:::2;::::0;107803:2;;107766:40:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;107766:40:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;107732:74;;107826:6;107821:214;107842:9;:16;107838:1;:20;107821:214;;;107912:12;::::0;107949;;107884:135:::2;::::0;-1:-1:-1;;;;;107912:12:0::2;::::0;98252:42:::2;::::0;107949:9;;107959:1;;107949:12;::::2;;;;;:::i;:::-;;;;;;;:20;;;107971:9;107981:1;107971:12;;;;;;;;:::i;:::-;;;;;;;:19;;;107992:9;108002:1;107992:12;;;;;;;;:::i;:::-;;;;;;;:26;;;107884:19;:135::i;:::-;107860:3:::0;::::2;::::0;::::2;:::i;:::-;;;;107821:214;;;-1:-1:-1::0;108083:12:0::2;::::0;:43:::2;::::0;-1:-1:-1;;;108083:43:0;;108051:29:::2;::::0;-1:-1:-1;;;;;108083:12:0::2;::::0;:27:::2;::::0;:43:::2;::::0;108111:10:::2;::::0;108123:2;;108083:43:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;108083:43:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;108051:75;;108146:9;108141:211;108165:10;:17;108161:1;:21;108141:211;;;108236:12;::::0;108263:13;;108208:128:::2;::::0;-1:-1:-1;;;;;108236:12:0::2;::::0;108251:10:::2;::::0;108263;;108274:1;;108263:13;::::2;;;;;:::i;108208:128::-;108184:3:::0;::::2;::::0;::::2;:::i;:::-;;;;108141:211;;;;107346:1017;;107291:1072;108373:12;::::0;108411::::2;::::0;::::2;::::0;108425:13:::2;::::0;;::::2;::::0;108373:66;;-1:-1:-1;;;108373:66:0;;-1:-1:-1;;;;;108373:12:0;;::::2;::::0;:21:::2;::::0;:66:::2;::::0;108395:10:::2;::::0;108407:2;;108411:12;108425:13;108373:66:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;108450:34;108461:10;108473:2;:10;;;108450;:34::i;:::-;108502:26;::::0;108525:2;;108513:10:::2;::::0;108502:26:::2;::::0;;;::::2;-1:-1:-1::0;;96523:1:0;97477:7;:22;-1:-1:-1;;106900:1636:0:o;99585:186::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;96567:1:::1;97165:7;;:19:::0;97157:63:::1;;;;-1:-1:-1::0;;;97157:63:0::1;;;;;;;:::i;:::-;96567:1;97298:7;:18:::0;;;99667:49:::2;::::0;:10:::2;::::0;99690:21:::2;::::0;97298:7;99667:49;97298:7;99667:49;99690:21;99667:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;99648:68;;;99735:7;99727:36;;;::::0;-1:-1:-1;;;99727:36:0;;26379:2:1;99727:36:0::2;::::0;::::2;26361:21:1::0;26418:2;26398:18;;;26391:30;-1:-1:-1;;;26437:18:1;;;26430:46;26493:18;;99727:36:0::2;26177:340:1::0;99727:36:0::2;-1:-1:-1::0;96523:1:0::1;97477:7;:22:::0;99585:186::o;49668:148::-;49776:9;;49761:47;;-1:-1:-1;;;49761:47:0;;49734:7;;-1:-1:-1;;;;;49776:9:0;;49761:40;;:47;;49802:5;;49761:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;25246:103::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;25311:30:::1;25338:1;25311:18;:30::i;:::-;25246:103::o:0;30082:160::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;30160:12:::1;:28:::0;;-1:-1:-1;;;;;;30160:28:0::1;-1:-1:-1::0;;;;;30160:28:0;::::1;::::0;;::::1;::::0;;;30204:30:::1;::::0;::::1;::::0;-1:-1:-1;;30204:30:0::1;30082:160:::0;:::o;99779:3284::-;96567:1;97165:7;;:19;97157:63;;;;-1:-1:-1;;;97157:63:0;;;;;;;:::i;:::-;96567:1;97298:7;:18;30300:12:::1;::::0;30287:48:::1;::::0;-1:-1:-1;;;30287:48:0;;30329:4:::1;30287:48;::::0;::::1;6374:51:1::0;-1:-1:-1;;;;;30300:12:0;;::::1;::::0;30287:33:::1;::::0;6347:18:1;;30287:48:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;30279:80;;;::::0;-1:-1:-1;;;30279:80:0;;14617:2:1;30279:80:0::1;::::0;::::1;14599:21:1::0;14656:2;14636:18;;;14629:30;-1:-1:-1;;;14675:18:1;;;14668:49;14734:18;;30279:80:0::1;14415:343:1::0;30279:80:0::1;99877:26:::2;99920:31;;;;;;;;;;;;;;-1:-1:-1::0;;;99920:31:0::2;;::::0;:14:::2;:31::i;:::-;-1:-1:-1::0;;;;;99906:63:0::2;;99970:2;99906:67;;;;;;;;;;;;;14909:25:1::0;;14897:2;14882:18;;14763:177;99906:67:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;99877:96;;99984:25;100005:3;99984:20;:25::i;:::-;100089:11;::::0;::::2;::::0;100024:12:::2;::::0;100072:13:::2;::::0;;::::2;::::0;100024:62;;-1:-1:-1;;;100024:62:0;;-1:-1:-1;;;;;100024:12:0;;::::2;::::0;:35:::2;::::0;:62:::2;::::0;100060:10:::2;::::0;100072:13;100024:62:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:76;100020:173;;;100117:12;::::0;100167:13:::2;::::0;;::::2;::::0;100117:64;;-1:-1:-1;;;100117:64:0;;-1:-1:-1;;;;;100117:12:0;;::::2;::::0;:37:::2;::::0;:64:::2;::::0;100155:10:::2;::::0;100167:13;100117:64:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;100020:173;100203:15;100237:33;;;;;;;;;;;;;;-1:-1:-1::0;;;100237:33:0::2;;::::0;:14:::2;:33::i;:::-;-1:-1:-1::0;;;;;100221:59:0::2;;100281:3;:11;;;100221:72;;;;;;;;;;;;;14909:25:1::0;;14897:2;14882:18;;14763:177;100221:72:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;100221:72:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;100203:90;;100344:9;:16;100312:2;:21;;;:28;:48;100304:82;;;::::0;-1:-1:-1;;;100304:82:0;;26980:2:1;100304:82:0::2;::::0;::::2;26962:21:1::0;27019:2;26999:18;;;26992:30;-1:-1:-1;;;27038:18:1;;;27031:51;27099:18;;100304:82:0::2;26778:345:1::0;100304:82:0::2;100434:16;::::0;::::2;::::0;100409:20:::2;100401:49:::0;100397:2615:::2;;100467:12;::::0;100505::::2;::::0;::::2;::::0;100519:13:::2;::::0;;::::2;::::0;100467:66;;-1:-1:-1;;;100467:66:0;;-1:-1:-1;;;;;100467:12:0;;::::2;::::0;:21:::2;::::0;:66:::2;::::0;100489:10:::2;::::0;100501:2;;100505:12;100519:13;100467:66:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;100548:34;100559:10;100571:2;:10;;;100548;:34::i;:::-;100397:2615;;;100615:27;100645:30;;;;;;;;;;;;;;-1:-1:-1::0;;;100645:30:0::2;;::::0;:14:::2;:30::i;:::-;100615:60;;100690:31;100724:34;;;;;;;;;;;;;;-1:-1:-1::0;;;100724:34:0::2;;::::0;:14:::2;:34::i;:::-;100690:68;;100773:30;100806:33;;;;;;;;;;;;;;-1:-1:-1::0;;;100806:33:0::2;;::::0;:14:::2;:33::i;:::-;100854:12;::::0;100894:14:::2;::::0;::::2;::::0;100854:55:::2;::::0;-1:-1:-1;;;100854:55:0;;100878:10:::2;100854:55;::::0;::::2;27330:51:1::0;27397:18;;;27390:34;;;27440:18;;;27433:34;;;;100773:66:0;;-1:-1:-1;;;;;;100854:12:0::2;::::0;:23:::2;::::0;27303:18:1;;100854:55:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;100946:12:0::2;::::0;:44:::2;::::0;-1:-1:-1;;;100946:44:0;;100924:19:::2;::::0;-1:-1:-1;;;;;;100946:12:0;;::::2;::::0;-1:-1:-1;100946:28:0::2;::::0;:44:::2;::::0;100975:10:::2;::::0;100987:2;;100946:44:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;100946:44:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;100924:66;;101018:2;:11;;;:18;101013:1;:23;101005:65;;;::::0;-1:-1:-1;;;101005:65:0;;27680:2:1;101005:65:0::2;::::0;::::2;27662:21:1::0;27719:2;27699:18;;;27692:30;27758:31;27738:18;;;27731:59;27807:18;;101005:65:0::2;27478:353:1::0;101005:65:0::2;101090:6;101085:1916;101106:9;:16;101102:1;:20;101085:1916;;;101161:9;101171:1;101161:12;;;;;;;;:::i;:::-;;;;;;;101156:1;:17:::0;101148:45:::2;;;::::0;-1:-1:-1;;;101148:45:0;;28038:2:1;101148:45:0::2;::::0;::::2;28020:21:1::0;28077:2;28057:18;;;28050:30;-1:-1:-1;;;28096:18:1;;;28089:45;28151:18;;101148:45:0::2;27836:339:1::0;101148:45:0::2;101237:10;::::0;101266:12;;101212:18:::2;::::0;-1:-1:-1;;;;;101237:10:0::2;::::0;101233:32:::2;::::0;101266:9;;101276:1;;101266:12;::::2;;;;;:::i;:::-;;;;;;;101233:46;;;;;;;;;;;;;14909:25:1::0;;14897:2;14882:18;;14763:177;101233:46:0::2;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;::::0;;::::2;-1:-1:-1::0;;101233:46:0::2;::::0;::::2;;::::0;::::2;::::0;;;::::2;::::0;::::2;:::i;:::-;101212:67;;101299:13;101318:14:::0;101334:15:::2;101351::::0;101372:97:::2;101394:19;101415:23;101440:22;101464:4;101372:21;:97::i;:::-;101298:171;;;;;;;;;;;101535:2;:21;;;101557:1;101535:24;;;;;;;;:::i;:::-;;;;;;;:38;;;101502:28;101494:37;;;;;;;;:::i;:::-;:79:::0;101490:1403:::2;;101632:2;:21;;;101654:1;101632:24;;;;;;;;:::i;:::-;;;;;;;:39;;;101614:5;101606:66;101598:149;;;::::0;-1:-1:-1;;;101598:149:0;;28724:2:1;101598:149:0::2;::::0;::::2;28706:21:1::0;28763:2;28743:18;;;28736:30;-1:-1:-1;;;;;;;;;;;28782:18:1;;;28775:62;28873:34;28853:18;;;28846:62;-1:-1:-1;;;28924:19:1;;;28917:37;28971:19;;101598:149:0::2;28522:474:1::0;101598:149:0::2;101779:2;:21;;;101801:1;101779:24;;;;;;;;:::i;:::-;;;;;;;:41;;;101774:1;:46;101770:224;;101849:121;101867:2;:21;;;101889:1;101867:24;;;;;;;;:::i;:::-;;;;;;;:41;;;101910:2;:21;;;101932:1;101910:24;;;;;;;;:::i;:::-;;;;;;;:42;;;101954:6;101962:7;101849:17;:121::i;:::-;101490:1403;;;102059:2;:21;;;102081:1;102059:24;;;;;;;;:::i;:::-;;;;;;;:38;;;102031:23;102023:32;;;;;;;;:::i;:::-;:74:::0;102019:874:::2;;102158:2;:21;;;102180:1;102158:24;;;;;;;;:::i;:::-;;;;;;;:39;;;102138:7;102130:68;102122:144;;;::::0;-1:-1:-1;;;102122:144:0;;29203:2:1;102122:144:0::2;::::0;::::2;29185:21:1::0;29242:2;29222:18;;;29215:30;-1:-1:-1;;;;;;;;;;;29261:18:1;;;29254:62;29352:33;29332:18;;;29325:61;29403:19;;102122:144:0::2;29001:427:1::0;102019:874:0::2;102573:2;:21;;;102595:1;102573:24;;;;;;;;:::i;:::-;;;;;;;:38;;;102550:18;102542:27;;;;;;;;:::i;:::-;:69:::0;102538:355:::2;;102677:2;:21;;;102699:1;102677:24;;;;;;;;:::i;:::-;;;;;;;:39;;;102652:9;102662:1;102652:12;;;;;;;;:::i;:::-;;;;;;;102644:73;102636:156;;;::::0;-1:-1:-1;;;102636:156:0;;29635:2:1;102636:156:0::2;::::0;::::2;29617:21:1::0;29674:2;29654:18;;;29647:30;-1:-1:-1;;;;;;;;;;;29693:18:1;;;29686:62;29784:34;29764:18;;;29757:62;-1:-1:-1;;;29835:19:1;;;29828:37;29882:19;;102636:156:0::2;29433:474:1::0;102538:355:0::2;102841:32;::::0;-1:-1:-1;;;102841:32:0;;30114:2:1;102841:32:0::2;::::0;::::2;30096:21:1::0;30153:2;30133:18;;;30126:30;-1:-1:-1;;;30172:18:1;;;30165:52;30234:18;;102841:32:0::2;29912:346:1::0;102538:355:0::2;102913:72;102939:2;102943:9;102953:1;102943:12;;;;;;;;:::i;:::-;;;;;;;102957:2;:21;;;102979:1;102957:24;;;;;;;;:::i;:::-;;;;;;;102983:1;102913:25;:72::i;:::-;101129:1872;;;;;101124:3;;;;;:::i;:::-;;;;101085:1916;;;;100600:2412;;;;100397:2615;103029:26;::::0;103052:2;;103040:10:::2;::::0;103029:26:::2;::::0;;;::::2;-1:-1:-1::0;;96523:1:0;97477:7;:22;-1:-1:-1;;99779:3284:0:o;99439:138::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;99529:18:::1;:40:::0;;-1:-1:-1;;;;;;99529:40:0::1;-1:-1:-1::0;;;;;99529:40:0;;;::::1;::::0;;;::::1;::::0;;99439:138::o;99327:106::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;99401:10:::1;:24:::0;;-1:-1:-1;;;;;;99401:24:0::1;-1:-1:-1::0;;;;;99401:24:0;;;::::1;::::0;;;::::1;::::0;;99327:106::o;99178:141::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;99263:12:::1;:48:::0;;-1:-1:-1;;;;;;99263:48:0::1;-1:-1:-1::0;;;;;99263:48:0;;;::::1;::::0;;;::::1;::::0;;99178:141::o;49518:142::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;49590:9:::1;:22:::0;;-1:-1:-1;;;;;;49590:22:0::1;-1:-1:-1::0;;;;;49590:22:0;::::1;::::0;;::::1;::::0;;;49628:24:::1;::::0;::::1;::::0;-1:-1:-1;;49628:24:0::1;49518:142:::0;:::o;25504:201::-;24668:6;;-1:-1:-1;;;;;24668:6:0;23399:10;24815:23;24807:68;;;;-1:-1:-1;;;24807:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;25593:22:0;::::1;25585:73;;;::::0;-1:-1:-1;;;25585:73:0;;30465:2:1;25585:73:0::1;::::0;::::1;30447:21:1::0;30504:2;30484:18;;;30477:30;30543:34;30523:18;;;30516:62;-1:-1:-1;;;30594:18:1;;;30587:36;30640:19;;25585:73:0::1;30263:402:1::0;25585:73:0::1;25669:28;25688:8;25669:18;:28::i;:::-;25504:201:::0;:::o;105360:1030::-;96567:1;97165:7;;:19;97157:63;;;;-1:-1:-1;;;97157:63:0;;;;;;;:::i;:::-;96567:1;97298:7;:18;;;105467:31:::1;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;105467:31:0::1;::::0;::::1;::::0;::::1;::::0;:14:::1;:31::i;:::-;-1:-1:-1::0;;;;;105453:63:0::1;;105517:2;105453:67;;;;;;;;;;;;;14909:25:1::0;;14897:2;14882:18;;14763:177;105453:67:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;105424:96;;105531:26;105553:3;105531:21;:26::i;:::-;105590:12;::::0;:44:::1;::::0;-1:-1:-1;;;105590:44:0;;105568:19:::1;::::0;-1:-1:-1;;;;;105590:12:0::1;::::0;:28:::1;::::0;:44:::1;::::0;105619:10:::1;::::0;105631:2;;105590:44:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;105590:44:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;105653:10:::0;;105568:66;;-1:-1:-1;105653:16:0;::::1;105645:47;;;::::0;-1:-1:-1;;;105645:47:0;;22671:2:1;105645:47:0::1;::::0;::::1;22653:21:1::0;22710:2;22690:18;;;22683:30;-1:-1:-1;;;22729:18:1;;;22722:48;22787:18;;105645:47:0::1;22469:342:1::0;105645:47:0::1;105735:12;::::0;:43:::1;::::0;-1:-1:-1;;;105735:43:0;;105703:29:::1;::::0;-1:-1:-1;;;;;105735:12:0::1;::::0;:27:::1;::::0;:43:::1;::::0;105763:10:::1;::::0;105775:2;;105735:43:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;105735:43:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;105703:75;;105794:9;105789:203;105813:10;:17;105809:1;:21;105789:203;;;105880:12;::::0;105907:13;;105852:128:::1;::::0;-1:-1:-1;;;;;105880:12:0::1;::::0;105895:10:::1;::::0;105907;;105918:1;;105907:13;::::1;;;;;:::i;105852:128::-;105832:3:::0;::::1;::::0;::::1;:::i;:::-;;;;105789:203;;;-1:-1:-1::0;106038:12:0::1;::::0;:40:::1;::::0;-1:-1:-1;;;106038:40:0;;106004:31:::1;::::0;-1:-1:-1;;;;;106038:12:0::1;::::0;:24:::1;::::0;:40:::1;::::0;106063:10:::1;::::0;106075:2;;106038:40:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;106038:40:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;106004:74;;106094:6;106089:196;106110:9;:16;106106:1;:20;106089:196;;;106176:12;::::0;106203;;106148:125:::1;::::0;-1:-1:-1;;;;;106176:12:0::1;::::0;106191:10:::1;::::0;106203:9;;106213:1;;106203:12;::::1;;;;;:::i;106148:125::-;106128:3:::0;::::1;::::0;::::1;:::i;:::-;;;;106089:196;;;-1:-1:-1::0;106297:12:0::1;::::0;:40:::1;::::0;-1:-1:-1;;;106297:40:0;;-1:-1:-1;;;;;106297:12:0;;::::1;::::0;:24:::1;::::0;:40:::1;::::0;106322:10:::1;::::0;106334:2;;106297:40:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;106355:27:0::1;::::0;106379:2;;-1:-1:-1;106367:10:0::1;::::0;-1:-1:-1;106355:27:0::1;::::0;;;::::1;-1:-1:-1::0;;96523:1:0;97477:7;:22;-1:-1:-1;;;105360:1030:0:o;108544:948::-;108634:3;:11;;;108626:39;;;;-1:-1:-1;;;108626:39:0;;30872:2:1;108626:39:0;;;30854:21:1;30911:2;30891:18;;;30884:30;-1:-1:-1;;;30930:18:1;;;30923:45;30985:18;;108626:39:0;30670:339:1;108626:39:0;108699:15;108684:3;:11;;;:30;;:61;;;;;108736:3;:9;;;108718:15;:27;108684:61;108676:88;;;;-1:-1:-1;;;108676:88:0;;31216:2:1;108676:88:0;;;31198:21:1;31255:2;31235:18;;;31228:30;-1:-1:-1;;;31274:18:1;;;31267:44;31328:18;;108676:88:0;31014:338:1;108676:88:0;108879:12;;108922:6;;108930:13;;;;108945:12;;;;108879:79;;-1:-1:-1;;;108879:79:0;;108776:18;;;;;;;;-1:-1:-1;;;;;108879:12:0;;;;:30;;:79;;108910:10;;108922:6;;108930:13;;108945:12;108879:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;108775:183;;;;;;;;108998:16;108977:17;:37;108969:74;;;;-1:-1:-1;;;108969:74:0;;31932:2:1;108969:74:0;;;31914:21:1;31971:2;31951:18;;;31944:30;-1:-1:-1;;;31990:18:1;;;31983:54;32054:18;;108969:74:0;31730:348:1;108969:74:0;109063:13;;;;109058:18;109054:142;;109121:18;109101:17;:38;109093:91;;;;-1:-1:-1;;;109093:91:0;;;;;;;:::i;:::-;109229:3;:17;;;109210:36;;;;;;;;:::i;:::-;:15;:36;109206:158;;109291:3;:13;;;109271:17;:33;109263:89;;;;-1:-1:-1;;;109263:89:0;;32694:2:1;109263:89:0;;;32676:21:1;32733:2;32713:18;;;32706:30;32772:34;32752:18;;;32745:62;-1:-1:-1;;;32823:18:1;;;32816:41;32874:19;;109263:89:0;32492:407:1;109263:89:0;109397:3;:13;;;109378:32;;;;;;;;:::i;:::-;:15;:32;109374:111;;109448:3;:9;;;109435:10;:22;109427:46;;;;-1:-1:-1;;;109427:46:0;;33106:2:1;109427:46:0;;;33088:21:1;33145:2;33125:18;;;33118:30;-1:-1:-1;;;33164:18:1;;;33157:41;33215:18;;109427:46:0;32904:335:1;109427:46:0;108615:877;;;;108544:948;:::o;111768:774::-;111943:14;111915:23;111907:50;:109;;;-1:-1:-1;112002:14:0;111969:28;111961:55;111907:109;111903:632;;;112041:10;;;112033:54;;-1:-1:-1;;;112033:54:0;;-1:-1:-1;;;;;33502:15:1;;;112033:54:0;;;33484:34:1;;;;33554:15;;;33534:18;;;33527:43;33586:18;;;33579:34;;;112041:10:0;;;112033:32;;33419:18:1;;112033:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;112138:10:0;;112107:77;;;33826:25:1;;;33882:2;33867:18;;33860:34;;;33910:18;;;33903:34;;;-1:-1:-1;;;;;112138:10:0;;;;-1:-1:-1;112107:77:0;;;;-1:-1:-1;112107:77:0;;;;;;33814:2:1;33799:18;112107:77:0;;;;;;;;111903:632;;;112237:14;112214:18;112206:45;112202:333;;112282:18;;112268:85;;-1:-1:-1;;;112268:85:0;;-1:-1:-1;;;;;34299:15:1;;;112268:85:0;;;34281:34:1;34351:15;;;34331:18;;;34324:43;34383:18;;;34376:34;;;34426:18;;;34419:34;;;34261:3;34469:19;;;34462:32;-1:-1:-1;34510:19:1;;;34503:30;112282:18:0;;;;112268:50;;34550:19:1;;112268:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;112404:18:0;;112373:85;;;33826:25:1;;;33882:2;33867:18;;33860:34;;;33910:18;;;33903:34;;;-1:-1:-1;;;;;112404:18:0;;;;-1:-1:-1;112373:85:0;;;;-1:-1:-1;112373:85:0;;;;;;33814:2:1;33799:18;112373:85:0;33624:319:1;110697:1063:0;110780:9;110775:978;110799:8;:15;110795:1;:19;110775:978;;;110836:28;110867:15;:39;110883:8;110892:1;110883:11;;;;;;;;:::i;:::-;;;;;;;;;;;;:22;110867:39;;;;;;;;;;;;;-1:-1:-1;110867:39:0;110836:70;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;110836:70:0;;;;;;;;;-1:-1:-1;;;110836:70:0;;;;;;;;;;;;;;-1:-1:-1;110921:47:0;;;;-1:-1:-1;;;110921:47:0;;34782:2:1;110921:47:0;;;34764:21:1;34821:2;34801:18;;;34794:30;-1:-1:-1;;;34840:18:1;;;34833:46;34896:18;;110921:47:0;34580:340:1;110921:47:0;111017:20;;;;110995:17;110987:50;110983:610;;111072:10;:23;;;-1:-1:-1;;;;;111058:43:0;;111102:3;111107:8;111116:1;111107:11;;;;;;;;:::i;:::-;;;;;;;:18;;;111127:8;111136:1;111127:11;;;;;;;;:::i;:::-;;;;;;;;;;;:24;;;;;111058:97;;-1:-1:-1;;;;;;111058:97:0;;;;;;;-1:-1:-1;;;;;35210:32:1;;;111058:97:0;;;35192:51:1;35259:18;;;35252:34;;;;35302:18;;;35295:34;35365:3;35345:18;;;35338:31;-1:-1:-1;35385:19:1;;;35378:30;35425:19;;111058:97:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;110983:610;;;111209:20;;;;111189:15;111181:48;111177:416;;111262:10;:23;;;-1:-1:-1;;;;;111250:45:0;;111296:3;111301:8;111310:1;111301:11;;;;;;;;:::i;:::-;;;;;;;:24;;;111250:76;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;111177:416;;;111381:20;;;;111360:16;111352:49;111348:245;;111430:10;:23;;;-1:-1:-1;;;;;111422:45:0;;111476:4;111483:3;111488:8;111497:1;111488:11;;;;;;;;:::i;:::-;;;;;;;;;;;;:18;;111422:85;;-1:-1:-1;;;;;;111422:85:0;;;;;;;-1:-1:-1;;;;;33502:15:1;;;111422:85:0;;;33484:34:1;33554:15;;;;33534:18;;;33527:43;33586:18;;;33579:34;33419:18;;111422:85:0;33244:375:1;111348:245:0;111548:29;;-1:-1:-1;;;111548:29:0;;35657:2:1;111548:29:0;;;35639:21:1;35696:2;35676:18;;;35669:30;-1:-1:-1;;;35715:18:1;;;35708:49;35774:18;;111548:29:0;35455:343:1;111348:245:0;111640:10;:23;;;-1:-1:-1;;;;;111612:129:0;111635:3;-1:-1:-1;;;;;111612:129:0;111623:10;-1:-1:-1;;;;;111612:129:0;;111673:10;:20;;;111696:8;111705:1;111696:11;;;;;;;;:::i;:::-;;;;;;;:18;;;111716:8;111725:1;111716:11;;;;;;;;:::i;:::-;;;;;;;:24;;;111612:129;;;;;;;33826:25:1;;;33882:2;33867:18;;33860:34;;;;33925:2;33910:18;;33903:34;33814:2;33799:18;;33624:319;111612:129:0;;;;;;;;-1:-1:-1;110816:3:0;;;;:::i;:::-;;;;110775:978;;;;110697:1063;;:::o;25865:191::-;25958:6;;;-1:-1:-1;;;;;25975:17:0;;;-1:-1:-1;;;;;;25975:17:0;;;;;;;26008:40;;25958:6;;;25975:17;25958:6;;26008:40;;25939:16;;26008:40;25928:128;25865:191;:::o;104704:648::-;104883:13;104847:31;104839:57;104835:510;;104949:14;104929:7;104921:43;104913:129;;;;-1:-1:-1;;;104913:129:0;;36005:2:1;104913:129:0;;;35987:21:1;36044:2;36024:18;;;36017:30;-1:-1:-1;;;;;;;;;;;36063:18:1;;;36056:62;36154:34;36134:18;;;36127:62;-1:-1:-1;;;36205:19:1;;;36198:40;36255:19;;104913:129:0;35803:477:1;104913:129:0;104835:510;;;105107:13;105072:30;105064:56;105060:285;;105172:14;105153:6;105145:42;105137:127;;;;-1:-1:-1;;;105137:127:0;;36487:2:1;105137:127:0;;;36469:21:1;36526:2;36506:18;;;36499:30;-1:-1:-1;;;;;;;;;;;36545:18:1;;;36538:62;36636:34;36616:18;;;36609:62;-1:-1:-1;;;36687:19:1;;;36680:39;36736:19;;105137:127:0;36285:476:1;105060:285:0;105297:36;;-1:-1:-1;;;105297:36:0;;36968:2:1;105297:36:0;;;36950:21:1;37007:2;36987:18;;;36980:30;37046:28;37026:18;;;37019:56;37092:18;;105297:36:0;36766:350:1;105060:285:0;104704:648;;;;:::o;109652:1037::-;109823:33;;;;109887:29;;109944:35;;;;109887:29;110002:16;109994:38;109990:615;;110049:12;;:81;;-1:-1:-1;;;110049:81:0;;110078:10;110049:81;;;37408:51:1;37475:18;;;37468:34;;;37518:18;;;37511:34;;;37561:18;;;37554:34;;;37604:19;;;37597:35;;;37648:19;;;37641:35;;;-1:-1:-1;;;;;110049:12:0;;;;:28;;37380:19:1;;110049:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;110185:12:0;;110145:87;;-1:-1:-1;110165:10:0;;-1:-1:-1;;;;;;110185:12:0;110200:8;110210:6;110218:13;110145:19;:87::i;:::-;109990:615;;;110284:9;110262:17;110254:39;:83;;;-1:-1:-1;110328:9:0;110305:18;110297:40;110254:83;110250:355;;;110354:12;;:74;;-1:-1:-1;;;110354:74:0;;110380:10;110354:74;;;37946:51:1;38013:18;;;38006:34;;;38056:18;;;38049:34;;;38099:18;;;38092:34;;;38142:19;;;38135:35;;;-1:-1:-1;;;;;110354:12:0;;;;:25;;37918:19:1;;110354:74:0;37687:489:1;110250:355:0;110563:30;;-1:-1:-1;;;110563:30:0;;38383:2:1;110563:30:0;;;38365:21:1;38422:2;38402:18;;;38395:30;-1:-1:-1;;;38441:18:1;;;38434:50;38501:18;;110563:30:0;38181:344:1;110250:355:0;110615:12;;:66;;-1:-1:-1;;;110615:66:0;;110640:10;110615:66;;;37946:51:1;38013:18;;;38006:34;;;38056:18;;;38049:34;;;38099:18;;;38092:34;;;38142:19;;;38135:35;;;-1:-1:-1;;;;;110615:12:0;;;;:24;;37918:19:1;;110615:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;109788:901;;;109652:1037;;;;:::o;106398:494::-;106568:12;;106611:6;;106619:13;;;;106634:12;;;;106568:79;;-1:-1:-1;;;106568:79:0;;106485:25;;;;;;-1:-1:-1;;;;;106568:12:0;;;;:30;;:79;;106599:10;;106611:6;106619:13;;106568:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;106481:166;;;;;;;106687:16;106666:17;:37;106658:74;;;;-1:-1:-1;;;106658:74:0;;31932:2:1;106658:74:0;;;31914:21:1;31971:2;31951:18;;;31944:30;-1:-1:-1;;;31990:18:1;;;31983:54;32054:18;;106658:74:0;31730:348:1;106658:74:0;106752:13;;;;106747:18;106743:142;;106810:18;106790:17;:38;106782:91;;;;-1:-1:-1;;;106782:91:0;;;;;;;:::i;14:286:1:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;199:71;289:5;14:286;-1:-1:-1;;;14:286:1:o;497:131::-;-1:-1:-1;;;;;572:31:1;;562:42;;552:70;;618:1;615;608:12;633:127;694:10;689:3;685:20;682:1;675:31;725:4;722:1;715:15;749:4;746:1;739:15;765:253;837:2;831:9;879:4;867:17;;-1:-1:-1;;;;;899:34:1;;935:22;;;896:62;893:88;;;961:18;;:::i;:::-;997:2;990:22;765:253;:::o;1023:252::-;1095:2;1089:9;1137:3;1125:16;;-1:-1:-1;;;;;1156:34:1;;1192:22;;;1153:62;1150:88;;;1218:18;;:::i;1280:253::-;1352:2;1346:9;1394:4;1382:17;;-1:-1:-1;;;;;1414:34:1;;1450:22;;;1411:62;1408:88;;;1476:18;;:::i;1538:253::-;1610:2;1604:9;1652:4;1640:17;;-1:-1:-1;;;;;1672:34:1;;1708:22;;;1669:62;1666:88;;;1734:18;;:::i;1796:253::-;1868:2;1862:9;1910:4;1898:17;;-1:-1:-1;;;;;1930:34:1;;1966:22;;;1927:62;1924:88;;;1992:18;;:::i;2054:275::-;2125:2;2119:9;2190:2;2171:13;;-1:-1:-1;;2167:27:1;2155:40;;-1:-1:-1;;;;;2210:34:1;;2246:22;;;2207:62;2204:88;;;2272:18;;:::i;:::-;2308:2;2301:22;2054:275;;-1:-1:-1;2054:275:1:o;2334:187::-;2383:4;-1:-1:-1;;;;;2408:6:1;2405:30;2402:56;;;2438:18;;:::i;:::-;-1:-1:-1;2504:2:1;2483:15;-1:-1:-1;;2479:29:1;2510:4;2475:40;;2334:187::o;2526:464::-;2569:5;2622:3;2615:4;2607:6;2603:17;2599:27;2589:55;;2640:1;2637;2630:12;2589:55;2676:6;2663:20;2707:49;2723:32;2752:2;2723:32;:::i;:::-;2707:49;:::i;:::-;2781:2;2772:7;2765:19;2827:3;2820:4;2815:2;2807:6;2803:15;2799:26;2796:35;2793:55;;;2844:1;2841;2834:12;2793:55;2909:2;2902:4;2894:6;2890:17;2883:4;2874:7;2870:18;2857:55;2957:1;2932:16;;;2950:4;2928:27;2921:38;;;;2936:7;2526:464;-1:-1:-1;;;2526:464:1:o;2995:740::-;3091:6;3099;3107;3115;3168:3;3156:9;3147:7;3143:23;3139:33;3136:53;;;3185:1;3182;3175:12;3136:53;3224:9;3211:23;3243:31;3268:5;3243:31;:::i;:::-;3293:5;-1:-1:-1;3350:2:1;3335:18;;3322:32;3363:33;3322:32;3363:33;:::i;:::-;3415:7;-1:-1:-1;3474:2:1;3459:18;;3446:32;3487:33;3446:32;3487:33;:::i;:::-;3539:7;-1:-1:-1;3597:2:1;3582:18;;3569:32;-1:-1:-1;;;;;3613:30:1;;3610:50;;;3656:1;3653;3646:12;3610:50;3679;3721:7;3712:6;3701:9;3697:22;3679:50;:::i;:::-;3669:60;;;2995:740;;;;;;;:::o;4362:193::-;4432:4;-1:-1:-1;;;;;4457:6:1;4454:30;4451:56;;;4487:18;;:::i;:::-;-1:-1:-1;4532:1:1;4528:14;4544:4;4524:25;;4362:193::o;4560:118::-;4646:5;4639:13;4632:21;4625:5;4622:32;4612:60;;4668:1;4665;4658:12;4683:1540;4794:6;4825:2;4868;4856:9;4847:7;4843:23;4839:32;4836:52;;;4884:1;4881;4874:12;4836:52;4924:9;4911:23;-1:-1:-1;;;;;4949:6:1;4946:30;4943:50;;;4989:1;4986;4979:12;4943:50;5012:22;;5065:4;5057:13;;5053:27;-1:-1:-1;5043:55:1;;5094:1;5091;5084:12;5043:55;5130:2;5117:16;5153:70;5169:53;5219:2;5169:53;:::i;5153:70::-;5257:15;;;5339:1;5335:10;;;;5327:19;;5323:28;;;5288:12;;;;5363:19;;;5360:39;;;5395:1;5392;5385:12;5360:39;5419:11;;;;5439:754;5455:6;5450:3;5447:15;5439:754;;;5537:4;5531:3;5522:7;5518:17;5514:28;5511:118;;;5583:1;5612:2;5608;5601:14;5511:118;5655:22;;:::i;:::-;5717:3;5704:17;5697:5;5690:32;5780:2;5775:3;5771:12;5758:26;5753:2;5746:5;5742:14;5735:50;5808:2;5860;5855:3;5851:12;5838:26;5877:33;5902:7;5877:33;:::i;:::-;5930:14;;;5923:31;5977:2;6020:12;;;6007:26;6046:30;6007:26;6046:30;:::i;:::-;6096:14;;;6089:31;6133:18;;5481:4;5472:14;;;;;6171:12;;;;5439:754;;;6212:5;4683:1540;-1:-1:-1;;;;;;;4683:1540:1:o;6436:180::-;6495:6;6548:2;6536:9;6527:7;6523:23;6519:32;6516:52;;;6564:1;6561;6554:12;6516:52;-1:-1:-1;6587:23:1;;6436:180;-1:-1:-1;6436:180:1:o;7288:322::-;7357:6;7410:2;7398:9;7389:7;7385:23;7381:32;7378:52;;;7426:1;7423;7416:12;7378:52;7466:9;7453:23;-1:-1:-1;;;;;7491:6:1;7488:30;7485:50;;;7531:1;7528;7521:12;7485:50;7554;7596:7;7587:6;7576:9;7572:22;7554:50;:::i;:::-;7544:60;7288:322;-1:-1:-1;;;;7288:322:1:o;7615:247::-;7674:6;7727:2;7715:9;7706:7;7702:23;7698:32;7695:52;;;7743:1;7740;7733:12;7695:52;7782:9;7769:23;7801:31;7826:5;7801:31;:::i;7867:672::-;7921:5;7974:3;7967:4;7959:6;7955:17;7951:27;7941:55;;7992:1;7989;7982:12;7941:55;8028:6;8015:20;8054:4;8078:70;8094:53;8144:2;8094:53;:::i;8078:70::-;8182:15;;;8268:1;8264:10;;;;8252:23;;8248:32;;;8213:12;;;;8292:15;;;8289:35;;;8320:1;8317;8310:12;8289:35;8356:2;8348:6;8344:15;8368:142;8384:6;8379:3;8376:15;8368:142;;;8450:17;;8438:30;;8488:12;;;;8401;;8368:142;;;-1:-1:-1;8528:5:1;7867:672;-1:-1:-1;;;;;;7867:672:1:o;8544:416::-;8637:6;8645;8698:2;8686:9;8677:7;8673:23;8669:32;8666:52;;;8714:1;8711;8704:12;8666:52;8750:9;8737:23;8727:33;;8811:2;8800:9;8796:18;8783:32;-1:-1:-1;;;;;8830:6:1;8827:30;8824:50;;;8870:1;8867;8860:12;8824:50;8893:61;8946:7;8937:6;8926:9;8922:22;8893:61;:::i;:::-;8883:71;;;8544:416;;;;;:::o;8965:1072::-;9119:6;9127;9135;9143;9151;9204:3;9192:9;9183:7;9179:23;9175:33;9172:53;;;9221:1;9218;9211:12;9172:53;9260:9;9247:23;9279:31;9304:5;9279:31;:::i;:::-;9329:5;-1:-1:-1;9386:2:1;9371:18;;9358:32;9399:33;9358:32;9399:33;:::i;:::-;9451:7;-1:-1:-1;9509:2:1;9494:18;;9481:32;-1:-1:-1;;;;;9562:14:1;;;9559:34;;;9589:1;9586;9579:12;9559:34;9612:61;9665:7;9656:6;9645:9;9641:22;9612:61;:::i;:::-;9602:71;;9726:2;9715:9;9711:18;9698:32;9682:48;;9755:2;9745:8;9742:16;9739:36;;;9771:1;9768;9761:12;9739:36;9794:63;9849:7;9838:8;9827:9;9823:24;9794:63;:::i;:::-;9784:73;;9910:3;9899:9;9895:19;9882:33;9866:49;;9940:2;9930:8;9927:16;9924:36;;;9956:1;9953;9946:12;9924:36;;9979:52;10023:7;10012:8;10001:9;9997:24;9979:52;:::i;:::-;9969:62;;;8965:1072;;;;;;;;:::o;10249:735::-;10353:6;10361;10369;10377;10385;10438:3;10426:9;10417:7;10413:23;10409:33;10406:53;;;10455:1;10452;10445:12;10406:53;10494:9;10481:23;10513:31;10538:5;10513:31;:::i;:::-;10563:5;-1:-1:-1;10620:2:1;10605:18;;10592:32;10633:33;10592:32;10633:33;:::i;:::-;10685:7;-1:-1:-1;10739:2:1;10724:18;;10711:32;;-1:-1:-1;10790:2:1;10775:18;;10762:32;;-1:-1:-1;10845:3:1;10830:19;;10817:33;-1:-1:-1;;;;;10862:30:1;;10859:50;;;10905:1;10902;10895:12;10859:50;10928;10970:7;10961:6;10950:9;10946:22;10928:50;:::i;10989:250::-;11074:1;11084:113;11098:6;11095:1;11092:13;11084:113;;;11174:11;;;11168:18;11155:11;;;11148:39;11120:2;11113:10;11084:113;;;-1:-1:-1;;11231:1:1;11213:16;;11206:27;10989:250::o;11244:396::-;11393:2;11382:9;11375:21;11356:4;11425:6;11419:13;11468:6;11463:2;11452:9;11448:18;11441:34;11484:79;11556:6;11551:2;11540:9;11536:18;11531:2;11523:6;11519:15;11484:79;:::i;:::-;11624:2;11603:15;-1:-1:-1;;11599:29:1;11584:45;;;;11631:2;11580:54;;11244:396;-1:-1:-1;;11244:396:1:o;11645:184::-;11715:6;11768:2;11756:9;11747:7;11743:23;11739:32;11736:52;;;11784:1;11781;11774:12;11736:52;-1:-1:-1;11807:16:1;;11645:184;-1:-1:-1;11645:184:1:o;11834:127::-;11895:10;11890:3;11886:20;11883:1;11876:31;11926:4;11923:1;11916:15;11950:4;11947:1;11940:15;11966:132;12042:13;;12064:28;12042:13;12064:28;:::i;:::-;11966:132;;;:::o;12103:615::-;12224:6;12232;12240;12248;12256;12264;12272;12325:3;12313:9;12304:7;12300:23;12296:33;12293:53;;;12342:1;12339;12332:12;12293:53;12371:9;12365:16;12355:26;;12421:2;12410:9;12406:18;12400:25;12390:35;;12465:2;12454:9;12450:18;12444:25;12434:35;;12509:2;12498:9;12494:18;12488:25;12478:35;;12553:3;12542:9;12538:19;12532:26;12522:36;;12598:3;12587:9;12583:19;12577:26;12567:36;;12646:3;12635:9;12631:19;12625:26;12660:28;12682:5;12660:28;:::i;:::-;12707:5;12697:15;;;12103:615;;;;;;;;;;:::o;13075:356::-;13277:2;13259:21;;;13296:18;;;13289:30;13355:34;13350:2;13335:18;;13328:62;13422:2;13407:18;;13075:356::o;13436:127::-;13497:10;13492:3;13488:20;13485:1;13478:31;13528:4;13525:1;13518:15;13552:4;13549:1;13542:15;13568:232;13607:3;13628:17;;;13625:140;;13687:10;13682:3;13678:20;13675:1;13668:31;13722:4;13719:1;13712:15;13750:4;13747:1;13740:15;13625:140;-1:-1:-1;13792:1:1;13781:13;;13568:232::o;13805:355::-;14007:2;13989:21;;;14046:2;14026:18;;;14019:30;14085:33;14080:2;14065:18;;14058:61;14151:2;14136:18;;13805:355::o;14165:245::-;14232:6;14285:2;14273:9;14264:7;14260:23;14256:32;14253:52;;;14301:1;14298;14291:12;14253:52;14333:9;14327:16;14352:28;14374:5;14352:28;:::i;14945:154::-;15031:13;;15073:1;15063:12;;15053:40;;15089:1;15086;15079:12;15104:1107;15206:6;15259:3;15247:9;15238:7;15234:23;15230:33;15227:53;;;15276:1;15273;15266:12;15227:53;15302:22;;:::i;:::-;15353:9;15347:16;15340:5;15333:31;15417:2;15406:9;15402:18;15396:25;15391:2;15384:5;15380:14;15373:49;15475:2;15464:9;15460:18;15454:25;15449:2;15442:5;15438:14;15431:49;15533:2;15522:9;15518:18;15512:25;15507:2;15500:5;15496:14;15489:49;15592:3;15581:9;15577:19;15571:26;15565:3;15558:5;15554:15;15547:51;15652:3;15641:9;15637:19;15631:26;15625:3;15618:5;15614:15;15607:51;15691:57;15743:3;15732:9;15728:19;15691:57;:::i;:::-;15685:3;15678:5;15674:15;15667:82;15803:3;15792:9;15788:19;15782:26;15776:3;15769:5;15765:15;15758:51;15828:3;15863:56;15915:2;15904:9;15900:18;15863:56;:::i;:::-;15847:14;;;15840:80;15939:3;15980:18;;;15974:25;15958:14;;;15951:49;16019:3;16060:18;;;16054:25;16038:14;;;16031:49;16099:3;16134:46;16161:18;;;16134:46;:::i;:::-;16118:14;;;16111:70;16122:5;15104:1107;-1:-1:-1;;;15104:1107:1:o;16216:443::-;16270:5;16323:3;16316:4;16308:6;16304:17;16300:27;16290:55;;16341:1;16338;16331:12;16290:55;16370:6;16364:13;16401:49;16417:32;16446:2;16417:32;:::i;16401:49::-;16475:2;16466:7;16459:19;16521:3;16514:4;16509:2;16501:6;16497:15;16493:26;16490:35;16487:55;;;16538:1;16535;16528:12;16487:55;16551:77;16625:2;16618:4;16609:7;16605:18;16598:4;16590:6;16586:17;16551:77;:::i;16664:944::-;16760:5;16789:74;16805:57;16855:6;16805:57;:::i;16789:74::-;16897:21;;;16780:83;-1:-1:-1;16937:4:1;16957:14;;;;16990:4;17029:15;;;17017:28;;17057:15;;;17054:35;;;17085:1;17082;17075:12;17054:35;17109:6;17124:478;17140:6;17135:3;17132:15;17124:478;;;17216:2;17210:3;17205;17201:13;17197:22;17194:112;;;17260:1;17289:2;17285;17278:14;17194:112;17332:22;;:::i;:::-;17381:10;;17367:25;;17434:12;;;17428:19;17412:14;;;17405:43;17471:2;17515:12;;;17509:19;17493:14;;;17486:43;17542:18;;17580:12;;;;17157;;17124:478;;;17128:3;;;;;16664:944;;;;;:::o;17613:271::-;17684:5;17737:3;17730:4;17722:6;17718:17;17714:27;17704:55;;17755:1;17752;17745:12;17704:55;17777:101;17874:3;17865:6;17859:13;17852:4;17844:6;17840:17;17777:101;:::i;17889:1299::-;17972:5;18025:3;18018:4;18010:6;18006:17;18002:27;17992:55;;18043:1;18040;18033:12;17992:55;18072:6;18066:13;18098:4;18122:70;18138:53;18188:2;18138:53;:::i;18122:70::-;18226:15;;;18288:4;18331:11;;;18319:24;;18315:33;;;18257:12;;;;18214:3;18360:15;;;18357:35;;;18388:1;18385;18378:12;18357:35;18424:2;18416:6;18412:15;18436:723;18452:6;18447:3;18444:15;18436:723;;;18528:2;18522:3;18517;18513:13;18509:22;18506:112;;;18572:1;18601:2;18597;18590:14;18506:112;18644:22;;:::i;:::-;18693:10;;18679:25;;18746:12;;;18740:19;18724:14;;;18717:43;18783:2;18827:12;;;18821:19;18805:14;;;18798:43;18864:2;18908:12;;;18902:19;18886:14;;;18879:43;18945:3;18990:12;;;18984:19;18968:14;;;18961:43;19027:3;19072:12;;;19066:19;19050:14;;;19043:43;19099:18;;19137:12;;;;18469;;18436:723;;;-1:-1:-1;19177:5:1;;17889:1299;-1:-1:-1;;;;;;;17889:1299:1:o;19193:1224::-;19285:6;19338:2;19326:9;19317:7;19313:23;19309:32;19306:52;;;19354:1;19351;19344:12;19306:52;19387:9;19381:16;-1:-1:-1;;;;;19457:2:1;19449:6;19446:14;19443:34;;;19473:1;19470;19463:12;19443:34;19496:22;;;;19552:4;19534:16;;;19530:27;19527:47;;;19570:1;19567;19560:12;19527:47;19596:22;;:::i;:::-;19647:2;19641:9;19634:5;19627:24;19690:2;19686;19682:11;19676:18;19719:2;19709:8;19706:16;19703:36;;;19735:1;19732;19725:12;19703:36;19771:56;19819:7;19808:8;19804:2;19800:17;19771:56;:::i;:::-;19766:2;19759:5;19755:14;19748:80;;19874:2;19870;19866:11;19860:18;19855:2;19848:5;19844:14;19837:42;19925:2;19921;19917:11;19911:18;19906:2;19899:5;19895:14;19888:42;19977:3;19973:2;19969:12;19963:19;19957:3;19950:5;19946:15;19939:44;20022:3;20018:2;20014:12;20008:19;20052:2;20042:8;20039:16;20036:36;;;20068:1;20065;20058:12;20036:36;20105:73;20170:7;20159:8;20155:2;20151:17;20105:73;:::i;:::-;20099:3;20092:5;20088:15;20081:98;;20218:3;20214:2;20210:12;20204:19;20248:2;20238:8;20235:16;20232:36;;;20264:1;20261;20254:12;20232:36;20301:85;20378:7;20367:8;20363:2;20359:17;20301:85;:::i;:::-;20295:3;20284:15;;20277:110;-1:-1:-1;20288:5:1;19193:1224;-1:-1:-1;;;;;19193:1224:1:o;20422:274::-;-1:-1:-1;;;;;20614:32:1;;;;20596:51;;20678:2;20663:18;;20656:34;20584:2;20569:18;;20422:274::o;20701:1763::-;20797:6;20828:2;20871;20859:9;20850:7;20846:23;20842:32;20839:52;;;20887:1;20884;20877:12;20839:52;20920:9;20914:16;-1:-1:-1;;;;;20990:2:1;20982:6;20979:14;20976:34;;;21006:1;21003;20996:12;20976:34;21029:22;;;;21085:4;21067:16;;;21063:27;21060:47;;;21103:1;21100;21093:12;21060:47;21129:22;;:::i;:::-;21180:2;21174:9;21167:5;21160:24;21230:2;21226;21222:11;21216:18;21211:2;21204:5;21200:14;21193:42;21254:2;21302;21298;21294:11;21288:18;21283:2;21276:5;21272:14;21265:42;21326:2;21367;21363;21359:11;21353:18;21396:2;21386:8;21383:16;21380:36;;;21412:1;21409;21402:12;21380:36;21443:8;21439:2;21435:17;21425:27;;;21490:7;21483:4;21479:2;21475:13;21471:27;21461:55;;21512:1;21509;21502:12;21461:55;21541:2;21535:9;21525:19;;21564:70;21580:53;21630:2;21580:53;:::i;21564:70::-;21668:15;;;21746:11;;;21738:20;;21734:29;;;21699:12;;;;21775:19;;;21772:39;;;21807:1;21804;21797:12;21772:39;21831:11;;;;21851:545;21867:6;21862:3;21859:15;21851:545;;;21947:2;21941:3;21932:7;21928:17;21924:26;21921:116;;;21991:1;22020:2;22016;22009:14;21921:116;22065:22;;:::i;:::-;22122:3;22116:10;22107:7;22100:27;22180:2;22175:3;22171:12;22165:19;22160:2;22151:7;22147:16;22140:45;22228:2;22223:3;22219:12;22213:19;22245:30;22267:7;22245:30;:::i;:::-;22295:16;;;22288:33;22334:20;;21884:12;;;;22374;;;;21851:545;;;22412:14;;;22405:29;;;;-1:-1:-1;22416:5:1;;20701:1763;-1:-1:-1;;;;;;;20701:1763:1:o;23666:1352::-;23790:6;23821:2;23864;23852:9;23843:7;23839:23;23835:32;23832:52;;;23880:1;23877;23870:12;23832:52;23913:9;23907:16;-1:-1:-1;;;;;23938:6:1;23935:30;23932:50;;;23978:1;23975;23968:12;23932:50;24001:22;;24054:4;24046:13;;24042:27;-1:-1:-1;24032:55:1;;24083:1;24080;24073:12;24032:55;24112:2;24106:9;24135:70;24151:53;24201:2;24151:53;:::i;24135:70::-;24239:15;;;24321:1;24317:10;;;;24309:19;;24305:28;;;24270:12;;;;24345:19;;;24342:39;;;24377:1;24374;24367:12;24342:39;24401:11;;;;24421:567;24437:6;24432:3;24429:15;24421:567;;;24519:4;24513:3;24504:7;24500:17;24496:28;24493:118;;;24565:1;24594:2;24590;24583:14;24493:118;24637:22;;:::i;:::-;24686:10;;24672:25;;24739:12;;;24733:19;24717:14;;;24710:43;24776:2;24820:12;;;24814:19;24798:14;;;24791:43;24857:2;24901:12;;;24895:19;24879:14;;;24872:43;24928:18;;24463:4;24454:14;;;;24966:12;;;;24421:567;;25023:517;25144:6;25197:2;25185:9;25176:7;25172:23;25168:32;25165:52;;;25213:1;25210;25203:12;25165:52;25246:9;25240:16;-1:-1:-1;;;;;25271:6:1;25268:30;25265:50;;;25311:1;25308;25301:12;25265:50;25334:22;;25387:4;25379:13;;25375:27;-1:-1:-1;25365:55:1;;25416:1;25413;25406:12;25365:55;25439:95;25526:7;25521:2;25515:9;25510:2;25506;25502:11;25439:95;:::i;25545:417::-;-1:-1:-1;;;;;25794:32:1;;;;25776:51;;25858:2;25843:18;;25836:34;;;;25901:2;25886:18;;25879:34;25944:2;25929:18;;25922:34;25763:3;25748:19;;25545:417::o;26522:251::-;26592:6;26645:2;26633:9;26624:7;26620:23;26616:32;26613:52;;;26661:1;26658;26651:12;26613:52;26693:9;26687:16;26712:31;26737:5;26712:31;:::i;28180:337::-;28260:6;28313:2;28301:9;28292:7;28288:23;28284:32;28281:52;;;28329:1;28326;28319:12;28281:52;28362:9;28356:16;-1:-1:-1;;;;;28387:6:1;28384:30;28381:50;;;28427:1;28424;28417:12;28381:50;28450:61;28503:7;28494:6;28483:9;28479:22;28450:61;:::i;31357:368::-;31454:6;31462;31470;31478;31531:3;31519:9;31510:7;31506:23;31502:33;31499:53;;;31548:1;31545;31538:12;31499:53;-1:-1:-1;;31571:16:1;;31627:2;31612:18;;31606:25;31671:2;31656:18;;31650:25;31715:2;31700:18;;;31694:25;31571:16;;31606:25;;-1:-1:-1;31694:25:1;;-1:-1:-1;31357:368:1;-1:-1:-1;31357:368:1:o;32083:404::-;32285:2;32267:21;;;32324:2;32304:18;;;32297:30;32363:34;32358:2;32343:18;;32336:62;-1:-1:-1;;;32429:2:1;32414:18;;32407:38;32477:3;32462:19;;32083:404::o

ipfs://40115772e547906e75c25bdc706721593df1f9f5a75dbae1f2f43357e0d9511a