Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Base64
•    - function encode(bytes memory data)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IFeeCollectable
•    - function setFeeTo(address _feeTo)
•    - function refund()
• library SafeCast
•    - function toUint224(uint256 value)
•    - function toUint128(uint256 value)
•    - function toUint96(uint256 value)
•    - function toUint64(uint256 value)
•    - function toUint32(uint256 value)
•    - function toUint16(uint256 value)
•    - function toUint8(uint256 value)
•    - function toUint256(int256 value)
•    - function toInt128(int256 value)
•    - function toInt64(int256 value)
•    - function toInt32(int256 value)
•    - function toInt16(int256 value)
•    - function toInt8(int256 value)
•    - function toInt256(uint256 value)
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• interface IERC721Receiver
•    - function onERC721Received(
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• library TransferHelper
•    - function safeTransferFrom(
•    - function safeTransferNFTFrom(
•    - function safeTransfer(
•    - function safeApprove(
•    - function safeTransferETH(address to, ...
•  contract FeeCollectable is Ownable ...
•    - function setFeeTo(address _feeTo)
•    - function refund()
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• interface IHistoryERC721 is IERC721, ...
•    - function getConfig()
•    - function eventNum()
•    - function eventContentHash(uint eventI ...
•    - function eventData(uint eventId)
•    - function tokenEventId(uint tokenId)
•    - function allowedDomain(uint id)
•    - function tokenURI2(uint256 tokenId)
•    - function contractURI()
•    - function setConfig(uint256 mint_, uin ...
•    - function addAllowedDomain(string memo ...
•    - function setBaseUrl(string memory bas ...
•    - function setContractUrl(string memory ...
•    - function mintNewHistoryReport(
•    - function followHistoryEvent(uint even ...
•  contract ERC721 is Context, ERC165 ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _safeTransfer(
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(
•    - function _approve(address to, uint256 ...
•    - function _checkOnERC721Received(
•    - function _beforeTokenTransfer(
•    - function supportsInterface(bytes4 int ...
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function _beforeTokenTransfer(
•    - function _addTokenToOwnerEnumeration( ...
•    - function _addTokenToAllTokensEnumerat ...
•    - function _removeTokenFromOwnerEnumera ...
•    - function _removeTokenFromAllTokensEnu ...
•  contract HistoryERC721 is ERC721En ... *
•    - function supportsInterface(bytes4 int ...
•    - function eventData(uint eventId)
•    - function _baseURI()
•    - function tokenURI2(uint256 tokenId)
•    - function getConfig()
•    - function setConfig(uint256 mint_, uin ...
•    - function setBaseUrl(string memory bas ...
•    - function setContractUrl(string memory ...
•    - function addAllowedDomain(string memo ...
•    - function mintNewHistoryReport(
•    - function followHistoryEvent(
•    - function tokenEventId(uint tokenId)
•    - function _genTokenID(uint eventID, ui ...
•    - function _tokenIdSplit(uint tokenId)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-12-15
*/

// SPDX-License-Identifier: MIT
// File: contracts/libraries/base64.sol


pragma solidity ^0.8.0;

/// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides a function for encoding some bytes in base64
library Base64 {
    string internal constant TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

    function encode(bytes memory data) internal pure returns (string memory) {
        if (data.length == 0) return '';
        
        // load the table into memory
        string memory table = TABLE;

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((data.length + 2) / 3);

        // add some extra buffer at the end required for the writing
        string memory result = new string(encodedLen + 32);

        assembly {
            // set the actual output length
            mstore(result, encodedLen)
            
            // prepare the lookup table
            let tablePtr := add(table, 1)
            
            // input ptr
            let dataPtr := data
            let endPtr := add(dataPtr, mload(data))
            
            // result ptr, jump over length
            let resultPtr := add(result, 32)
            
            // run over the input, 3 bytes at a time
            for {} lt(dataPtr, endPtr) {}
            {
               dataPtr := add(dataPtr, 3)
               
               // read 3 bytes
               let input := mload(dataPtr)
               
               // write 4 characters
               mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(18, input), 0x3F)))))
               resultPtr := add(resultPtr, 1)
               mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(12, input), 0x3F)))))
               resultPtr := add(resultPtr, 1)
               mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr( 6, input), 0x3F)))))
               resultPtr := add(resultPtr, 1)
               mstore(resultPtr, shl(248, mload(add(tablePtr, and(        input,  0x3F)))))
               resultPtr := add(resultPtr, 1)
            }
            
            // padding with '='
            switch mod(mload(data), 3)
            case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
            case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
        }
        
        return result;
    }
}

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



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: contracts/interfaces/IFeeCollectable.sol



pragma solidity ^0.8.0;

interface IFeeCollectable {
    /// @notice emitted when set new fee to address.
    event FeeToChangedEvt(address newFeeTo);

    /// @notice emitted when fee is paid to fee to address.
    event FeeWithdrawedEvt(address feeTo, uint amount);

    /// @notice set fee to address.
    function setFeeTo(address _feeTo) external;

    /// @notice transfer all fee to address feeTo.
    function refund() external;
    
}
// File: @openzeppelin/contracts/utils/math/SafeCast.sol



pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// File: @openzeppelin/contracts/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 no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

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

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

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

// File: @openzeppelin/contracts/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/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



pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

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

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

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

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

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

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



pragma solidity ^0.8.0;

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

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

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

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

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

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

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

// File: contracts/libraries/TransferHelper.sol


pragma solidity >=0.6.0;



library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers NFT from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param tokenId the id of the token need to be transfered
    function safeTransferNFTFrom(
        address token,
        address from,
        address to,
        uint256 tokenId
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC721.transferFrom.selector, from, to, tokenId));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}

// File: contracts/FeeCollectable.sol



pragma solidity ^0.8.0;




contract FeeCollectable is Ownable, IFeeCollectable{
    address public feeTo;

    /// @inheritdoc IFeeCollectable
    function setFeeTo(address _feeTo) onlyOwner external override{
        feeTo = _feeTo;
        emit FeeToChangedEvt(_feeTo);
    }

    /// @inheritdoc IFeeCollectable
    function refund() external override{
        uint amount = address(this).balance;
        TransferHelper.safeTransferETH(feeTo, amount);
        emit FeeWithdrawedEvt(feeTo, amount);
    }

}
// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol



pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/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: contracts/interfaces/IHistoryERC721.sol



pragma solidity ^0.8.0;



interface IHistoryERC721 is IERC721, IERC721Metadata {
    //////////////////////////////////////////////////////////////////////////
    // View Functions
    //////////////////////////////////////////////////////////////////////////
    
    /// @notice get config of this contract.
    function getConfig() external view returns(
        uint256 _contractId,
        uint256 _mintFee,
        uint256 _mintStartTime,
        uint256 _mintEndTime,
        address _feeTo
    );

    /// @notice get amount of events in this contract.
    function eventNum() external view returns(uint);

    function eventContentHash(uint eventId) external view returns(string memory contentHash);

    /// @notice Get event data
    function eventData(uint eventId) external view returns(
        uint totalMintFee,
        string memory name,
        string memory contentHash,
        string memory contentDomain,
        uint firstMintTime
    );

    /// @notice  get event id of specified token.
    function tokenEventId(uint tokenId) external view returns(uint tkEvtId);
    
    /// @notice return the allowed domain with specified id.
    function allowedDomain(uint id) external view returns(string memory domain);

    /// @notice get info stored just in evm and ipfs.
    function tokenURI2(uint256 tokenId) external view returns (string memory);

    /// @notice get contract meta info
    function contractURI() external view returns (string memory);

    //////////////////////////////////////////////////////////////////////////
    // Manage Functions
    //////////////////////////////////////////////////////////////////////////
    
    /// @notice set config of this contract.
    function setConfig(uint256 mint_, uint256 startTime_, uint256 endTime_) external;

    /// @notice put a new domain into use.
    function addAllowedDomain(string memory domain) external returns(bool res);

    /// @notice set base url.
    function setBaseUrl(string memory baseUri) external;

    /// @notice set base url.
    function setContractUrl(string memory _contractURI) external;
    
    //////////////////////////////////////////////////////////////////////////
    // User Functions
    //////////////////////////////////////////////////////////////////////////
    /// @notice mint a new history.
    function mintNewHistoryReport(
        uint domainId,
        bool usingSSL,
        string memory _name,
        string memory _contentHash
    ) external payable returns(uint tokenId);

    /// @notice follow a history report
    function followHistoryEvent(uint eventId) external payable returns(uint tokenId);
}

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



pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

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



pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: contracts/HistoryERC721.sol



pragma solidity ^0.8.0;









contract HistoryERC721 is ERC721Enumerable, FeeCollectable, IHistoryERC721{
    using Strings for uint256;
    using SafeMath for uint256;
    using SafeCast for uint256;

    //////////////////////////////////////////////////////////////////////////
    // Global data
    //////////////////////////////////////////////////////////////////////////

    /// @notice used to separate nft from different chain and contract version.
    uint32 private contractID;

    // @notice fee cost when mint nft.
    uint256 private mintFee;

    /// @notice Follow is allowed in [ mintTime + mintStartTime, mintTime + mintEndTime ]
    uint256 private mintEndTime;
    uint256 private mintStartTime;
    
    /// @notice domain allowed to use.
    /// Domain Id => domain in bytes.
    mapping(uint => string) public override allowedDomain;
    uint256 private allowedDomainNum;

    //////////////////////////////////////////////////////////////////////////
    // Event and token data
    //////////////////////////////////////////////////////////////////////////
    
    /// @inheritdoc IHistoryERC721
    uint public override eventNum;

    mapping(uint => bytes32) private eventContentDomain;

    struct EventMeta{
       bool sslOn;
       uint32 firstMintTime;
       uint128 totalMintFee;
       uint32 domainId;
       uint32 mintNum;
    }
    mapping(uint => EventMeta) private eventMeta;
    
    /// @notice Hash of event content.
    mapping(uint => string) public  override eventContentHash;
    
    // fee used to mint nft in an event.
    mapping(uint => uint) private eventAssets;

    // name of an event.
    mapping(uint => string) private eventName;

    string public getBaseURI;

    /// @inheritdoc IHistoryERC721
    string public override contractURI;
    
    //////////////////////////////////////////////////////////////////////////
    // Functions
    //////////////////////////////////////////////////////////////////////////

    /// Constructor function
    /// @param contractId_ should be smaller than uint32(-1)
    constructor(string memory name_, string memory symbol_, uint contractId_) ERC721(name_,symbol_){
        require(contractId_ < 0xFFFFFFFF);
        contractID = contractId_.toUint32();

        feeTo = _msgSender();
        // default start time is 10 min.
        mintStartTime = 10 * 60;
        // default end time is 60 min.
        mintEndTime = 30 * 60;
        // default mint fee is 0.01 ETH
        mintFee = 0.01 * 1e18;
    }

    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721Enumerable) returns (bool) {
        return interfaceId == type(IHistoryERC721).interfaceId || super.supportsInterface(interfaceId);
    }

    /// @inheritdoc IHistoryERC721
    function eventData(uint eventId) external view override returns(
        uint totalMintFee,
        string memory _name,
        string memory contentHash,
        string memory contentDomain,
        uint firstMintTime
    ){
        EventMeta memory meta = eventMeta[eventId];
        totalMintFee = meta.totalMintFee;
        _name = eventName[eventId];
        contentDomain = allowedDomain[meta.domainId];
        contentHash = eventContentHash[eventId];
        firstMintTime = meta.firstMintTime;
    }

    function _baseURI() internal view override(ERC721) returns (string memory) {
        return getBaseURI;
    }

    /// @inheritdoc IHistoryERC721
    function tokenURI2(uint256 tokenId) external view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        (uint evtId, uint reportId) = _tokenIdSplit(tokenId);
        EventMeta memory meta = eventMeta[evtId];
        string memory contentDomain = allowedDomain[meta.domainId];
        string memory head = meta.sslOn ? "https://" : "http://";
        string memory contentUrl = string(abi.encodePacked(head, contentDomain, eventContentHash[evtId]));
        string memory name = string(abi.encodePacked(eventName[evtId]," #",reportId.toString()));
        string memory description = string(abi.encodePacked(
            "History V1 NFT of event ",
            evtId.toString(),
            " : ",
            eventName[evtId],
            ", report id is ",
            reportId.toString(),
            "."
        ));

        return
            string(
                abi.encodePacked(
                    'data:application/json;base64,',
                    Base64.encode(
                        bytes(
                            abi.encodePacked(
                                '{"name":"',
                                name,
                                '", "description":"',
                                description,
                                '", "content": "',
                                contentUrl,
                                '"}'
                            )
                        )
                    )
                )
            );
    }

    /// @inheritdoc IHistoryERC721
    function getConfig() external override view returns(
        uint256 _contractId,
        uint256 _mintFee,
        uint256 _mintStartTime,
        uint256 _mintEndTime,
        address _feeTo)
    {
        return (contractID, mintFee, mintStartTime, mintEndTime, feeTo);
    }

    /// @inheritdoc IHistoryERC721
    function setConfig(uint256 mint_, uint256 startTime_, uint256 endTime_) external override onlyOwner{
        mintFee = mint_;
        mintStartTime = startTime_;
        mintEndTime = endTime_;
    }

    /// @inheritdoc IHistoryERC721
    function setBaseUrl(string memory baseUri) external override onlyOwner{
        getBaseURI = baseUri;
    }

     /// @inheritdoc IHistoryERC721
    function setContractUrl(string memory _contractURI) external override onlyOwner{
        contractURI = _contractURI;
    }

    /// @inheritdoc IHistoryERC721
    function addAllowedDomain(string memory domain) external override onlyOwner returns(bool res){
        allowedDomain[allowedDomainNum] = domain;
        allowedDomainNum = allowedDomainNum.add(1);
        return true;
    }

    /// @inheritdoc IHistoryERC721
    function mintNewHistoryReport(
        uint domainId,
        bool usingSSL,
        string memory _name,
        string memory _contentHash
    ) external payable override returns(uint tokenId){
        require(domainId < allowedDomainNum,"Invalid domain id.");
        require(msg.value >= mintFee, "Not enough fee.");
        uint reportId = 0;
        uint eventId;

        // New event.
        eventId = eventNum.add(1);
        eventNum = eventId;
        EventMeta storage meta = eventMeta[eventId];
        (meta.totalMintFee, meta.mintNum, meta.sslOn, meta.domainId, meta.firstMintTime) = (
            msg.value.toUint128(),
            1,
            usingSSL,
            domainId.toUint32(),
            uint32(block.timestamp)
        );
        eventName[eventId] = _name;
        eventContentHash[eventId] = _contentHash;
    
        // Mint Coin
        tokenId = _genTokenID(eventId, reportId);
        _safeMint(_msgSender(), tokenId);
    }

    /// @inheritdoc IHistoryERC721
    function followHistoryEvent(
        uint eventId
    )external payable override returns(uint tokenId){
        require(msg.value >= mintFee, "Not enough fee.");
        require(eventId <= eventNum, "Invalid event.");
     
        EventMeta storage meta = eventMeta[eventId];
        EventMeta memory _meta = meta;

        require(_meta.firstMintTime + mintEndTime >= block.timestamp, "mint too late.");
        require(_meta.firstMintTime + mintStartTime <= block.timestamp, "mint too early");
        uint reportId = uint(meta.mintNum).add(1);
        (meta.totalMintFee, meta.mintNum) = (
            msg.value.add(_meta.totalMintFee).toUint128(),
            reportId.toUint32()
        );

        // Mint Coin
        tokenId = _genTokenID(eventId, reportId);
        _safeMint(_msgSender(), tokenId);
    }

    /// @inheritdoc IHistoryERC721
    function tokenEventId(uint tokenId) external pure override returns(uint tkEvtId){
        (tkEvtId, ) = _tokenIdSplit(tokenId);
    }

    /// @notice  Packing (contractID: 32, eventID: 192, reportID 32)
    function _genTokenID(uint eventID, uint reportID) internal  view returns(uint tokenID){
        require(eventID < 0xFFFFFFFF && reportID < 0xFFFFFFFF, "Invalid ID");
        tokenID = (uint(contractID) << (192+32)) + (eventID << 32) + reportID;
    }

    function _tokenIdSplit(uint tokenId) internal pure returns(uint eventID, uint reportID){
        /// remaining (tokenID >> (192+32)) is contract id.
        eventID  = (tokenId >> 32) & ((1<<192)-1);
        reportID = tokenId & ((1<<32)-1);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"contractId_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newFeeTo","type":"address"}],"name":"FeeToChangedEvt","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeTo","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"FeeWithdrawedEvt","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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"string","name":"domain","type":"string"}],"name":"addAllowedDomain","outputs":[{"internalType":"bool","name":"res","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allowedDomain","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"eventContentHash","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"eventId","type":"uint256"}],"name":"eventData","outputs":[{"internalType":"uint256","name":"totalMintFee","type":"uint256"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"contentHash","type":"string"},{"internalType":"string","name":"contentDomain","type":"string"},{"internalType":"uint256","name":"firstMintTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eventNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeTo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"eventId","type":"uint256"}],"name":"followHistoryEvent","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBaseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getConfig","outputs":[{"internalType":"uint256","name":"_contractId","type":"uint256"},{"internalType":"uint256","name":"_mintFee","type":"uint256"},{"internalType":"uint256","name":"_mintStartTime","type":"uint256"},{"internalType":"uint256","name":"_mintEndTime","type":"uint256"},{"internalType":"address","name":"_feeTo","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"domainId","type":"uint256"},{"internalType":"bool","name":"usingSSL","type":"bool"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_contentHash","type":"string"}],"name":"mintNewHistoryReport","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseUri","type":"string"}],"name":"setBaseUrl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"mint_","type":"uint256"},{"internalType":"uint256","name":"startTime_","type":"uint256"},{"internalType":"uint256","name":"endTime_","type":"uint256"}],"name":"setConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_contractURI","type":"string"}],"name":"setContractUrl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeTo","type":"address"}],"name":"setFeeTo","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":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenEventId","outputs":[{"internalType":"uint256","name":"tkEvtId","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI2","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000d426c6f636b20486973746f7279000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007484953544f525900000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Block History
Arg [1] : symbol_ (string): HISTORY
Arg [2] : contractId_ (uint256): 2

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000d
Arg [4] : 426c6f636b20486973746f727900000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [6] : 484953544f525900000000000000000000000000000000000000000000000000

70672:9006:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45105:20;;;;;;;;;;-1:-1:-1;45105:20:0;;;;-1:-1:-1;;;;;45105:20:0;;;;;;-1:-1:-1;;;;;11446:32:1;;;11428:51;;11416:2;11401:18;45105:20:0;;;;;;;;73264:231;;;;;;;;;;-1:-1:-1;73264:231:0;;;;;:::i;:::-;;:::i;:::-;;;12427:14:1;;12420:22;12402:41;;12390:2;12375:18;73264:231:0;12262:187:1;52329:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;53888:221::-;;;;;;;;;;-1:-1:-1;53888:221:0;;;;;:::i;:::-;;:::i;53411:411::-;;;;;;;;;;-1:-1:-1;53411:411:0;;;;;:::i;:::-;;:::i;:::-;;76194:203;;;;;;;;;;-1:-1:-1;76194:203:0;;;;;:::i;:::-;;:::i;65077:113::-;;;;;;;;;;-1:-1:-1;65165:10:0;:17;65077:113;;;23236:25:1;;;23224:2;23209:18;65077:113:0;23090:177:1;54778:339:0;;;;;;;;;;-1:-1:-1;54778:339:0;;;;;:::i;:::-;;:::i;64745:256::-;;;;;;;;;;-1:-1:-1;64745:256:0;;;;;:::i;:::-;;:::i;71800:29::-;;;;;;;;;;;;;;;;71468:53;;;;;;;;;;-1:-1:-1;71468:53:0;;;;;:::i;:::-;;:::i;55188:185::-;;;;;;;;;;-1:-1:-1;55188:185:0;;;;;:::i;:::-;;:::i;76763:227::-;;;;;;;;;;-1:-1:-1;76763:227:0;;;;;:::i;:::-;;:::i;65267:233::-;;;;;;;;;;-1:-1:-1;65267:233:0;;;;;:::i;:::-;;:::i;45349:192::-;;;;;;;;;;;;;:::i;78948:135::-;;;;;;;;;;-1:-1:-1;78948:135:0;;;;;:::i;:::-;79604:2;79593:13;-1:-1:-1;;;;;79592:30:0;;78948:135;52023:239;;;;;;;;;;-1:-1:-1;52023:239:0;;;;;:::i;:::-;;:::i;76595:124::-;;;;;;;;;;-1:-1:-1;76595:124:0;;;;;:::i;:::-;;:::i;51753:208::-;;;;;;;;;;-1:-1:-1;51753:208:0;;;;;:::i;:::-;;:::i;72392:24::-;;;;;;;;;;;;;:::i;25314:94::-;;;;;;;;;;;;;:::i;78069:835::-;;;;;;:::i;:::-;;:::i;24663:87::-;;;;;;;;;;-1:-1:-1;24736:6:0;;-1:-1:-1;;;;;24736:6:0;24663:87;;52498:104;;;;;;;;;;;;;:::i;54181:295::-;;;;;;;;;;-1:-1:-1;54181:295:0;;;;;:::i;:::-;;:::i;72154:57::-;;;;;;;;;;-1:-1:-1;72154:57:0;;;;;:::i;:::-;;:::i;55444:328::-;;;;;;;;;;-1:-1:-1;55444:328:0;;;;;:::i;:::-;;:::i;73539:522::-;;;;;;;;;;-1:-1:-1;73539:522:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;75864:286::-;;;;;;;;;;-1:-1:-1;76087:10:0;;76099:7;;76108:13;;76123:11;;75864:286;;;76087:10;-1:-1:-1;;;76087:10:0;;;24224:25:1;;24280:2;24265:18;;24258:34;;;;24308:18;;24301:34;;;;24366:2;24351:18;;24344:34;-1:-1:-1;;;;;76136:5:0;;;24409:3:1;24394:19;;24387:61;24211:3;24196:19;75864:286:0;23965:489:1;76441:109:0;;;;;;;;;;-1:-1:-1;76441:109:0;;;;;:::i;:::-;;:::i;52673:334::-;;;;;;;;;;-1:-1:-1;52673:334:0;;;;;:::i;:::-;;:::i;74224:1596::-;;;;;;;;;;-1:-1:-1;74224:1596:0;;;;;:::i;:::-;;:::i;77034:991::-;;;;;;:::i;:::-;;:::i;72461:34::-;;;;;;;;;;;;;:::i;54547:164::-;;;;;;;;;;-1:-1:-1;54547:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;54668:25:0;;;54644:4;54668:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;54547:164;25563:192;;;;;;;;;;-1:-1:-1;25563:192:0;;;;;:::i;:::-;;:::i;45171:133::-;;;;;;;;;;-1:-1:-1;45171:133:0;;;;;:::i;:::-;;:::i;73264:231::-;73376:4;-1:-1:-1;;;;;;73400:47:0;;-1:-1:-1;;;73400:47:0;;:87;;;73451:36;73475:11;73451:23;:36::i;:::-;73393:94;73264:231;-1:-1:-1;;73264:231:0:o;52329:100::-;52383:13;52416:5;52409:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52329:100;:::o;53888:221::-;53964:7;57371:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57371:16:0;53984:73;;;;-1:-1:-1;;;53984:73:0;;19019:2:1;53984:73:0;;;19001:21:1;19058:2;19038:18;;;19031:30;19097:34;19077:18;;;19070:62;-1:-1:-1;;;19148:18:1;;;19141:42;19200:19;;53984:73:0;;;;;;;;;-1:-1:-1;54077:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54077:24:0;;53888:221::o;53411:411::-;53492:13;53508:23;53523:7;53508:14;:23::i;:::-;53492:39;;53556:5;-1:-1:-1;;;;;53550:11:0;:2;-1:-1:-1;;;;;53550:11:0;;;53542:57;;;;-1:-1:-1;;;53542:57:0;;20619:2:1;53542:57:0;;;20601:21:1;20658:2;20638:18;;;20631:30;20697:34;20677:18;;;20670:62;-1:-1:-1;;;20748:18:1;;;20741:31;20789:19;;53542:57:0;20417:397:1;53542:57:0;23531:10;-1:-1:-1;;;;;53634:21:0;;;;:62;;-1:-1:-1;53659:37:0;53676:5;23531:10;54547:164;:::i;53659:37::-;53612:168;;;;-1:-1:-1;;;53612:168:0;;16386:2:1;53612:168:0;;;16368:21:1;16425:2;16405:18;;;16398:30;16464:34;16444:18;;;16437:62;16535:26;16515:18;;;16508:54;16579:19;;53612:168:0;16184:420:1;53612:168:0;53793:21;53802:2;53806:7;53793:8;:21::i;:::-;53481:341;53411:411;;:::o;76194:203::-;24736:6;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;76304:7:::1;:15:::0;;;;76330:13:::1;:26:::0;76367:11:::1;:22:::0;76194:203::o;54778:339::-;54973:41;23531:10;55006:7;54973:18;:41::i;:::-;54965:103;;;;-1:-1:-1;;;54965:103:0;;;;;;;:::i;:::-;55081:28;55091:4;55097:2;55101:7;55081:9;:28::i;64745:256::-;64842:7;64878:23;64895:5;64878:16;:23::i;:::-;64870:5;:31;64862:87;;;;-1:-1:-1;;;64862:87:0;;12880:2:1;64862:87:0;;;12862:21:1;12919:2;12899:18;;;12892:30;12958:34;12938:18;;;12931:62;-1:-1:-1;;;13009:18:1;;;13002:41;13060:19;;64862:87:0;12678:407:1;64862:87:0;-1:-1:-1;;;;;;64967:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;64745:256::o;71468:53::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55188:185::-;55326:39;55343:4;55349:2;55353:7;55326:39;;;;;;;;;;;;:16;:39::i;76763:227::-;24736:6;;76847:8;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;76881:16:::1;::::0;76867:31:::1;::::0;;;:13:::1;:31;::::0;;;;;;;:40;;::::1;::::0;;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;76937:16:0::1;::::0;:23:::1;::::0;76958:1:::1;76937:20;:23::i;:::-;76918:16;:42:::0;-1:-1:-1;76978:4:0::1;24954:1;76763:227:::0;;;:::o;65267:233::-;65342:7;65378:30;65165:10;:17;;65077:113;65378:30;65370:5;:38;65362:95;;;;-1:-1:-1;;;65362:95:0;;22536:2:1;65362:95:0;;;22518:21:1;22575:2;22555:18;;;22548:30;22614:34;22594:18;;;22587:62;-1:-1:-1;;;22665:18:1;;;22658:42;22717:19;;65362:95:0;22334:408:1;65362:95:0;65475:10;65486:5;65475:17;;;;;;;;:::i;:::-;;;;;;;;;65468:24;;65267:233;;;:::o;45349:192::-;45472:5;;45409:21;;45441:45;;-1:-1:-1;;;;;45472:5:0;45409:21;45441:30;:45::i;:::-;45519:5;;45502:31;;;-1:-1:-1;;;;;45519:5:0;;;12157:51:1;;12239:2;12224:18;;12217:34;;;45502:31:0;;12130:18:1;45502:31:0;;;;;;;;45384:157;45349:192::o;52023:239::-;52095:7;52131:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52131:16:0;52166:19;52158:73;;;;-1:-1:-1;;;52158:73:0;;17222:2:1;52158:73:0;;;17204:21:1;17261:2;17241:18;;;17234:30;17300:34;17280:18;;;17273:62;-1:-1:-1;;;17351:18:1;;;17344:39;17400:19;;52158:73:0;17020:405:1;76595:124:0;24736:6;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;76685:26;;::::1;::::0;:11:::1;::::0;:26:::1;::::0;::::1;::::0;::::1;:::i;:::-;;76595:124:::0;:::o;51753:208::-;51825:7;-1:-1:-1;;;;;51853:19:0;;51845:74;;;;-1:-1:-1;;;51845:74:0;;16811:2:1;51845:74:0;;;16793:21:1;16850:2;16830:18;;;16823:30;16889:34;16869:18;;;16862:62;-1:-1:-1;;;16940:18:1;;;16933:40;16990:19;;51845:74:0;16609:406:1;51845:74:0;-1:-1:-1;;;;;;51937:16:0;;;;;:9;:16;;;;;;;51753:208::o;72392:24::-;;;;;;;:::i;25314:94::-;24736:6;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;25379:21:::1;25397:1;25379:9;:21::i;:::-;25314:94::o:0;78069:835::-;78160:12;78205:7;;78192:9;:20;;78184:48;;;;-1:-1:-1;;;78184:48:0;;17632:2:1;78184:48:0;;;17614:21:1;17671:2;17651:18;;;17644:30;-1:-1:-1;;;17690:18:1;;;17683:45;17745:18;;78184:48:0;17430:339:1;78184:48:0;78262:8;;78251:7;:19;;78243:46;;;;-1:-1:-1;;;78243:46:0;;22949:2:1;78243:46:0;;;22931:21:1;22988:2;22968:18;;;22961:30;-1:-1:-1;;;23007:18:1;;;23000:44;23061:18;;78243:46:0;22747:338:1;78243:46:0;78307:22;78332:18;;;:9;:18;;;;;;;;;78361:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;78361:29:0;;;;;;;;;;-1:-1:-1;;;78361:29:0;;;;;;;;-1:-1:-1;;;78361:29:0;;;;;;;;;78433:11;;78332:18;;78361:29;78448:15;;78411:33;;;:::i;:::-;:52;;78403:79;;;;-1:-1:-1;;;78403:79:0;;18676:2:1;78403:79:0;;;18658:21:1;18715:2;18695:18;;;18688:30;-1:-1:-1;;;18734:18:1;;;18727:44;18788:18;;78403:79:0;18474:338:1;78403:79:0;78540:15;78523:13;;78501:5;:19;;;:35;;;;;;:::i;:::-;:54;;78493:81;;;;-1:-1:-1;;;78493:81:0;;22193:2:1;78493:81:0;;;22175:21:1;22232:2;22212:18;;;22205:30;-1:-1:-1;;;22251:18:1;;;22244:44;22305:18;;78493:81:0;21991:338:1;78493:81:0;78606:12;;78585:13;;78601:25;;78606:12;-1:-1:-1;;;78606:12:0;;;;;;78624:1;;78601:22;:25;:::i;:::-;78585:41;;78688:45;:33;78702:5;:18;;;-1:-1:-1;;;;;78688:33:0;:9;:13;;:33;;;;:::i;:::-;:43;:45::i;:::-;78748:19;:8;:17;:19::i;:::-;78637:141;;-1:-1:-1;;;;;78637:141:0;;;-1:-1:-1;;;78637:141:0;-1:-1:-1;;;;;;78637:141:0;;;;-1:-1:-1;;;78637:141:0;;;;;;;;;;;;;;;;78823:30;78835:7;78844:8;78823:11;:30::i;:::-;78813:40;-1:-1:-1;78864:32:0;23531:10;78874:12;78888:7;78864:9;:32::i;:::-;78173:731;;;78069:835;;;:::o;52498:104::-;52554:13;52587:7;52580:14;;;;;:::i;54181:295::-;-1:-1:-1;;;;;54284:24:0;;23531:10;54284:24;;54276:62;;;;-1:-1:-1;;;54276:62:0;;14880:2:1;54276:62:0;;;14862:21:1;14919:2;14899:18;;;14892:30;14958:27;14938:18;;;14931:55;15003:18;;54276:62:0;14678:349:1;54276:62:0;23531:10;54351:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;54351:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;54351:53:0;;;;;;;;;;54420:48;;12402:41:1;;;54351:42:0;;23531:10;54420:48;;12375:18:1;54420:48:0;;;;;;;54181:295;;:::o;72154:57::-;;;;;;;;;;;;;;;;:::i;55444:328::-;55619:41;23531:10;55652:7;55619:18;:41::i;:::-;55611:103;;;;-1:-1:-1;;;55611:103:0;;;;;;;:::i;:::-;55725:39;55739:4;55745:2;55749:7;55758:5;55725:13;:39::i;:::-;55444:328;;;;:::o;73539:522::-;73613:17;73805:18;;;:9;:18;;;;;;;;73781:42;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;73781:42:0;;;;;;;;;-1:-1:-1;;;73781:42:0;;;;73641:19;73781:42;;;;;;;-1:-1:-1;;;73781:42:0;;;;;;;;;;73885:18;;;:9;:18;;;;;;73877:26;;73781:42;;73641:19;;;;;;73613:17;;73781:42;;73877:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73930:13;:28;73944:4;:13;;;73930:28;;;;;;;;;;;;;73914:44;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;73983:25:0;;;;:16;:25;;;;;73969:39;;73914:44;;-1:-1:-1;73983:25:0;73969:39;;-1:-1:-1;73969:39:0;-1:-1:-1;73969:39:0;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74035:4;:18;;;74019:34;;;;73770:291;73539:522;;;;;;;:::o;76441:109::-;24736:6;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;76522:20;;::::1;::::0;:10:::1;::::0;:20:::1;::::0;::::1;::::0;::::1;:::i;52673:334::-:0;57347:4;57371:16;;;:7;:16;;;;;;52746:13;;-1:-1:-1;;;;;57371:16:0;52772:76;;;;-1:-1:-1;;;52772:76:0;;;;;;;:::i;:::-;52861:21;52885:10;:8;:10::i;:::-;52861:34;;52937:1;52919:7;52913:21;:25;:86;;;;;;;;;;;;;;;;;52965:7;52974:18;:7;:16;:18::i;:::-;52948:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52913:86;52906:93;52673:334;-1:-1:-1;;;52673:334:0:o;74224:1596::-;57347:4;57371:16;;;:7;:16;;;;;;74292:13;;-1:-1:-1;;;;;57371:16:0;74318:76;;;;-1:-1:-1;;;74318:76:0;;;;;;;:::i;:::-;79604:2;79593:13;;;-1:-1:-1;;;;;79592:30:0;74406:10;74492:16;;;:9;:16;;;;;;74468:40;;;;;;;;;;;;;;;;79655:9;74468:40;;;;;;;;;-1:-1:-1;;;;;;;;74468:40:0;;;;;;;-1:-1:-1;;;74468:40:0;;;;;;;;;;-1:-1:-1;;;74468:40:0;;;;;;;;;74549:28;;;:13;:28;;;;;;74519:58;;79592:30;;79644:21;;;74468:40;;74406:10;74519:58;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74588:18;74609:4;:10;;;:35;;;;;;;;;;;;;;;-1:-1:-1;;;74609:35:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;74609:35:0;;;;74655:24;74727:23;;;:16;:23;;;;;;;;74689:62;;74588:56;;-1:-1:-1;74655:24:0;;74689:62;;74588:56;;74712:13;;74689:62;;:::i;:::-;;;;-1:-1:-1;;74689:62:0;;;;;;;;;74763:18;74808:16;;;:9;74689:62;74808:16;;;;74689:62;;-1:-1:-1;74763:18:0;74830:19;:8;:17;:19::i;:::-;74791:59;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74763:88;;74862:25;74969:16;:5;:14;:16::i;:::-;75020;;;;:9;:16;;;;;75083:19;:8;:17;:19::i;:::-;74897:234;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74862:270;;75283:495;75456:4;75550:11;75648:10;75359:369;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75283:13;:495::i;:::-;75190:607;;;;;;;;:::i;:::-;;;;;;;;;;;;;75145:667;;;;;;;;;;74224:1596;;;:::o;77034:991::-;77220:12;77263:16;;77252:8;:27;77244:57;;;;-1:-1:-1;;;77244:57:0;;21021:2:1;77244:57:0;;;21003:21:1;21060:2;21040:18;;;21033:30;-1:-1:-1;;;21079:18:1;;;21072:48;21137:18;;77244:57:0;20819:342:1;77244:57:0;77333:7;;77320:9;:20;;77312:48;;;;-1:-1:-1;;;77312:48:0;;17632:2:1;77312:48:0;;;17614:21:1;17671:2;17651:18;;;17644:30;-1:-1:-1;;;17690:18:1;;;17683:45;17745:18;;77312:48:0;17430:339:1;77312:48:0;77371:13;77399:12;77457:15;77470:1;77457:8;;:12;;:15;;;;:::i;:::-;77483:8;:18;;;77512:22;77537:18;;;:9;:18;;;;;77447:25;;-1:-1:-1;77664:21:0;:9;:19;:21::i;:::-;77700:1;77716:8;77739:19;:8;:17;:19::i;:::-;77566:241;;-1:-1:-1;;;;;77566:241:0;;;-1:-1:-1;;;77566:241:0;-1:-1:-1;;;;;;77566:241:0;;;;-1:-1:-1;;;77566:241:0;-1:-1:-1;;;;77566:241:0;;;;;;;-1:-1:-1;;;;;;77566:241:0;;;-1:-1:-1;;;77566:241:0;-1:-1:-1;;;;77780:15:0;77566:241;;;;;;;;;;-1:-1:-1;;77566:241:0;;;;;;;;;;;;;;;;;;;;;;;;77567:17;77818:18;;;:9;:18;;;;;;;;:26;;;;;;;;:::i;:::-;-1:-1:-1;77855:25:0;;;;:16;:25;;;;;;;;:40;;;;;;;;:::i;:::-;;77944:30;77956:7;77965:8;77944:11;:30::i;:::-;77934:40;-1:-1:-1;77985:32:0;23531:10;77995:12;23451:98;77985:32;77233:792;;;77034:991;;;;;;:::o;72461:34::-;;;;;;;:::i;25563:192::-;24736:6;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;25652:22:0;::::1;25644:73;;;::::0;-1:-1:-1;;;25644:73:0;;13711:2:1;25644:73:0::1;::::0;::::1;13693:21:1::0;13750:2;13730:18;;;13723:30;13789:34;13769:18;;;13762:62;-1:-1:-1;;;13840:18:1;;;13833:36;13886:19;;25644:73:0::1;13509:402:1::0;25644:73:0::1;25728:19;25738:8;25728:9;:19::i;:::-;25563:192:::0;:::o;45171:133::-;24736:6;;-1:-1:-1;;;;;24736:6:0;23531:10;24883:23;24875:68;;;;-1:-1:-1;;;24875:68:0;;;;;;;:::i;:::-;45243:5:::1;:14:::0;;-1:-1:-1;;;;;;45243:14:0::1;-1:-1:-1::0;;;;;45243:14:0;::::1;::::0;;::::1;::::0;;;45273:23:::1;::::0;11428:51:1;;;45273:23:0::1;::::0;11416:2:1;11401:18;45273:23:0::1;11282:203:1::0;8874:190:0;8930:6;8966:16;8957:25;;;8949:76;;;;-1:-1:-1;;;8949:76:0;;21786:2:1;8949:76:0;;;21768:21:1;21825:2;21805:18;;;21798:30;21864:34;21844:18;;;21837:62;-1:-1:-1;;;21915:18:1;;;21908:36;21961:19;;8949:76:0;21584:402:1;8949:76:0;-1:-1:-1;9050:5:0;8874:190::o;64437:224::-;64539:4;-1:-1:-1;;;;;;64563:50:0;;-1:-1:-1;;;64563:50:0;;:90;;;64617:36;64641:11;64617:23;:36::i;61264:174::-;61339:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;61339:29:0;-1:-1:-1;;;;;61339:29:0;;;;;;;;:24;;61393:23;61339:24;61393:14;:23::i;:::-;-1:-1:-1;;;;;61384:46:0;;;;;;;;;;;61264:174;;:::o;57576:348::-;57669:4;57371:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57371:16:0;57686:73;;;;-1:-1:-1;;;57686:73:0;;15973:2:1;57686:73:0;;;15955:21:1;16012:2;15992:18;;;15985:30;16051:34;16031:18;;;16024:62;-1:-1:-1;;;16102:18:1;;;16095:42;16154:19;;57686:73:0;15771:408:1;57686:73:0;57770:13;57786:23;57801:7;57786:14;:23::i;:::-;57770:39;;57839:5;-1:-1:-1;;;;;57828:16:0;:7;-1:-1:-1;;;;;57828:16:0;;:51;;;;57872:7;-1:-1:-1;;;;;57848:31:0;:20;57860:7;57848:11;:20::i;:::-;-1:-1:-1;;;;;57848:31:0;;57828:51;:87;;;-1:-1:-1;;;;;;54668:25:0;;;54644:4;54668:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;57883:32;57820:96;57576:348;-1:-1:-1;;;;57576:348:0:o;60568:578::-;60727:4;-1:-1:-1;;;;;60700:31:0;:23;60715:7;60700:14;:23::i;:::-;-1:-1:-1;;;;;60700:31:0;;60692:85;;;;-1:-1:-1;;;60692:85:0;;19793:2:1;60692:85:0;;;19775:21:1;19832:2;19812:18;;;19805:30;19871:34;19851:18;;;19844:62;-1:-1:-1;;;19922:18:1;;;19915:39;19971:19;;60692:85:0;19591:405:1;60692:85:0;-1:-1:-1;;;;;60796:16:0;;60788:65;;;;-1:-1:-1;;;60788:65:0;;14475:2:1;60788:65:0;;;14457:21:1;14514:2;14494:18;;;14487:30;14553:34;14533:18;;;14526:62;-1:-1:-1;;;14604:18:1;;;14597:34;14648:19;;60788:65:0;14273:400:1;60788:65:0;60866:39;60887:4;60893:2;60897:7;60866:20;:39::i;:::-;60970:29;60987:1;60991:7;60970:8;:29::i;:::-;-1:-1:-1;;;;;61012:15:0;;;;;;:9;:15;;;;;:20;;61031:1;;61012:15;:20;;61031:1;;61012:20;:::i;:::-;;;;-1:-1:-1;;;;;;;61043:13:0;;;;;;:9;:13;;;;;:18;;61060:1;;61043:13;:18;;61060:1;;61043:18;:::i;:::-;;;;-1:-1:-1;;61072:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;61072:21:0;-1:-1:-1;;;;;61072:21:0;;;;;;;;;61111:27;;61072:16;;61111:27;;;;;;;60568:578;;;:::o;16591:98::-;16649:7;16676:5;16680:1;16676;:5;:::i;44794:168::-;44907:12;;;44867;44907;;;;;;;;;-1:-1:-1;;;;;44885:7:0;;;44900:5;;44885:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44866:54;;;44939:7;44931:23;;;;-1:-1:-1;;;44931:23:0;;15642:2:1;44931:23:0;;;15624:21:1;15681:1;15661:18;;;15654:29;-1:-1:-1;;;15699:18:1;;;15692:33;15742:18;;44931:23:0;15440:326:1;25763:173:0;25838:6;;;-1:-1:-1;;;;;25855:17:0;;;-1:-1:-1;;;;;;25855:17:0;;;;;;;25888:40;;25838:6;;;25855:17;25838:6;;25888:40;;25819:16;;25888:40;25808:128;25763:173;:::o;7402:195::-;7459:7;-1:-1:-1;;;;;7487:26:0;;;7479:78;;;;-1:-1:-1;;;7479:78:0;;15234:2:1;7479:78:0;;;15216:21:1;15273:2;15253:18;;;15246:30;15312:34;15292:18;;;15285:62;-1:-1:-1;;;15363:18:1;;;15356:37;15410:19;;7479:78:0;15032:403:1;79161:253:0;79234:12;79276:10;79266:7;:20;:45;;;;;79301:10;79290:8;:21;79266:45;79258:68;;;;-1:-1:-1;;;79258:68:0;;17976:2:1;79258:68:0;;;17958:21:1;18015:2;17995:18;;;17988:30;-1:-1:-1;;;18034:18:1;;;18027:40;18084:18;;79258:68:0;17774:334:1;79258:68:0;79353:10;;79398:8;;79347:48;;79392:2;79381:13;;;;-1:-1:-1;;;79353:10:0;;79369:6;79348:28;-1:-1:-1;;;;;;79348:28:0;79347:48;:::i;:::-;:59;;;;:::i;58266:110::-;58342:26;58352:2;58356:7;58342:26;;;;;;;;;;;;:9;:26::i;56654:315::-;56811:28;56821:4;56827:2;56831:7;56811:9;:28::i;:::-;56858:48;56881:4;56887:2;56891:7;56900:5;56858:22;:48::i;:::-;56850:111;;;;-1:-1:-1;;;56850:111:0;;;;;;;:::i;74069:::-;74129:13;74162:10;74155:17;;;;;:::i;21067:723::-;21123:13;21344:10;21340:53;;-1:-1:-1;;21371:10:0;;;;;;;;;;;;-1:-1:-1;;;21371:10:0;;;;;21067:723::o;21340:53::-;21418:5;21403:12;21459:78;21466:9;;21459:78;;21492:8;;;;:::i;:::-;;-1:-1:-1;21515:10:0;;-1:-1:-1;21523:2:0;21515:10;;:::i;:::-;;;21459:78;;;21547:19;21579:6;21569:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21569:17:0;;21547:39;;21597:154;21604:10;;21597:154;;21631:11;21641:1;21631:11;;:::i;:::-;;-1:-1:-1;21700:10:0;21708:2;21700:5;:10;:::i;:::-;21687:24;;:2;:24;:::i;:::-;21674:39;;21657:6;21664;21657:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;21657:56:0;;;;;;;;-1:-1:-1;21728:11:0;21737:2;21728:11;;:::i;:::-;;;21597:154;;371:2037;429:13;459:4;:11;474:1;459:16;455:31;;;-1:-1:-1;;477:9:0;;;;;;;;;-1:-1:-1;477:9:0;;;371:2037::o;455:31::-;546:19;568:5;;;;;;;;;;;;;;;;;546:27;;625:18;671:1;652:4;:11;666:1;652:15;;;;:::i;:::-;651:21;;;;:::i;:::-;646:27;;:1;:27;:::i;:::-;625:48;-1:-1:-1;756:20:0;790:15;625:48;803:2;790:15;:::i;:::-;779:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;779:27:0;;756:50;;903:10;895:6;888:26;1010:1;1003:5;999:13;1081:4;1132;1126:11;1117:7;1113:25;1240:2;1232:6;1228:15;1325:810;1344:6;1335:7;1332:19;1325:810;;;1410:1;1397:15;;;1491:14;;1644:4;1632:2;1628:14;;;1624:25;;1610:40;;1604:47;1599:3;1595:57;;;1577:76;;1772:2;1768:14;;;1764:25;;1750:40;;1744:47;1735:57;;1698:1;1683:17;;1717:76;1913:1;1908:14;;;1904:25;;1890:40;;1884:47;1875:57;;1823:17;;;1857:76;2044:25;;2030:40;;2024:47;2015:57;;1963:17;;;1997:76;;;;2103:17;;1325:810;;;2220:1;2213:4;2207:11;2203:19;2241:1;2236:54;;;;2309:1;2304:52;;;;2196:160;;2236:54;-1:-1:-1;;;;;2252:17:0;;2245:43;2236:54;;2304:52;-1:-1:-1;;;;;2320:17:0;;2313:41;2196:160;-1:-1:-1;2394:6:0;;371:2037;-1:-1:-1;;;;;;;;371:2037:0:o;51384:305::-;51486:4;-1:-1:-1;;;;;;51523:40:0;;-1:-1:-1;;;51523:40:0;;:105;;-1:-1:-1;;;;;;;51580:48:0;;-1:-1:-1;;;51580:48:0;51523:105;:158;;;-1:-1:-1;;;;;;;;;;36758:40:0;;;51645:36;36649:157;66113:589;-1:-1:-1;;;;;66319:18:0;;66315:187;;66354:40;66386:7;67529:10;:17;;67502:24;;;;:15;:24;;;;;:44;;;67557:24;;;;;;;;;;;;67425:164;66354:40;66315:187;;;66424:2;-1:-1:-1;;;;;66416:10:0;:4;-1:-1:-1;;;;;66416:10:0;;66412:90;;66443:47;66476:4;66482:7;66443:32;:47::i;:::-;-1:-1:-1;;;;;66516:16:0;;66512:183;;66549:45;66586:7;66549:36;:45::i;66512:183::-;66622:4;-1:-1:-1;;;;;66616:10:0;:2;-1:-1:-1;;;;;66616:10:0;;66612:83;;66643:40;66671:2;66675:7;66643:27;:40::i;58603:321::-;58733:18;58739:2;58743:7;58733:5;:18::i;:::-;58784:54;58815:1;58819:2;58823:7;58832:5;58784:22;:54::i;:::-;58762:154;;;;-1:-1:-1;;;58762:154:0;;;;;;;:::i;62003:799::-;62158:4;-1:-1:-1;;;;;62179:13:0;;27032:20;27080:8;62175:620;;62215:72;;-1:-1:-1;;;62215:72:0;;-1:-1:-1;;;;;62215:36:0;;;;;:72;;23531:10;;62266:4;;62272:7;;62281:5;;62215:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62215:72:0;;;;;;;;-1:-1:-1;;62215:72:0;;;;;;;;;;;;:::i;:::-;;;62211:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62457:13:0;;62453:272;;62500:60;;-1:-1:-1;;;62500:60:0;;;;;;;:::i;62453:272::-;62675:6;62669:13;62660:6;62656:2;62652:15;62645:38;62211:529;-1:-1:-1;;;;;;62338:51:0;-1:-1:-1;;;62338:51:0;;-1:-1:-1;62331:58:0;;62175:620;-1:-1:-1;62779:4:0;62003:799;;;;;;:::o;68216:988::-;68482:22;68532:1;68507:22;68524:4;68507:16;:22::i;:::-;:26;;;;:::i;:::-;68544:18;68565:26;;;:17;:26;;;;;;68482:51;;-1:-1:-1;68698:28:0;;;68694:328;;-1:-1:-1;;;;;68765:18:0;;68743:19;68765:18;;;:12;:18;;;;;;;;:34;;;;;;;;;68816:30;;;;;;:44;;;68933:30;;:17;:30;;;;;:43;;;68694:328;-1:-1:-1;69118:26:0;;;;:17;:26;;;;;;;;69111:33;;;-1:-1:-1;;;;;69162:18:0;;;;;:12;:18;;;;;:34;;;;;;;69155:41;68216:988::o;69499:1079::-;69777:10;:17;69752:22;;69777:21;;69797:1;;69777:21;:::i;:::-;69809:18;69830:24;;;:15;:24;;;;;;70203:10;:26;;69752:46;;-1:-1:-1;69830:24:0;;69752:46;;70203:26;;;;;;:::i;:::-;;;;;;;;;70181:48;;70267:11;70242:10;70253;70242:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;70347:28;;;:15;:28;;;;;;;:41;;;70519:24;;;;;70512:31;70554:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;69570:1008;;;69499:1079;:::o;67003:221::-;67088:14;67105:20;67122:2;67105:16;:20::i;:::-;-1:-1:-1;;;;;67136:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;67181:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;67003:221:0:o;59260:382::-;-1:-1:-1;;;;;59340:16:0;;59332:61;;;;-1:-1:-1;;;59332:61:0;;18315:2:1;59332:61:0;;;18297:21:1;;;18334:18;;;18327:30;18393:34;18373:18;;;18366:62;18445:18;;59332:61:0;18113:356:1;59332:61:0;57347:4;57371:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57371:16:0;:30;59404:58;;;;-1:-1:-1;;;59404:58:0;;14118:2:1;59404:58:0;;;14100:21:1;14157:2;14137:18;;;14130:30;14196;14176:18;;;14169:58;14244:18;;59404:58:0;13916:352:1;59404:58:0;59475:45;59504:1;59508:2;59512:7;59475:20;:45::i;:::-;-1:-1:-1;;;;;59533:13:0;;;;;;:9;:13;;;;;:18;;59550:1;;59533:13;:18;;59550:1;;59533:18;:::i;:::-;;;;-1:-1:-1;;59562:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;59562:21:0;-1:-1:-1;;;;;59562:21:0;;;;;;;;59601:33;;59562:16;;;59601:33;;59562:16;;59601:33;59260:382;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;828:160;893:20;;949:13;;942:21;932:32;;922:60;;978:1;975;968:12;993:221;1036:5;1089:3;1082:4;1074:6;1070:17;1066:27;1056:55;;1107:1;1104;1097:12;1056:55;1129:79;1204:3;1195:6;1182:20;1175:4;1167:6;1163:17;1129:79;:::i;1219:186::-;1278:6;1331:2;1319:9;1310:7;1306:23;1302:32;1299:52;;;1347:1;1344;1337:12;1299:52;1370:29;1389:9;1370:29;:::i;1410:260::-;1478:6;1486;1539:2;1527:9;1518:7;1514:23;1510:32;1507:52;;;1555:1;1552;1545:12;1507:52;1578:29;1597:9;1578:29;:::i;:::-;1568:39;;1626:38;1660:2;1649:9;1645:18;1626:38;:::i;:::-;1616:48;;1410:260;;;;;:::o;1675:328::-;1752:6;1760;1768;1821:2;1809:9;1800:7;1796:23;1792:32;1789:52;;;1837:1;1834;1827:12;1789:52;1860:29;1879:9;1860:29;:::i;:::-;1850:39;;1908:38;1942:2;1931:9;1927:18;1908:38;:::i;:::-;1898:48;;1993:2;1982:9;1978:18;1965:32;1955:42;;1675:328;;;;;:::o;2008:666::-;2103:6;2111;2119;2127;2180:3;2168:9;2159:7;2155:23;2151:33;2148:53;;;2197:1;2194;2187:12;2148:53;2220:29;2239:9;2220:29;:::i;:::-;2210:39;;2268:38;2302:2;2291:9;2287:18;2268:38;:::i;:::-;2258:48;;2353:2;2342:9;2338:18;2325:32;2315:42;;2408:2;2397:9;2393:18;2380:32;2435:18;2427:6;2424:30;2421:50;;;2467:1;2464;2457:12;2421:50;2490:22;;2543:4;2535:13;;2531:27;-1:-1:-1;2521:55:1;;2572:1;2569;2562:12;2521:55;2595:73;2660:7;2655:2;2642:16;2637:2;2633;2629:11;2595:73;:::i;:::-;2585:83;;;2008:666;;;;;;;:::o;2679:254::-;2744:6;2752;2805:2;2793:9;2784:7;2780:23;2776:32;2773:52;;;2821:1;2818;2811:12;2773:52;2844:29;2863:9;2844:29;:::i;:::-;2834:39;;2892:35;2923:2;2912:9;2908:18;2892:35;:::i;2938:254::-;3006:6;3014;3067:2;3055:9;3046:7;3042:23;3038:32;3035:52;;;3083:1;3080;3073:12;3035:52;3106:29;3125:9;3106:29;:::i;:::-;3096:39;3182:2;3167:18;;;;3154:32;;-1:-1:-1;;;2938:254:1:o;3197:245::-;3255:6;3308:2;3296:9;3287:7;3283:23;3279:32;3276:52;;;3324:1;3321;3314:12;3276:52;3363:9;3350:23;3382:30;3406:5;3382:30;:::i;3447:249::-;3516:6;3569:2;3557:9;3548:7;3544:23;3540:32;3537:52;;;3585:1;3582;3575:12;3537:52;3617:9;3611:16;3636:30;3660:5;3636:30;:::i;3701:322::-;3770:6;3823:2;3811:9;3802:7;3798:23;3794:32;3791:52;;;3839:1;3836;3829:12;3791:52;3879:9;3866:23;3912:18;3904:6;3901:30;3898:50;;;3944:1;3941;3934:12;3898:50;3967;4009:7;4000:6;3989:9;3985:22;3967:50;:::i;4028:180::-;4087:6;4140:2;4128:9;4119:7;4115:23;4111:32;4108:52;;;4156:1;4153;4146:12;4108:52;-1:-1:-1;4179:23:1;;4028:180;-1:-1:-1;4028:180:1:o;4213:680::-;4316:6;4324;4332;4340;4393:3;4381:9;4372:7;4368:23;4364:33;4361:53;;;4410:1;4407;4400:12;4361:53;4446:9;4433:23;4423:33;;4475:35;4506:2;4495:9;4491:18;4475:35;:::i;:::-;4465:45;;4561:2;4550:9;4546:18;4533:32;4584:18;4625:2;4617:6;4614:14;4611:34;;;4641:1;4638;4631:12;4611:34;4664:50;4706:7;4697:6;4686:9;4682:22;4664:50;:::i;:::-;4654:60;;4767:2;4756:9;4752:18;4739:32;4723:48;;4796:2;4786:8;4783:16;4780:36;;;4812:1;4809;4802:12;4780:36;;4835:52;4879:7;4868:8;4857:9;4853:24;4835:52;:::i;4898:316::-;4975:6;4983;4991;5044:2;5032:9;5023:7;5019:23;5015:32;5012:52;;;5060:1;5057;5050:12;5012:52;-1:-1:-1;;5083:23:1;;;5153:2;5138:18;;5125:32;;-1:-1:-1;5204:2:1;5189:18;;;5176:32;;4898:316;-1:-1:-1;4898:316:1:o;5219:257::-;5260:3;5298:5;5292:12;5325:6;5320:3;5313:19;5341:63;5397:6;5390:4;5385:3;5381:14;5374:4;5367:5;5363:16;5341:63;:::i;:::-;5458:2;5437:15;-1:-1:-1;;5433:29:1;5424:39;;;;5465:4;5420:50;;5219:257;-1:-1:-1;;5219:257:1:o;5481:973::-;5566:12;;5531:3;;5621:1;5641:18;;;;5694;;;;5721:61;;5775:4;5767:6;5763:17;5753:27;;5721:61;5801:2;5849;5841:6;5838:14;5818:18;5815:38;5812:161;;;5895:10;5890:3;5886:20;5883:1;5876:31;5930:4;5927:1;5920:15;5958:4;5955:1;5948:15;5812:161;5989:18;6016:104;;;;6134:1;6129:319;;;;5982:466;;6016:104;-1:-1:-1;;6049:24:1;;6037:37;;6094:16;;;;-1:-1:-1;6016:104:1;;6129:319;24532:1;24525:14;;;24569:4;24556:18;;6223:1;6237:165;6251:6;6248:1;6245:13;6237:165;;;6329:14;;6316:11;;;6309:35;6372:16;;;;6266:10;;6237:165;;;6241:3;;6431:6;6426:3;6422:16;6415:23;;5982:466;;;;;;;5481:973;;;;:::o;6459:274::-;6588:3;6626:6;6620:13;6642:53;6688:6;6683:3;6676:4;6668:6;6664:17;6642:53;:::i;:::-;6711:16;;;;;6459:274;-1:-1:-1;;6459:274:1:o;6738:470::-;6917:3;6955:6;6949:13;6971:53;7017:6;7012:3;7005:4;6997:6;6993:17;6971:53;:::i;:::-;7087:13;;7046:16;;;;7109:57;7087:13;7046:16;7143:4;7131:17;;7109:57;:::i;:::-;7182:20;;6738:470;-1:-1:-1;;;;6738:470:1:o;7213:550::-;7437:3;7475:6;7469:13;7491:53;7537:6;7532:3;7525:4;7517:6;7513:17;7491:53;:::i;:::-;7607:13;;7566:16;;;;7629:57;7607:13;7566:16;7663:4;7651:17;;7629:57;:::i;:::-;7702:55;7747:8;7740:5;7736:20;7728:6;7702:55;:::i;:::-;7695:62;7213:550;-1:-1:-1;;;;;;;7213:550:1:o;7768:518::-;8045:3;8073:38;8107:3;8099:6;8073:38;:::i;:::-;-1:-1:-1;;;8127:2:1;8120:16;8165:6;8159:13;8181:60;8234:6;8230:1;8226:2;8222:10;8215:4;8207:6;8203:17;8181:60;:::i;:::-;8261:15;8278:1;8257:23;;7768:518;-1:-1:-1;;;;7768:518:1:o;8291:1351::-;-1:-1:-1;;;8940:43:1;;9006:13;;8922:3;;9028:61;9006:13;9078:1;9069:11;;9062:4;9050:17;;9028:61;:::i;:::-;-1:-1:-1;;;9148:1:1;9108:16;;;9140:10;;;9133:68;9226:13;;9248:63;9226:13;9297:2;9289:11;;9282:4;9270:17;;9248:63;:::i;:::-;-1:-1:-1;;;9371:2:1;9330:17;;;;9363:11;;;9356:63;9444:13;;9466:63;9444:13;9515:2;9507:11;;9500:4;9488:17;;9466:63;:::i;:::-;-1:-1:-1;;;9589:2:1;9548:17;;;;9581:11;;;9574:35;9633:2;9625:11;;8291:1351;-1:-1:-1;;;;;8291:1351:1:o;9647:1177::-;10305:26;10300:3;10293:39;10275:3;10361:6;10355:13;10377:62;10432:6;10427:2;10422:3;10418:12;10411:4;10403:6;10399:17;10377:62;:::i;:::-;-1:-1:-1;;;10498:2:1;10458:16;;;10490:11;;;10483:26;10528:46;10570:2;10562:11;;10554:6;10528:46;:::i;:::-;10518:56;;-1:-1:-1;;;10590:2:1;10583:29;10643:6;10637:13;10659:63;10713:8;10708:2;10704;10700:11;10693:4;10685:6;10681:17;10659:63;:::i;:::-;-1:-1:-1;;;10782:2:1;10741:17;;;;10774:11;;;10767:24;10815:2;10807:11;;9647:1177;-1:-1:-1;;;;;9647:1177:1:o;10829:448::-;11091:31;11086:3;11079:44;11061:3;11152:6;11146:13;11168:62;11223:6;11218:2;11213:3;11209:12;11202:4;11194:6;11190:17;11168:62;:::i;:::-;11250:16;;;;11268:2;11246:25;;10829:448;-1:-1:-1;;10829:448:1:o;11490:488::-;-1:-1:-1;;;;;11759:15:1;;;11741:34;;11811:15;;11806:2;11791:18;;11784:43;11858:2;11843:18;;11836:34;;;11906:3;11901:2;11886:18;;11879:31;;;11684:4;;11927:45;;11952:19;;11944:6;11927:45;:::i;:::-;11919:53;11490:488;-1:-1:-1;;;;;;11490:488:1:o;12454:219::-;12603:2;12592:9;12585:21;12566:4;12623:44;12663:2;12652:9;12648:18;12640:6;12623:44;:::i;13090:414::-;13292:2;13274:21;;;13331:2;13311:18;;;13304:30;13370:34;13365:2;13350:18;;13343:62;-1:-1:-1;;;13436:2:1;13421:18;;13414:48;13494:3;13479:19;;13090:414::o;19230:356::-;19432:2;19414:21;;;19451:18;;;19444:30;19510:34;19505:2;19490:18;;19483:62;19577:2;19562:18;;19230:356::o;20001:411::-;20203:2;20185:21;;;20242:2;20222:18;;;20215:30;20281:34;20276:2;20261:18;;20254:62;-1:-1:-1;;;20347:2:1;20332:18;;20325:45;20402:3;20387:19;;20001:411::o;21166:413::-;21368:2;21350:21;;;21407:2;21387:18;;;21380:30;21446:34;21441:2;21426:18;;21419:62;-1:-1:-1;;;21512:2:1;21497:18;;21490:47;21569:3;21554:19;;21166:413::o;23272:688::-;23573:6;23562:9;23555:25;23616:3;23611:2;23600:9;23596:18;23589:31;23536:4;23643:45;23683:3;23672:9;23668:19;23660:6;23643:45;:::i;:::-;23736:9;23728:6;23724:22;23719:2;23708:9;23704:18;23697:50;23770:32;23795:6;23787;23770:32;:::i;:::-;23756:46;;23850:9;23842:6;23838:22;23833:2;23822:9;23818:18;23811:50;23878:32;23903:6;23895;23878:32;:::i;:::-;23870:40;;;23947:6;23941:3;23930:9;23926:19;23919:35;23272:688;;;;;;;;:::o;24585:128::-;24625:3;24656:1;24652:6;24649:1;24646:13;24643:39;;;24662:18;;:::i;:::-;-1:-1:-1;24698:9:1;;24585:128::o;24718:120::-;24758:1;24784;24774:35;;24789:18;;:::i;:::-;-1:-1:-1;24823:9:1;;24718:120::o;24843:168::-;24883:7;24949:1;24945;24941:6;24937:14;24934:1;24931:21;24926:1;24919:9;24912:17;24908:45;24905:71;;;24956:18;;:::i;:::-;-1:-1:-1;24996:9:1;;24843:168::o;25016:125::-;25056:4;25084:1;25081;25078:8;25075:34;;;25089:18;;:::i;:::-;-1:-1:-1;25126:9:1;;25016:125::o;25146:258::-;25218:1;25228:113;25242:6;25239:1;25236:13;25228:113;;;25318:11;;;25312:18;25299:11;;;25292:39;25264:2;25257:10;25228:113;;;25359:6;25356:1;25353:13;25350:48;;;-1:-1:-1;;25394:1:1;25376:16;;25369:27;25146:258::o;25409:380::-;25488:1;25484:12;;;;25531;;;25552:61;;25606:4;25598:6;25594:17;25584:27;;25552:61;25659:2;25651:6;25648:14;25628:18;25625:38;25622:161;;;25705:10;25700:3;25696:20;25693:1;25686:31;25740:4;25737:1;25730:15;25768:4;25765:1;25758:15;25622:161;;25409:380;;;:::o;25794:135::-;25833:3;-1:-1:-1;;25854:17:1;;25851:43;;;25874:18;;:::i;:::-;-1:-1:-1;25921:1:1;25910:13;;25794:135::o;25934:112::-;25966:1;25992;25982:35;;25997:18;;:::i;:::-;-1:-1:-1;26031:9:1;;25934:112::o;26051:127::-;26112:10;26107:3;26103:20;26100:1;26093:31;26143:4;26140:1;26133:15;26167:4;26164:1;26157:15;26183:127;26244:10;26239:3;26235:20;26232:1;26225:31;26275:4;26272:1;26265:15;26299:4;26296:1;26289:15;26315:127;26376:10;26371:3;26367:20;26364:1;26357:31;26407:4;26404:1;26397:15;26431:4;26428:1;26421:15;26447:127;26508:10;26503:3;26499:20;26496:1;26489:31;26539:4;26536:1;26529:15;26563:4;26560:1;26553:15;26579:127;26640:10;26635:3;26631:20;26628:1;26621:31;26671:4;26668:1;26661:15;26695:4;26692:1;26685:15;26711:131;-1:-1:-1;;;;;;26785:32:1;;26775:43;;26765:71;;26832:1;26829;26822:12

ipfs://65ac933859d5915ae33c69bf3e30d86969667846455440d70618d82acaf74267