Contract 0xb9DE41917B46a9233003067d6479D48e013c7d96 1

Txn Hash Method
Block
From
To
Value [Txn Fee]
0xb5c8f42356e87fdf5e2011d8cfc3cf4ebe3b5925470d4dce13ed201fbf9a7b80Un Pledge117863472022-01-15 13:24:3312 days 18 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.000077679 2.25
0x982b6b145ecc62678340adc4aac9aff5e709726c5c891a7dbd1fd79c43e8047aPledge117848722022-01-15 12:10:4812 days 19 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.000132255 2.25
0x34b59c74a01fd13f8702c80079fb48358e151c9b54a4f399326a123ed2d00e95Mint Flee117836212022-01-15 11:08:1512 days 20 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.000613782 2.25
0x8aa587203ace52179139cf1c3166da369f301b36361d51616cc490f4f3ed246fMint Ship Work117835782022-01-15 11:06:0612 days 20 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.000618048 2.25
0x8c43f23a3f6c7cb98e406e552848b7a9e6b64941519c5b7c5231330a71b2eb01Mint Ship Work117835422022-01-15 11:04:1812 days 20 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.00088400475 2.25
0xa87f778fce0d47bfd7cd7696b12ba1d081a27d79f45ee543a9e99311509bae0bFlip Sale State117829362022-01-15 10:34:0012 days 21 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.000114115 2.5
0xa959027bcf873152ca2af9b3525bef5c0afcd8fa9fce1130096498d69aaa7e74Set Base URI117829322022-01-15 10:33:4812 days 21 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN 0xb9de41917b46a9233003067d6479d48e013c7d960 HT0.0002298 2.5
0xb32d525870720860e69c0ec8ba5acb728bfc2074b9d59b178be3e530b95b82ee0x60e06040117828202022-01-15 10:28:1212 days 21 hrs ago0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9 IN  Create: TShip0 HT0.0134051475 2.5
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
TShip

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at hecoinfo.com on 2022-01-15
*/

/**
 *Submitted for verification at Etherscan.io on 2021-09-01
*/

/**
 *Submitted for verification at Etherscan.io on 2021-08-18
*/

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this;
        // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

interface TokenMint {
    function balanceOf(address _owner) external returns (uint256);

    function transfer(address _to, uint256 _value) external;

    function setPowerOne(address owner, uint256 powerOne) external;

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
/**
 * @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);
}


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

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


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


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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}


/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) {// Equivalent to !contains(map, key)
            map._entries.push(MapEntry({_key : key, _value : value}));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

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

        if (keyIndex != 0) {// Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

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

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1;
            // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

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

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

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

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0);
        // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value);
        // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key");
        // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value;
        // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage);
        // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value;
        // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

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

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}


/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping(address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;
    EnumerableMap.UintToAddressMap private _amountShipOneTotal;
    EnumerableMap.UintToAddressMap private _amountShipTwoTotal;
    EnumerableMap.UintToAddressMap private _amountShipThreeTotal;
    EnumerableMap.UintToAddressMap private _amountWorkOneTotal;
    EnumerableMap.UintToAddressMap private _amountWorkTwoTotal;
    EnumerableMap.UintToAddressMap private _amountWorkThreeTotal;
    EnumerableMap.UintToAddressMap private _amount;

    // 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;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

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

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @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 _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @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 _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI, '.json'));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, (tokenId.toString()), ".txt"));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    // ship one start totalSupply
    function amountShipOneTotal() public view virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _amountShipOneTotal.length();
    }

    // ship two start totalSupply
    function amountShipTwoTotal() public view virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _amountShipTwoTotal.length();
    }

    // ship three start totalSupply
    function amountShipThreeTotal() public view virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _amountShipThreeTotal.length();
    }

    // worker one start totalSupply
    function amountWorkOneTotal() public view virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _amountWorkOneTotal.length();
    }

    // worker two start totalSupply
    function amountWorkTwoTotal() public view virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _amountWorkTwoTotal.length();
    }

    // worker three start totalSupply
    function amountWorkThreeTotal() public view virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _amountWorkThreeTotal.length();
    }





    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId,) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @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 || ERC721.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 _tokenOwners.contains(tokenId);
    }

    /**
     * @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 || ERC721.isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `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);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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


    // ship one start set
    function _amountShipOneSet(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        _amountShipOneTotal.set(tokenId, to);
    }

    // ship two start set
    function _amountShipTwoSet(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        _amountShipTwoTotal.set(tokenId, to);
    }

    // ship three start set
    function _amountShipThreeSet(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        _amountShipThreeTotal.set(tokenId, to);
    }


    // workers one start set
    function _amountWorkOneSet(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        _amountWorkOneTotal.set(tokenId, to);
    }

    // workers two start set
    function _amountWorkTwoSet(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        _amountWorkTwoTotal.set(tokenId, to);
    }

    // workers three start set
    function _amountWorkThreeSet(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        _amountWorkThreeTotal.set(tokenId, to);
    }




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

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

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

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(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");
        // internal owner
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @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()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
                IERC721Receiver(to).onERC721Received.selector,
                _msgSender(),
                from,
                tokenId,
                _data
            ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

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

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

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

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

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

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

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

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

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

contract TShip is ERC721, Ownable {
    using SafeMath for uint256;
    using SafeMath for uint256;
    shipMapping.itmap dataShip;
    OwnersMapping.itmap data2;

    // dataShip
    // 合成
    function insert(address key, uint256 shipTokenId, uint256 power, uint256[] memory works) internal returns (bool)
    {
        return shipMapping.insert(dataShip, key, shipTokenId, power, works);
    }

    // 质押
    function update(address key, uint256 shipTokenId) internal returns (bool)
    {
        return shipMapping.update(dataShip, key, shipTokenId);
    }
    // 解除质押
    function releive(address key, uint256 shipTokenId) internal returns (bool)
    {
        return shipMapping.releive(dataShip, key, shipTokenId);
    }

    //解散
    function remove(address key, uint256 shipTokenId) internal returns (bool)
    {
        return shipMapping.remove(dataShip, key, shipTokenId);
    }

    // 充值
    function recharge(address key, uint256 shipTokenId, uint256 tokenAmount) public returns (bool)
    {
        return shipMapping.recharge(dataShip, key, shipTokenId, tokenAmount);
    }

    // 查询剩余时间
    function balanceTime(address key, uint256 shipTokenId) public view returns (uint256)
    {
        return shipMapping.balanceTime(dataShip, key, shipTokenId);
    }


    // 是否已合成
    function contains(address key, uint256 shipTokenId) public view returns (bool)
    {
        return shipMapping.contains(dataShip, key, shipTokenId);
    }

    // 合成总数量
    function getsize() public view returns (uint256)
    {
        return shipMapping.getsize(dataShip);
    }

    // 未质押 ids 合集
    function getAllShipIdsNotPle(address key) public view returns (uint256[] memory)
    {
        return shipMapping.getAllShipIdsNotPle(dataShip, key);
    }

    // 质押 ids 合集
    function getAllShipIdsPle(address key) public view returns (uint256[] memory)
    {
        return shipMapping.getAllShipIdsPle(dataShip, key);
    }

    // 未质押 算力汇总
    function getAllShipIdsPowerNotPle(address key) public view returns (uint256)
    {
        return shipMapping.getAllShipIdsPowerNotPle(dataShip, key);
    }

    // 质押 算力汇总
    function getAllShipIdsPowerPle(address key) public view returns (uint256)
    {
        return shipMapping.getAllShipIdsPowerPle(dataShip, key);
    }

    // 质押 算力汇总且有效的
    function getAllShipIdsPowerPleValid(address key) public view returns (uint256)
    {
        return shipMapping.getAllShipIdsPowerPleValid(dataShip, key);
    }



    // 质押 算力汇总
    function getShipEnergy(address key, uint256 shipTokenId) public view returns (uint256)
    {
        return shipMapping.getShipEnergy(dataShip, key, shipTokenId);
    }

    // 查询到期时间
    function getShipOverTime(address key, uint256 shipTokenId) public view returns (uint256)
    {
        return shipMapping.getShipOverTime(dataShip, key, shipTokenId);
    }

    // 查询到合成后的组成
    function getShipWorks(address key, uint256 shipTokenId) public view returns (uint256[] memory)
    {
        return shipMapping.getShipWorks(dataShip, key, shipTokenId);
    }
    // 查询某个workId是否已合成
    function getShipWorksStatus(uint256 workId) public view returns (bool)
    {
        return shipMapping.getShipWorksStatus(dataShip, workId);
    }

    // 查询某个shipId状态
    function getShipStatus(address key, uint256 shipTokenId) public view returns (bool)
    {
        return shipMapping.getShipStatus(dataShip, key, shipTokenId);
    }


    // data2*************
    //data2
    function insert2(address key, uint256 tokenId) internal returns (bool)
    {
        return OwnersMapping.insert(data2, key, tokenId);
    }

    function add2(address key, uint256 tokenId) internal returns (bool)
    {
        return OwnersMapping.add(data2, key, tokenId);
    }

    function del2(address key, uint256 tokenId) internal returns (bool)
    {
        return OwnersMapping.del(data2, key, tokenId);
    }

    function contains2(address key) public view returns (bool)
    {
        return OwnersMapping.contains(data2, key);
    }

    function getTokenIds(address key) public returns (uint256[] memory)
    {

        uint256[]  memory tokenIds = OwnersMapping.getTokenIds(data2, key);
        uint256[] memory allIds = new uint256[](tokenIds.length);
        for (uint256 i; i < tokenIds.length; i++) {
            if (ERC721.ownerOf(tokenIds[i]) == key) {
                allIds[i] = tokenIds[i];
            }
        }
        return allIds;
    }


    mapping(uint256 => uint256) private amountShip;
    mapping(uint256 => uint256) private priceShip;
    mapping(uint256 => uint256) private bearShip;

    mapping(uint256 => uint256) private amountWork;
    mapping(uint256 => uint256) private priceWork;
    mapping(uint256 => uint256) private powerWork;

    uint256 public immutable maxPerTx;
    uint256 public immutable maxNumber; // 10240

    mapping(address => mapping(uint256 => uint256)) private _pledgePowers; // 质押数据
    mapping(uint256 => uint256) private _tokenPowers; // token的算力数据
    mapping(address => uint256) private _addRessPowers; // address地址的算力汇总
    uint256 public totalPower; // 当前质押总算力

    address private immutable reserveAddress;
    bool public isSaleActive;

    constructor(address _reserveAddress)
    public
    ERC721("tShip", "tShip")
    {
        maxNumber = 8000;
        maxPerTx = 10;
        // ship
        amountShip[1] = 10000;
        amountShip[2] = 20000;
        amountShip[3] = 30000;
        priceShip[1] = 3 * 10 ** 17;
        priceShip[2] = 6 * 10 ** 17;
        priceShip[3] = 9 * 10 ** 17;
        bearShip[1] = 1;
        bearShip[2] = 2;
        bearShip[3] = 3;


        //work
        amountWork[1] = 40000;
        amountWork[2] = 50000;
        amountWork[3] = 60000;
        priceWork[1] = 3 * 10 ** 17;
        priceWork[2] = 6 * 10 ** 17;
        priceWork[3] = 9 * 10 ** 17;
        powerWork[1] = 100;
        powerWork[2] = 200;
        powerWork[3] = 300;


        reserveAddress = _reserveAddress;
    }



    // 质押
    function pledge(uint256 shipId) public {
        address owner = ERC721.ownerOf(shipId);
        require(owner == msg.sender, "not owner");
        require(!getShipStatus(msg.sender, shipId), "tokenId not insert or already ple");
        require(update(msg.sender, shipId), "update false");
        //uint256 powerNow = getAllShipIdsPowerPle(msg.sender);
       // TokenMint tokenMint = TokenMint(tokenAddr);
       // tokenMint.setPowerOne(msg.sender, powerNow);
    }

    // 解除质押战队
    function unPledge(uint256 shipId) public {
        address owner = ERC721.ownerOf(shipId);
        require(owner == msg.sender, "not owner");
        require(getShipStatus(msg.sender, shipId), "tokenId not insert or have not ple");
        releive(msg.sender, shipId);
        //uint256 powerNow = getAllShipIdsPowerPle(msg.sender);
        //TokenMint token = TokenMint(tokenAddr);
       // token.setPowerOne(msg.sender, powerNow);
    }

    //解散战队
    function releasePledge(uint256 shipId) public {
        address owner = ERC721.ownerOf(shipId);
        require(owner == msg.sender, "not owner");
        require(getShipStatus(msg.sender, shipId), "tokenId not insert or have not ple");
        remove(msg.sender, shipId);
    }

    // mint ship and work
    function mintShipWork(uint256 tpe) public payable {
        require(isSaleActive, "Sale is not active");
        require(totalSupply().add(1) <= maxNumber, "Purchase would exceed max supply of Martial");
        uint256 mintIndex;
        uint256 price;
        if (tpe == 1) {//ship one star
            require(amountShipOneTotal().add(1) <= amountShip[1], "Purchase would exceed max supply of Martial");
            mintIndex = amountShipOneTotal().add(1);
            price = priceShip[1];
            _amountShipOneSet(msg.sender, mintIndex);
        } else if (tpe == 2) {//ship two star
            require(amountShipTwoTotal().add(1).add(amountShip[1]) <= amountShip[2], "Purchase would exceed max supply of Martial");
            mintIndex = amountShipTwoTotal().add(1).add(amountShip[1]);
            price = priceShip[2];
            _amountShipTwoSet(msg.sender, mintIndex);
        } else if (tpe == 3) {//ship three star
            require(amountShipThreeTotal().add(1).add(amountShip[2]) <= amountShip[3], "Purchase would exceed max supply of Martial");
            mintIndex = amountShipThreeTotal().add(1).add(amountShip[2]);
            price = priceShip[3];
            _amountShipThreeSet(msg.sender, mintIndex);
        } else if (tpe == 4) {//work one star
            require(amountWorkOneTotal().add(1).add(amountShip[3]) <= amountWork[1], "Purchase would exceed max supply of Martial");
            mintIndex = amountWorkOneTotal().add(1).add(amountShip[3]);
            price = priceWork[1];
            _amountWorkOneSet(msg.sender, mintIndex);
        } else if (tpe == 5) {//work two star
            require(amountWorkTwoTotal().add(1).add(amountWork[1]) <= amountWork[2], "Purchase would exceed max supply of Martial");
            mintIndex = amountWorkTwoTotal().add(1).add(amountWork[1]);
            price = priceWork[2];
            _amountWorkTwoSet(msg.sender, mintIndex);
        } else if (tpe == 6) {//work three star
            require(amountWorkThreeTotal().add(1).add(amountWork[2]) <= amountWork[3], "Purchase would exceed max supply of Martial");
            mintIndex = amountWorkThreeTotal().add(1).add(amountWork[2]);
            price = priceWork[3];
            _amountWorkThreeSet(msg.sender, mintIndex);
        }

        if (totalSupply() < maxNumber) {
            _safeMint(msg.sender, mintIndex);
            if (!contains2(msg.sender)) {
                insert2(msg.sender, mintIndex);
            } else {
                add2(msg.sender, mintIndex);
            }
        }
        require(price.mul(1) >= msg.value, "Ether value is not correct");
        payable(owner()).transfer(msg.value);
    }

    // mint ship and work free Test todo
    function mintShipWorkFree(uint256 tpe) public {
        require(isSaleActive, "Sale is not active");
        require(totalSupply().add(1) <= maxNumber, "Purchase would exceed max supply of Martial");
        uint256 mintIndex;
        uint256 price;
        if (tpe == 1) {//ship one star
            require(amountShipOneTotal().add(1) <= amountShip[1], "Purchase would exceed max supply of Martial");
            mintIndex = amountShipOneTotal().add(1);
            price = priceShip[1];
            _amountShipOneSet(msg.sender, mintIndex);
        } else if (tpe == 2) {//ship two star
            require(amountShipTwoTotal().add(1).add(amountShip[1]) <= amountShip[2], "Purchase would exceed max supply of Martial");
            mintIndex = amountShipTwoTotal().add(1).add(amountShip[1]);
            price = priceShip[2];
            _amountShipTwoSet(msg.sender, mintIndex);
        } else if (tpe == 3) {//ship three star
            require(amountShipThreeTotal().add(1).add(amountShip[2]) <= amountShip[3], "Purchase would exceed max supply of Martial");
            mintIndex = amountShipThreeTotal().add(1).add(amountShip[2]);
            price = priceShip[3];
            _amountShipThreeSet(msg.sender, mintIndex);
        } else if (tpe == 4) {//work one star
            require(amountWorkOneTotal().add(1).add(amountShip[3]) <= amountWork[1], "Purchase would exceed max supply of Martial");
            mintIndex = amountWorkOneTotal().add(1).add(amountShip[3]);
            price = priceWork[1];
            _amountWorkOneSet(msg.sender, mintIndex);
        } else if (tpe == 5) {//work two star
            require(amountWorkTwoTotal().add(1).add(amountWork[1]) <= amountWork[2], "Purchase would exceed max supply of Martial");
            mintIndex = amountWorkTwoTotal().add(1).add(amountWork[1]);
            price = priceWork[2];
            _amountWorkTwoSet(msg.sender, mintIndex);
        } else if (tpe == 6) {//work three star
            require(amountWorkThreeTotal().add(1).add(amountWork[2]) <= amountWork[3], "Purchase would exceed max supply of Martial");
            mintIndex = amountWorkThreeTotal().add(1).add(amountWork[2]);
            price = priceWork[3];
            _amountWorkThreeSet(msg.sender, mintIndex);
        }

        if (totalSupply() < maxNumber) {
            _safeMint(msg.sender, mintIndex);
            if (!contains2(msg.sender)) {
                insert2(msg.sender, mintIndex);
            } else {
                add2(msg.sender, mintIndex);
            }
        }
    }

    // set flees
    function mintFlee(uint256 shipTokenId, uint256[] memory workTokenIds) public {
        require(isSaleActive, "Sale is not active");
        require(ERC721.ownerOf(shipTokenId) == msg.sender, "ERC721: transfer of token shipTokenId that is not own");
        require(workTokenIds.length != 0, "ERC721: workTokenIds is zero");
        require(!contains(msg.sender, shipTokenId), "ERC721: shipTokenId already mintFlee");
        if (shipTokenId > 0 && shipTokenId <= amountShip[1]) {
            require(workTokenIds.length == bearShip[1], "no more than one");
        } else if (shipTokenId > amountShip[1] && shipTokenId <= amountShip[2]) {
            require(workTokenIds.length == bearShip[2], "no more than two");
        } else if (shipTokenId > amountShip[2] && shipTokenId <= amountShip[3]) {
            require(workTokenIds.length == bearShip[3], "no more three two");
        }
        for (uint j = 0; j < workTokenIds.length; j++) {
            if (ERC721.ownerOf(workTokenIds[j]) != msg.sender) {
                return;
            }
        }
        uint256 powerAll = 0;
        for (uint j = 0; j < workTokenIds.length; j++) {
            if (workTokenIds[j] >= (amountShip[3].add(1)) && workTokenIds[j] <= amountWork[1]) {
                powerAll += powerWork[1];
            }
            if (workTokenIds[j] >= (amountWork[1].add(1)) && workTokenIds[j] <= amountWork[2]) {
                powerAll += powerWork[2];
            }
            if (workTokenIds[j] >= (amountWork[2].add(1)) && workTokenIds[j] <= amountWork[3]) {
                powerAll += powerWork[3];
            }
        }
        insert(msg.sender, shipTokenId, powerAll, workTokenIds);
    }


    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }


    function flipSaleState() public onlyOwner {
        isSaleActive = !isSaleActive;
    }


}

library shipMapping
{

    struct itmap
    {
        mapping(address => mapping(uint256 => ShipValue)) data;// address shiptokenId [baseinfo]
        mapping(address => uint256[]) ids;// address [shiptokenIds]
        mapping(uint256 => uint256[]) works; // shiptokenId  [workIds]
        mapping(uint256 => bool) worksStatus; // workId status for merge
        uint size;
    }


    struct ShipValue {uint256 shipTokenId;bool isVaild;bool isPledge;uint256 energy;uint256 overTime;uint256 power;}

    function insert(itmap storage self, address key, uint256 shipTokenId, uint256 powers, uint256[] memory work) internal returns (bool)
    {
        if (self.data[key][shipTokenId].isVaild) {
            return false;
        } else {
            self.data[key][shipTokenId].shipTokenId = shipTokenId;
            self.data[key][shipTokenId].isVaild = true;
            self.data[key][shipTokenId].isPledge = false;
            self.data[key][shipTokenId].energy = 60;
            self.data[key][shipTokenId].power = powers;
            self.ids[key].push(shipTokenId);
            self.works[shipTokenId] = work;
            for (uint i = 0; i < work.length; i++) {
                self.worksStatus[work[i]] = true;
            }
            self.size++;
            return true;
        }
    }

    // 质押
    function update(itmap storage self, address key, uint256 shipTokenId) internal returns (bool)
    {
        if (self.data[key][shipTokenId].isVaild) {
            self.data[key][shipTokenId].isPledge = true;
            //质押
            self.data[key][shipTokenId].overTime = self.data[key][shipTokenId].energy + block.timestamp;
            //质押
            return true;
        } else {
            return false;
        }
    }

    // 解除质押
    function releive(itmap storage self, address key, uint256 shipTokenId) internal returns (bool)
    {
        if (self.data[key][shipTokenId].isVaild) {
            self.data[key][shipTokenId].isPledge = false;
            //解除质押
            return true;
        } else {
            return false;
        }
    }
    // 解散
    function remove(itmap storage self, address key, uint256 shipTokenId) internal returns (bool)
    {
        if (self.data[key][shipTokenId].isVaild) {
            self.data[key][shipTokenId].isVaild = false;
            self.data[key][shipTokenId].isPledge = false;
            delete self.data[key][shipTokenId];
            for (uint i = 0; i < self.works[shipTokenId].length; i++) {
                self.worksStatus[self.works[shipTokenId][i]] = false;
            }
            delete self.works[shipTokenId];
            for (uint i = 0; i < self.ids[key].length; i++) {
                if (self.ids[key][i] == shipTokenId) {
                    delete self.ids[key][i];
                }
            }
            self.size --;
            return true;
        }
        return false;
    }


    // 充值
    function recharge(itmap storage self, address key, uint256 shipTokenId, uint256 tokenAmount) internal returns (bool)
    {
        if (self.data[key][shipTokenId].isVaild) {
            //self.data[key][shipTokenId].isPledge = true;
            //充值
            uint256 amountShip1 = 10000;
            uint256 amountShip2 = 20000;
            uint256 amountShip3 = 30000;

            if (shipTokenId > 0 && shipTokenId <= amountShip1) {
                self.data[key][shipTokenId].energy = self.data[key][shipTokenId].energy + tokenAmount * 28800;
                self.data[key][shipTokenId].overTime = self.data[key][shipTokenId].energy + block.timestamp;
            } else if (shipTokenId > amountShip1 && shipTokenId <= amountShip2) {
                self.data[key][shipTokenId].energy = self.data[key][shipTokenId].energy + tokenAmount * 8640;
                self.data[key][shipTokenId].overTime = self.data[key][shipTokenId].energy + block.timestamp;
            } else if (shipTokenId > amountShip2 && shipTokenId <= amountShip3) {
                self.data[key][shipTokenId].energy = self.data[key][shipTokenId].energy + tokenAmount * 3928;
                self.data[key][shipTokenId].overTime = self.data[key][shipTokenId].energy + block.timestamp;
            }
            //充值
            return true;
        } else {
            return false;
        }
    }

    // 查询质押开启后 剩余时间
    function balanceTime(itmap storage self, address key, uint256 shipTokenId) internal view returns (uint256)
    {
        if (self.data[key][shipTokenId].isVaild && self.data[key][shipTokenId].isPledge) {
            if (self.data[key][shipTokenId].overTime > block.timestamp) {
                return self.data[key][shipTokenId].overTime - block.timestamp;
            } else {
                return 0;
            }
        } else {
            return 0;
        }
    }


    function contains(itmap storage self, address key, uint256 shipTokenId) internal view returns (bool)
    {
        return self.data[key][shipTokenId].isVaild;
    }

    function getsize(itmap storage self) internal view returns (uint)
    {
        return self.size;
    }

    // get all not ple ships
    function getAllShipIdsNotPle(itmap storage self, address key) internal view returns (uint256[] memory){
        uint256[] memory allShips = new uint256[](uint256(self.ids[key].length));
        uint j = 0;
        for (uint i = 0; i < self.ids[key].length; i++) {
            if (self.data[key][self.ids[key][i]].isVaild && !self.data[key][self.ids[key][i]].isPledge) {
                allShips[j] = self.ids[key][i];
                j++;
            }
        }
        return allShips;
    }

    // get all  ple ships
    function getAllShipIdsPle(itmap storage self, address key) internal view returns (uint256[] memory){
        uint256[] memory allShips = new uint256[](uint256(self.ids[key].length));
        uint j = 0;
        for (uint i = 0; i < self.ids[key].length; i++) {
            if (self.data[key][self.ids[key][i]].isVaild && self.data[key][self.ids[key][i]].isPledge) {
                allShips[j] = self.ids[key][i];
                j++;
            }
        }
        return allShips;
    }

    // get all not ple shipspower
    function getAllShipIdsPowerNotPle(itmap storage self, address key) internal view returns (uint256){
        uint256 powerAll;
        for (uint i = 0; i < self.ids[key].length; i++) {
            if (self.data[key][self.ids[key][i]].isVaild && !self.data[key][self.ids[key][i]].isPledge) {
                powerAll += self.data[key][self.ids[key][i]].power;
            }
        }
        return powerAll;
    }

    // get all  ple shipspower
    function getAllShipIdsPowerPle(itmap storage self, address key) internal view returns (uint256){
        uint256 powerAll;
        for (uint i = 0; i < self.ids[key].length; i++) {
            if (self.data[key][self.ids[key][i]].isVaild && self.data[key][self.ids[key][i]].isPledge) {
                powerAll += self.data[key][self.ids[key][i]].power;
            }
        }
        return powerAll;
    }


    // 质押中的 没过期的 有效算力
    function getAllShipIdsPowerPleValid(itmap storage self, address key) internal view returns (uint256){
        uint256 powerAll;
        for (uint i = 0; i < self.ids[key].length; i++) {
            if (self.data[key][self.ids[key][i]].isVaild && self.data[key][self.ids[key][i]].isPledge &&
                self.data[key][self.ids[key][i]].overTime > block.timestamp) {
                powerAll += self.data[key][self.ids[key][i]].power;
            }
        }
        return powerAll;
    }

    // ple return
    function getShipEnergy(itmap storage self, address key, uint256 shipTokenId) internal view returns (uint256){
        if (self.data[key][shipTokenId].isVaild && self.data[key][shipTokenId].isPledge) {
            return self.data[key][shipTokenId].energy;
        } else {
            return 0;
        }
    }

    function getShipOverTime(itmap storage self, address key, uint256 shipTokenId) internal view returns (uint256){
        if (self.data[key][shipTokenId].isVaild) {
            return self.data[key][shipTokenId].overTime;
        } else {
            return 0;
        }
    }

    function getShipWorks(itmap storage self, address key, uint256 shipTokenId) internal view returns (uint256[] memory){
        uint256[] memory works;
        if (self.data[key][shipTokenId].isVaild) {
            return self.works[shipTokenId];
        } else {
            return works;
        }
    }

    // check work status
    function getShipWorksStatus(itmap storage self, uint256 workId) internal view returns (bool){
        return self.worksStatus[workId];
    }

    function getShipStatus(itmap storage self, address key, uint256 shipTokenId) internal view returns (bool){
        return self.data[key][shipTokenId].isVaild && self.data[key][shipTokenId].isPledge;
    }

}

library OwnersMapping
{

    struct itmap
    {
        mapping(address => IndexValue) data;

        uint size;
    }

    struct IndexValue {uint256 total;bool isVaild; uint256[] tokenIds;}

    function insert(itmap storage self, address key, uint256 tokenId) internal returns (bool)
    {
        self.data[key].total = 1;
        self.data[key].isVaild = true;
        self.data[key].tokenIds.push(tokenId);
        self.size++;
        return true;
    }

    function getTokenIds(itmap storage self, address key) internal returns (uint256[] memory)
    {
        return self.data[key].tokenIds;
    }

    function add(itmap storage self, address key, uint256 tokenId) internal returns (bool)
    {
        self.data[key].total + 1;
        self.data[key].tokenIds.push(tokenId);
        return true;
    }

    function del(itmap storage self, address key, uint256 tokenId) internal returns (bool)
    {
        self.data[key].total = self.data[key].total - 1;
        for (uint256 i; i < self.data[key].tokenIds.length; i++) {
            if (self.data[key].tokenIds[i] == tokenId) {
                delete self.data[key].tokenIds[i];
            }
        }
        return true;
    }

    function remove(itmap storage self, address key) internal returns (bool)
    {
        if (self.data[key].isVaild) {
            self.data[key].isVaild = false;
            self.size --;
            return true;
        }
        return false;
    }

    function isLimit(itmap storage self, address key) internal view returns (bool)
    {
        return self.data[key].total < 1;
    }

    function contains(itmap storage self, address key) internal view returns (bool)
    {
        return self.data[key].isVaild;
    }

    function getsize(itmap storage self) internal view returns (uint)
    {
        return self.size;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_reserveAddress","type":"address"}],"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":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":[],"name":"amountShipOneTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountShipThreeTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountShipTwoTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountWorkOneTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountWorkThreeTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountWorkTwoTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"}],"name":"balanceTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"}],"name":"contains","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"contains2","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"getAllShipIdsNotPle","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"getAllShipIdsPle","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"getAllShipIdsPowerNotPle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"getAllShipIdsPowerPle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"getAllShipIdsPowerPleValid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"}],"name":"getShipEnergy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"}],"name":"getShipOverTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"}],"name":"getShipStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"}],"name":"getShipWorks","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"workId","type":"uint256"}],"name":"getShipWorksStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"}],"name":"getTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getsize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"isSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shipTokenId","type":"uint256"},{"internalType":"uint256[]","name":"workTokenIds","type":"uint256[]"}],"name":"mintFlee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tpe","type":"uint256"}],"name":"mintShipWork","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tpe","type":"uint256"}],"name":"mintShipWorkFree","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"uint256","name":"shipId","type":"uint256"}],"name":"pledge","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"key","type":"address"},{"internalType":"uint256","name":"shipTokenId","type":"uint256"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recharge","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shipId","type":"uint256"}],"name":"releasePledge","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":"setBaseURI","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":"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":[],"name":"totalPower","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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"},{"inputs":[{"internalType":"uint256","name":"shipId","type":"uint256"}],"name":"unPledge","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000d5b8981d8506b086f8dcda495af44d7e28ddb1f9

-----Decoded View---------------
Arg [0] : _reserveAddress (address): 0xd5b8981d8506b086f8dcda495af44d7e28ddb1f9

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d5b8981d8506b086f8dcda495af44d7e28ddb1f9


Deployed ByteCode Sourcemap

69526:15018:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9980:150;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9980:150:0;-1:-1:-1;;;;;;9980:150:0;;:::i;:::-;;;;;;;;;;;;;;;;;;51264:100;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55648:221;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55648:221:0;;:::i;:::-;;;;-1:-1:-1;;;;;55648:221:0;;;;;;;;;;;;;;55178:404;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;55178:404:0;;;;;;;;:::i;:::-;;53851:220;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;53077:211;;;;;;;;;;;;;:::i;54116:216::-;;;;;;;;;;;;;:::i;54640:220::-;;;;;;;;;;;;;:::i;73069:168::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;73069:168:0;;;;;;;;:::i;56542:305::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56542:305:0;;;;;;;;;;;;;;;;;:::i;70486:187::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;70486:187:0;;;;;;;;;;;;;:::i;71099:109::-;;;;;;;;;;;;;:::i;52839:162::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;52839:162:0;;;;;;;;:::i;84448:89::-;;;;;;;;;;;;;:::i;71437:152::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71437:152:0;-1:-1:-1;;;;;71437:152:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72433:175;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;72433:175:0;;;;;;;;:::i;74654:34::-;;;;;;;;;;;;;:::i;72227:171::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;72227:171:0;;;;;;;;:::i;56918:151::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56918:151:0;;;;;;;;;;;;;;;;;:::i;54945:171::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54945:171:0;;:::i;84339:99::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;84339:99:0;;-1:-1:-1;84339:99:0;;-1:-1:-1;;;;;84339:99:0:i;75072:24::-;;;;;;;;;;;;;:::i;73728:124::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73728:124:0;-1:-1:-1;;;;;73728:124:0;;:::i;77249:2709::-;;;;;;;;;;;;;;;;-1:-1:-1;77249:2709:0;;:::i;51020:177::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51020:177:0;;:::i;71628:159::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71628:159:0;-1:-1:-1;;;;;71628:159:0;;:::i;52658:97::-;;;;;;;;;;;;;:::i;50737:221::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50737:221:0;-1:-1:-1;;;;;50737:221:0;;:::i;68972:148::-;;;;;;;;;;;;;:::i;75944:477::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75944:477:0;;:::i;70909:158::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;70909:158:0;;;;;;;;:::i;82617:1712::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;82617:1712:0;;-1:-1:-1;82617:1712:0;;-1:-1:-1;;;;;82617:1712:0:i;72652:178::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;72652:178:0;;;;;;;;:::i;71823:153::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71823:153:0;-1:-1:-1;;;;;71823:153:0;;:::i;68321:87::-;;;;;;;;;;;;;:::i;80008:2583::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80008:2583:0;;:::i;51433:104::-;;;;;;;;;;;;;:::i;55945:295::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;55945:295:0;;;;;;;;;;:::i;70708:167::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;70708:167:0;;;;;;;;:::i;72024:163::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72024:163:0;-1:-1:-1;;;;;72024:163:0;;:::i;76931:283::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76931:283:0;;:::i;76456:447::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76456:447:0;;:::i;57140:285::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;57140:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57140:285:0;;-1:-1:-1;57140:285:0;;-1:-1:-1;;;;;57140:285:0:i;53590:216::-;;;;;;;;;;;;;:::i;71245:158::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71245:158:0;-1:-1:-1;;;;;71245:158:0;;:::i;51608:811::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51608:811:0;;:::i;73860:427::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73860:427:0;-1:-1:-1;;;;;73860:427:0;;:::i;53331:216::-;;;;;;;;;;;;;:::i;74966:25::-;;;;;;;;;;;;;:::i;72878:150::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72878:150:0;;:::i;54377:216::-;;;;;;;;;;;;;:::i;56311:164::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56311:164:0;;;;;;;;;;:::i;69275:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69275:244:0;-1:-1:-1;;;;;69275:244:0;;:::i;74614:33::-;;;;;;;;;;;;;:::i;9980:150::-;-1:-1:-1;;;;;;10089:33:0;;10065:4;10089:33;;;;;;;;;;;;;9980:150;;;;:::o;51264:100::-;51351:5;51344:12;;;;;;;;-1:-1:-1;;51344:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51318:13;;51344:12;;51351:5;;51344:12;;51351:5;51344:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51264:100;:::o;55648:221::-;55724:7;55752:16;55760:7;55752;:16::i;:::-;55744:73;;;;-1:-1:-1;;;55744:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55837:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;55837:24:0;;55648:221::o;55178:404::-;55259:13;55275:23;55290:7;55275:14;:23::i;:::-;55259:39;;55323:5;-1:-1:-1;;;;;55317:11:0;:2;-1:-1:-1;;;;;55317:11:0;;;55309:57;;;;-1:-1:-1;;;55309:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55403:5;-1:-1:-1;;;;;55387:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;55387:21:0;;:69;;;;55412:44;55436:5;55443:12;:10;:12::i;:::-;55412:23;:44::i;:::-;55379:161;;;;-1:-1:-1;;;55379:161:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55553:21;55562:2;55566:7;55553:8;:21::i;:::-;55178:404;;;:::o;53851:220::-;53912:7;54033:30;:21;:28;:30::i;:::-;54026:37;;53851:220;:::o;53077:211::-;53138:7;53259:21;:12;:19;:21::i;54116:216::-;54175:7;54296:28;:19;:26;:28::i;54640:220::-;54701:7;54822:30;:21;:28;:30::i;73069:168::-;73147:4;73176:53;73202:8;73212:3;73217:11;73176:25;:53::i;:::-;73169:60;;73069:168;;;;;:::o;56542:305::-;56703:41;56722:12;:10;:12::i;:::-;56736:7;56703:18;:41::i;:::-;56695:103;;;;-1:-1:-1;;;56695:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56811:28;56821:4;56827:2;56831:7;56811:9;:28::i;70486:187::-;70575:4;70604:61;70625:8;70635:3;70640:11;70653;70604:20;:61::i;:::-;70597:68;;70486:187;;;;;;:::o;71099:109::-;71139:7;71171:29;71191:8;71171:19;:29::i;52839:162::-;-1:-1:-1;;;;;52963:20:0;;52936:7;52963:20;;;:13;:20;;;;;:30;;52987:5;52963:23;:30::i;84448:89::-;68552:12;:10;:12::i;:::-;-1:-1:-1;;;;;68541:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;68541:23:0;;68533:68;;;;;-1:-1:-1;;;68533:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;68533:68:0;;;;;;;;;;;;;;;84517:12:::1;::::0;;-1:-1:-1;;84501:28:0;::::1;84517:12;::::0;;::::1;84516:13;84501:28;::::0;;84448:89::o;71437:152::-;71497:16;71538:43;71567:8;71577:3;71538:28;:43::i;72433:175::-;72513:7;72545:55;72573:8;72583:3;72588:11;72545:27;:55::i;74654:34::-;;;:::o;72227:171::-;72305:7;72337:53;72363:8;72373:3;72378:11;72337:25;:53::i;56918:151::-;57022:39;57039:4;57045:2;57049:7;57022:39;;;;;;;;;;;;:16;:39::i;54945:171::-;55020:7;;55061:22;:12;55077:5;55061:15;:22::i;:::-;-1:-1:-1;55040:43:0;54945:171;-1:-1:-1;;;54945:171:0:o;84339:99::-;68552:12;:10;:12::i;:::-;-1:-1:-1;;;;;68541:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;68541:23:0;;68533:68;;;;;-1:-1:-1;;;68533:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;68533:68:0;;;;;;;;;;;;;;;84410:20:::1;84422:7;84410:11;:20::i;:::-;84339:99:::0;:::o;75072:24::-;;;;;;:::o;73728:124::-;73781:4;73810:34;73833:5;73840:3;73810:22;:34::i;77249:2709::-;77318:12;;;;77310:43;;;;;-1:-1:-1;;;77310:43:0;;;;;;;;;;;;-1:-1:-1;;;77310:43:0;;;;;;;;;;;;;;;77396:9;77372:20;77390:1;77372:13;:11;:13::i;:::-;:17;;:20::i;:::-;:33;;77364:89;;;;-1:-1:-1;;;77364:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77464:17;77492:13;77520:3;77527:1;77520:8;77516:2036;;;77610:1;77599:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;77599:13:0;;77568:27;;:20;:18;:20::i;:27::-;:44;;77560:100;;;;-1:-1:-1;;;77560:100:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77687:27;77712:1;77687:20;:18;:20::i;:27::-;77747:1;77737:12;;:9;:12;;;;77675:39;;-1:-1:-1;77737:12:0;-1:-1:-1;77764:40:0;77782:10;77675:39;77764:17;:40::i;:::-;77516:2036;;;77826:3;77833:1;77826:8;77822:1730;;;77924:10;:13;;-1:-1:-1;;;;;;;;;;;77924:13:0;77917:1;77924:13;77906;;;-1:-1:-1;;;;;;;;;;;77906:13:0;77874:46;;:27;;;:18;:20::i;:46::-;:63;;77866:119;;;;-1:-1:-1;;;77866:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78055:1;78044:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;78044:13:0;78012:46;;:27;;;:18;:20::i;:46::-;78091:1;78081:12;;:9;:12;;;;78000:58;;-1:-1:-1;78081:12:0;-1:-1:-1;78108:40:0;78126:10;78000:58;78108:17;:40::i;77822:1730::-;78170:3;78177:1;78170:8;78166:1386;;;78272:10;:13;;-1:-1:-1;;;;;;;;;;;78272:13:0;78265:1;78272:13;78254;-1:-1:-1;;;;;;;;;;;78254:13:0;78220:48;;:29;78247:1;78220:29;:20;:22::i;:48::-;:65;;78212:121;;;;-1:-1:-1;;;78212:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78405:1;78394:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;78394:13:0;78360:48;;:29;78387:1;78360:29;:20;:22::i;:48::-;78441:1;78431:12;;:9;:12;;;;78348:60;;-1:-1:-1;78431:12:0;-1:-1:-1;78458:42:0;78478:10;78348:60;78458:19;:42::i;78166:1386::-;78522:3;78529:1;78522:8;78518:1034;;;-1:-1:-1;;;;;;;;;;;78620:13:0;78613:1;78620:13;78602;78620;78602;;-1:-1:-1;;;;;;;;;;;78602:13:0;78570:46;;:27;78631:1;78570:27;:18;:20::i;:46::-;:63;;78562:119;;;;-1:-1:-1;;;78562:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78751:1;78740:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;78740:13:0;78708:46;;:27;78733:1;78708:27;:18;:20::i;:46::-;78787:1;78777:12;;:9;:12;;;;78696:58;;-1:-1:-1;78777:12:0;-1:-1:-1;78804:40:0;78822:10;78696:58;78804:17;:40::i;78518:1034::-;78866:3;78873:1;78866:8;78862:690;;;78964:10;:13;;-1:-1:-1;;;;;;;;;;;78964:13:0;78957:1;78964:13;78946;;;-1:-1:-1;;;;;;;;;;;78946:13:0;78914:46;;:27;;;:18;:20::i;:46::-;:63;;78906:119;;;;-1:-1:-1;;;78906:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79095:1;79084:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;79084:13:0;79052:46;;:27;;;:18;:20::i;:46::-;79131:1;79121:12;;:9;:12;;;;79040:58;;-1:-1:-1;79121:12:0;-1:-1:-1;79148:40:0;79166:10;79040:58;79148:17;:40::i;78862:690::-;79210:3;79217:1;79210:8;79206:346;;;79312:10;:13;;;;79305:1;79312:13;79294;-1:-1:-1;;;;;;;;;;;79294:13:0;79260:48;;:29;79287:1;79260:29;:20;:22::i;:48::-;:65;;79252:121;;;;-1:-1:-1;;;79252:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79445:1;79434:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;79434:13:0;79400:48;;:29;79427:1;79400:29;:20;:22::i;:48::-;79481:1;79471:12;;:9;:12;;;;79388:60;;-1:-1:-1;79471:12:0;-1:-1:-1;79498:42:0;79518:10;79388:60;79498:19;:42::i;:::-;79584:9;79568:13;:11;:13::i;:::-;:25;79564:265;;;79610:32;79620:10;79632:9;79610;:32::i;:::-;79662:21;79672:10;79662:9;:21::i;:::-;79657:161;;79704:30;79712:10;79724:9;79704:7;:30::i;:::-;;79657:161;;;79775:27;79780:10;79792:9;79775:4;:27::i;:::-;;79657:161;79863:9;79847:12;:5;79857:1;79847:9;:12::i;:::-;:25;;79839:64;;;;;-1:-1:-1;;;79839:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;79922:7;:5;:7::i;:::-;-1:-1:-1;;;;;79914:25:0;:36;79940:9;79914:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77249:2709;;;:::o;51020:177::-;51092:7;51119:70;51136:7;51119:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;71628:159::-;71696:7;71728:51;71765:8;71775:3;71728:36;:51::i;52658:97::-;52739:8;52732:15;;;;;;;;-1:-1:-1;;52732:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52706:13;;52732:15;;52739:8;;52732:15;;52739:8;52732:15;;;;;;;;;;;;;;;;;;;;;;;;50737:221;50809:7;-1:-1:-1;;;;;50837:19:0;;50829:74;;;;-1:-1:-1;;;50829:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50921:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;68972:148::-;68552:12;:10;:12::i;:::-;-1:-1:-1;;;;;68541:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;68541:23:0;;68533:68;;;;;-1:-1:-1;;;68533:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;68533:68:0;;;;;;;;;;;;;;;69063:6:::1;::::0;69042:40:::1;::::0;69079:1:::1;::::0;-1:-1:-1;;;;;69063:6:0::1;::::0;69042:40:::1;::::0;69079:1;;69042:40:::1;69093:6;:19:::0;;-1:-1:-1;;;;;;69093:19:0::1;::::0;;68972:148::o;75944:477::-;75994:13;76010:22;76025:6;76010:14;:22::i;:::-;75994:38;-1:-1:-1;;;;;;76051:19:0;;76060:10;76051:19;76043:41;;;;;-1:-1:-1;;;76043:41:0;;;;;;;;;;;;-1:-1:-1;;;76043:41:0;;;;;;;;;;;;;;;76104:33;76118:10;76130:6;76104:13;:33::i;:::-;76103:34;76095:80;;;;-1:-1:-1;;;76095:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76194:26;76201:10;76213:6;76194;:26::i;:::-;76186:51;;;;;-1:-1:-1;;;76186:51:0;;;;;;;;;;;;-1:-1:-1;;;76186:51:0;;;;;;;;;;;;;;;75944:477;;:::o;70909:158::-;70982:4;71011:48;71032:8;71042:3;71047:11;71011:20;:48::i;82617:1712::-;82713:12;;;;82705:43;;;;;-1:-1:-1;;;82705:43:0;;;;;;;;;;;;-1:-1:-1;;;82705:43:0;;;;;;;;;;;;;;;82798:10;82767:27;82782:11;82767:14;:27::i;:::-;-1:-1:-1;;;;;82767:41:0;;82759:107;;;;-1:-1:-1;;;82759:107:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82885:19;;82877:65;;;;;-1:-1:-1;;;82877:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;82962:33;82971:10;82983:11;82962:8;:33::i;:::-;82961:34;82953:83;;;;-1:-1:-1;;;82953:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83065:1;83051:11;:15;:47;;;;-1:-1:-1;83096:1:0;83085:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83085:13:0;83070:28;;;83051:47;83047:466;;;83155:1;83146:11;;:8;:11;;;;83123:19;;:34;83115:63;;;;;-1:-1:-1;;;83115:63:0;;;;;;;;;;;;-1:-1:-1;;;83115:63:0;;;;;;;;;;;;;;;83047:466;;;83225:1;83214:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83214:13:0;83200:27;;:59;;;;-1:-1:-1;83257:1:0;83246:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83246:13:0;83231:28;;;83200:59;83196:317;;;83316:1;83307:11;;:8;:11;;;;83284:19;;:34;83276:63;;;;;-1:-1:-1;;;83276:63:0;;;;;;;;;;;;-1:-1:-1;;;83276:63:0;;;;;;;;;;;;;;83196:317;83386:1;83375:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83375:13:0;83361:27;;:59;;;;-1:-1:-1;83418:1:0;83407:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83407:13:0;83392:28;;;83361:59;83357:156;;;83477:1;83468:11;;:8;:11;;;;83445:19;;:34;83437:64;;;;;-1:-1:-1;;;83437:64:0;;;;;;;;;;;;-1:-1:-1;;;83437:64:0;;;;;;;;;;;;;;;83528:6;83523:165;83544:12;:19;83540:1;:23;83523:165;;;83624:10;-1:-1:-1;;;;;83589:45:0;:31;83604:12;83617:1;83604:15;;;;;;;;;;;;;;83589:14;:31::i;:::-;-1:-1:-1;;;;;83589:45:0;;83585:92;;83655:7;;;83585:92;83565:3;;83523:165;;;;83698:16;83734:6;83729:527;83750:12;:19;83746:1;:23;83729:527;;;83826:1;83815:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83815:13:0;:20;;83833:1;83815:17;:20::i;:::-;83795:12;83808:1;83795:15;;;;;;;;;;;;;;:41;;:77;;;;-1:-1:-1;83870:1:0;83859:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;83859:13:0;83840:15;;:12;;83853:1;;83840:15;;;;;;;;;;;;:32;;83795:77;83791:142;;;83915:1;83905:12;;:9;:12;;;;83893:24;;;;;83791:142;83989:1;83971:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;83971:13:0;:20;;:17;:20::i;:::-;83951:12;83964:1;83951:15;;;;;;;;;;;;;;:41;;:77;;;;-1:-1:-1;84026:1:0;84015:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;84015:13:0;83996:15;;:12;;84009:1;;83996:15;;;;;;;;;;;;:32;;83951:77;83947:142;;;84071:1;84061:12;;:9;:12;;;;84049:24;;;;;83947:142;84138:1;84127:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;84127:13:0;:20;;84145:1;84127:17;:20::i;:::-;84107:12;84120:1;84107:15;;;;;;;;;;;;;;:41;;:77;;;;-1:-1:-1;84182:1:0;84171:13;;:10;:13;;;;84152:15;;:12;;84165:1;;84152:15;;;;;;;;;;;;:32;;84107:77;84103:142;;;84227:1;84217:12;;:9;:12;;;;84205:24;;;;;84103:142;83771:3;;83729:527;;;;84266:55;84273:10;84285:11;84298:8;84308:12;84266:6;:55::i;72652:178::-;72729:16;72770:52;72795:8;72805:3;72810:11;72770:24;:52::i;71823:153::-;71888:7;71920:48;71954:8;71964:3;71920:33;:48::i;68321:87::-;68394:6;;-1:-1:-1;;;;;68394:6:0;68321:87;:::o;80008:2583::-;80073:12;;;;80065:43;;;;;-1:-1:-1;;;80065:43:0;;;;;;;;;;;;-1:-1:-1;;;80065:43:0;;;;;;;;;;;;;;;80151:9;80127:20;80145:1;80127:13;:11;:13::i;:20::-;:33;;80119:89;;;;-1:-1:-1;;;80119:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80219:17;80247:13;80275:3;80282:1;80275:8;80271:2036;;;80365:1;80354:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;80354:13:0;;80323:27;;:20;:18;:20::i;:27::-;:44;;80315:100;;;;-1:-1:-1;;;80315:100:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80442:27;80467:1;80442:20;:18;:20::i;:27::-;80502:1;80492:12;;:9;:12;;;;80430:39;;-1:-1:-1;80492:12:0;-1:-1:-1;80519:40:0;80537:10;80430:39;80519:17;:40::i;:::-;80271:2036;;;80581:3;80588:1;80581:8;80577:1730;;;80679:10;:13;;-1:-1:-1;;;;;;;;;;;80679:13:0;80672:1;80679:13;80661;;;-1:-1:-1;;;;;;;;;;;80661:13:0;80629:46;;:27;;;:18;:20::i;:46::-;:63;;80621:119;;;;-1:-1:-1;;;80621:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80810:1;80799:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;80799:13:0;80767:46;;:27;;;:18;:20::i;:46::-;80846:1;80836:12;;:9;:12;;;;80755:58;;-1:-1:-1;80836:12:0;-1:-1:-1;80863:40:0;80881:10;80755:58;80863:17;:40::i;80577:1730::-;80925:3;80932:1;80925:8;80921:1386;;;81027:10;:13;;-1:-1:-1;;;;;;;;;;;81027:13:0;81020:1;81027:13;81009;-1:-1:-1;;;;;;;;;;;81009:13:0;80975:48;;:29;81002:1;80975:29;:20;:22::i;:48::-;:65;;80967:121;;;;-1:-1:-1;;;80967:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81160:1;81149:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;81149:13:0;81115:48;;:29;81142:1;81115:29;:20;:22::i;:48::-;81196:1;81186:12;;:9;:12;;;;81103:60;;-1:-1:-1;81186:12:0;-1:-1:-1;81213:42:0;81233:10;81103:60;81213:19;:42::i;80921:1386::-;81277:3;81284:1;81277:8;81273:1034;;;-1:-1:-1;;;;;;;;;;;81375:13:0;81368:1;81375:13;81357;81375;81357;;-1:-1:-1;;;;;;;;;;;81357:13:0;81325:46;;:27;81386:1;81325:27;:18;:20::i;:46::-;:63;;81317:119;;;;-1:-1:-1;;;81317:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81506:1;81495:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;81495:13:0;81463:46;;:27;81488:1;81463:27;:18;:20::i;:46::-;81542:1;81532:12;;:9;:12;;;;81451:58;;-1:-1:-1;81532:12:0;-1:-1:-1;81559:40:0;81577:10;81451:58;81559:17;:40::i;81273:1034::-;81621:3;81628:1;81621:8;81617:690;;;81719:10;:13;;-1:-1:-1;;;;;;;;;;;81719:13:0;81712:1;81719:13;81701;;;-1:-1:-1;;;;;;;;;;;81701:13:0;81669:46;;:27;;;:18;:20::i;:46::-;:63;;81661:119;;;;-1:-1:-1;;;81661:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81850:1;81839:13;;;;:10;:13;;-1:-1:-1;;;;;;;;;;;81839:13:0;81807:46;;:27;;;:18;:20::i;:46::-;81886:1;81876:12;;:9;:12;;;;81795:58;;-1:-1:-1;81876:12:0;-1:-1:-1;81903:40:0;81921:10;81795:58;81903:17;:40::i;81617:690::-;81965:3;81972:1;81965:8;81961:346;;;82067:10;:13;;;;82060:1;82067:13;82049;-1:-1:-1;;;;;;;;;;;82049:13:0;82015:48;;:29;82042:1;82015:29;:20;:22::i;:48::-;:65;;82007:121;;;;-1:-1:-1;;;82007:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82200:1;82189:13;;:10;:13;;-1:-1:-1;;;;;;;;;;;82189:13:0;82155:48;;:29;82182:1;82155:29;:20;:22::i;:48::-;82236:1;82226:12;;:9;:12;;;;82143:60;;-1:-1:-1;82226:12:0;-1:-1:-1;82253:42:0;82273:10;82143:60;82253:19;:42::i;:::-;82339:9;82323:13;:11;:13::i;:::-;:25;82319:265;;;82365:32;82375:10;82387:9;82365;:32::i;:::-;82417:21;82427:10;82417:9;:21::i;:::-;82412:161;;82459:30;82467:10;82479:9;82459:7;:30::i;:::-;;82412:161;;;82530:27;82535:10;82547:9;82530:4;:27::i;51433:104::-;51522:7;51515:14;;;;;;;;-1:-1:-1;;51515:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51489:13;;51515:14;;51522:7;;51515:14;;51522:7;51515:14;;;;;;;;;;;;;;;;;;;;;;;;55945:295;56060:12;:10;:12::i;:::-;-1:-1:-1;;;;;56048:24:0;:8;-1:-1:-1;;;;;56048:24:0;;;56040:62;;;;;-1:-1:-1;;;56040:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;56160:8;56115:18;:32;56134:12;:10;:12::i;:::-;-1:-1:-1;;;;;56115:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;56115:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;56115:53:0;;;;;;;;;;;56199:12;:10;:12::i;:::-;-1:-1:-1;;;;;56184:48:0;;56223:8;56184:48;;;;;;;;;;;;;;;;;;;;55945:295;;:::o;70708:167::-;70784:7;70816:51;70840:8;70850:3;70855:11;70816:23;:51::i;72024:163::-;72094:7;72126:53;72165:8;72175:3;72126:38;:53::i;76931:283::-;76988:13;77004:22;77019:6;77004:14;:22::i;:::-;76988:38;-1:-1:-1;;;;;;77045:19:0;;77054:10;77045:19;77037:41;;;;;-1:-1:-1;;;77037:41:0;;;;;;;;;;;;-1:-1:-1;;;77037:41:0;;;;;;;;;;;;;;;77097:33;77111:10;77123:6;77097:13;:33::i;:::-;77089:80;;;;-1:-1:-1;;;77089:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77180:26;77187:10;77199:6;77180;:26::i;76456:447::-;76508:13;76524:22;76539:6;76524:14;:22::i;:::-;76508:38;-1:-1:-1;;;;;;76565:19:0;;76574:10;76565:19;76557:41;;;;;-1:-1:-1;;;76557:41:0;;;;;;;;;;;;-1:-1:-1;;;76557:41:0;;;;;;;;;;;;;;;76617:33;76631:10;76643:6;76617:13;:33::i;:::-;76609:80;;;;-1:-1:-1;;;76609:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76700:27;76708:10;76720:6;76700:7;:27::i;57140:285::-;57272:41;57291:12;:10;:12::i;:::-;57305:7;57272:18;:41::i;:::-;57264:103;;;;-1:-1:-1;;;57264:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57378:39;57392:4;57398:2;57402:7;57411:5;57378:13;:39::i;53590:216::-;53649:7;53770:28;:19;:26;:28::i;71245:158::-;71308:16;71349:46;71381:8;71391:3;71349:31;:46::i;51608:811::-;51681:13;51715:16;51723:7;51715;:16::i;:::-;51707:76;;;;-1:-1:-1;;;51707:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51796:23;51822:19;;;:10;:19;;;;;;;;51796:45;;;;;;;;;;;-1:-1:-1;;51796:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;51822:19;;51796:45;;;51822:19;51796:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51852:18;51873:9;:7;:9::i;:::-;51852:30;;51964:4;51958:18;51980:1;51958:23;51954:72;;;-1:-1:-1;52005:9:0;-1:-1:-1;51998:16:0;;51954:72;52130:23;;:27;52126:117;;52205:4;52211:9;52188:42;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52188:42:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52188:42:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52188:42:0;;;;;;;;;;;;;-1:-1:-1;;52188:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;52188:42:0;;;;;;;;;;;;;;;;;;;;;52174:57;;;;;;52126:117;52375:4;52382:18;:7;:16;:18::i;:::-;52358:52;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52358:52:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52358:52:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52358:52:0;;;;;;;;;;;;;-1:-1:-1;;52358:52:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52358:52:0;;;;;;;;;;;;;;-1:-1:-1;;;52358:52:0;;;;;-1:-1:-1;52358:52:0;;;;;;-1:-1:-1;;52358:52:0;;;;;;;;;;;-1:-1:-1;;;;;;;51608:811:0:o;73860:427::-;73910:16;73946:26;73975:37;74001:5;74008:3;73975:25;:37::i;:::-;73946:66;;74023:23;74063:8;:15;74049:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74049:30:0;;74023:56;;74095:9;74090:166;74110:8;:15;74106:1;:19;74090:166;;;74182:3;-1:-1:-1;;;;;74151:34:0;:27;74166:8;74175:1;74166:11;;;;;;;74151:27;-1:-1:-1;;;;;74151:34:0;;74147:98;;;74218:8;74227:1;74218:11;;;;;;;;;;;;;;74206:6;74213:1;74206:9;;;;;;;;;;;;;:23;;;;;74147:98;74127:3;;74090:166;;53331:216;53390:7;53511:28;:19;:26;:28::i;74966:25::-;;;;:::o;72878:150::-;72943:4;72972:48;73003:8;73013:6;72972:30;:48::i;54377:216::-;54436:7;54557:28;:19;:26;:28::i;56311:164::-;-1:-1:-1;;;;;56432:25:0;;;56408:4;56432:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;56311:164::o;69275:244::-;68552:12;:10;:12::i;:::-;-1:-1:-1;;;;;68541:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;68541:23:0;;68533:68;;;;;-1:-1:-1;;;68533:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;68533:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;69364:22:0;::::1;69356:73;;;;-1:-1:-1::0;;;69356:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69466:6;::::0;69445:38:::1;::::0;-1:-1:-1;;;;;69445:38:0;;::::1;::::0;69466:6:::1;::::0;69445:38:::1;::::0;69466:6:::1;::::0;69445:38:::1;69494:6;:17:::0;;-1:-1:-1;;;;;;69494:17:0::1;-1:-1:-1::0;;;;;69494:17:0;;;::::1;::::0;;;::::1;::::0;;69275:244::o;74614:33::-;;;:::o;58892:127::-;58957:4;58981:30;:12;59003:7;58981:21;:30::i;720:106::-;808:10;720:106;:::o;66391:201::-;66466:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;66466:29:0;-1:-1:-1;;;;;66466:29:0;;;;;;;;:24;;66520:23;66466:24;66520:14;:23::i;:::-;-1:-1:-1;;;;;66511:46:0;;;;;;;;;;;66391:201;;:::o;43764:123::-;43833:7;43860:19;43868:3;43860:7;:19::i;93487:206::-;-1:-1:-1;;;;;93610:14:0;;93587:4;93610:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;:75;;;;-1:-1:-1;;;;;;;93649:14:0;;;;:9;:14;;;;;;;;;;;:27;;;;;;;;;:36;;;;;;;;;93487:206::o;59186:355::-;59279:4;59304:16;59312:7;59304;:16::i;:::-;59296:73;;;;-1:-1:-1;;;59296:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59380:13;59396:23;59411:7;59396:14;:23::i;:::-;59380:39;;59449:5;-1:-1:-1;;;;;59438:16:0;:7;-1:-1:-1;;;;;59438:16:0;;:51;;;;59482:7;-1:-1:-1;;;;;59458:31:0;:20;59470:7;59458:11;:20::i;:::-;-1:-1:-1;;;;;59458:31:0;;59438:51;:94;;;;59493:39;59517:5;59524:7;59493:23;:39::i;:::-;59430:103;59186:355;-1:-1:-1;;;;59186:355:0:o;63774:608::-;63899:4;-1:-1:-1;;;;;63872:31:0;:23;63887:7;63872:14;:23::i;:::-;-1:-1:-1;;;;;63872:31:0;;63864:85;;;;-1:-1:-1;;;63864:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63995:16:0;;63987:65;;;;-1:-1:-1;;;63987:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64065:39;64086:4;64092:2;64096:7;64065:20;:39::i;:::-;64169:29;64186:1;64190:7;64169:8;:29::i;:::-;-1:-1:-1;;;;;64211:19:0;;;;;;:13;:19;;;;;:35;;64238:7;64211:26;:35::i;:::-;-1:-1:-1;;;;;;64257:17:0;;;;;;:13;:17;;;;;:30;;64279:7;64257:21;:30::i;:::-;-1:-1:-1;64300:29:0;:12;64317:7;64326:2;64300:16;:29::i;:::-;;64366:7;64362:2;-1:-1:-1;;;;;64347:27:0;64356:4;-1:-1:-1;;;;;64347:27:0;;;;;;;;;;;63774:608;;;:::o;87570:1407::-;-1:-1:-1;;;;;87707:14:0;;87681:4;87707:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;87703:1267;;;87863:5;87905;87947;87973:15;;;;;:45;;;88007:11;87992;:26;;87973:45;87969:897;;;-1:-1:-1;;;;;88076:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:34;;;;;88127:5;88113:19;;88076:56;88039:93;;;;88227:15;88190:52;88151:36;;;;:91;87969:897;;;88282:11;88268;:25;:55;;;;;88312:11;88297;:26;;88268:55;88264:602;;;-1:-1:-1;;;;;88381:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:34;;;;;88432:4;88418:18;;88381:55;88344:92;;;;88531:15;88494:52;88455:36;;;;:91;88264:602;;;88586:11;88572;:25;:55;;;;;88616:11;88601;:26;;88572:55;88568:298;;;-1:-1:-1;;;;;88685:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:34;;;;;88736:4;88722:18;;88685:55;88648:92;;;;88835:15;88798:52;88759:36;;;;:91;88568:298;88909:4;88902:11;;;;;;;87703:1267;-1:-1:-1;88953:5:0;87570:1407;;;;;;:::o;89696:106::-;89785:9;;;;89696:106::o;35580:137::-;35651:7;35686:22;35690:3;35702:5;35686:3;:22::i;90378:499::-;-1:-1:-1;;;;;90538:13:0;;90488:25;90538:13;;;:8;;;:13;;;;;:20;90460:16;;90488:25;90516:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;90516:44:0;;90488:72;;90571:6;90597;90592:252;-1:-1:-1;;;;;90613:13:0;;;;;;:8;;;:13;;;;;:20;90609:24;;90592:252;;;-1:-1:-1;;;;;90659:14:0;;:9;:14;;;;;;;;;;;90674:8;;;:13;;;;;:16;;90659:14;;:9;90688:1;;90674:16;;;;;;;;;;;;;;;;;;90659:32;;;;;;;;;;;;:40;;;;;:85;;;;-1:-1:-1;;;;;;90703:14:0;;:9;:14;;;;;;;;;;;90718:8;;;:13;;;;;:16;;90703:14;;:9;90732:1;;90718:16;;;;;;;;;;;;;;90703:32;;;;;;;;;;;:41;;;;;;;;;;;;90659:85;90655:178;;;-1:-1:-1;;;;;90779:13:0;;;;;;:8;;;:13;;;;;:16;;90793:1;;90779:16;;;;;;;;;;;;;;90765:8;90774:1;90765:11;;;;;;;;;;;;;;;;;:30;90814:3;;;;;90655:178;90635:3;;90592:252;;;-1:-1:-1;90861:8:0;;90378:499;-1:-1:-1;;;;90378:499:0:o;92705:280::-;-1:-1:-1;;;;;92830:14:0;;92807:7;92830:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;92826:152;;;-1:-1:-1;;;;;;92889:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:36;;;92882:43;;92826:152;-1:-1:-1;92965:1:0;92958:8;;92381:316;-1:-1:-1;;;;;92504:14:0;;92481:7;92504:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;:75;;;;-1:-1:-1;;;;;;92543:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:36;;;;;;;;92504:75;92500:190;;;-1:-1:-1;;;;;;92603:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:34;;;92596:41;;44235:236;44315:7;;;;44375:22;44379:3;44391:5;44375:3;:22::i;:::-;44344:53;;;;-1:-1:-1;44235:236:0;-1:-1:-1;;;;;44235:236:0:o;64983:100::-;65056:19;;;;:8;;:19;;;;;:::i;95353:133::-;-1:-1:-1;;;;;95456:14:0;95427:4;95456:14;;;;;;;;;;;:22;;;;;;95353:133::o;13451:179::-;13509:7;13541:5;;;13565:6;;;;13557:46;;;;;-1:-1:-1;;;13557:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;61250:200;-1:-1:-1;;;;;61342:16:0;;61334:61;;;;;-1:-1:-1;;;61334:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;61334:61:0;;;;;;;;;;;;;;;61406:36;:19;61430:7;61439:2;61406:23;:36::i;61485:200::-;-1:-1:-1;;;;;61577:16:0;;61569:61;;;;;-1:-1:-1;;;61569:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;61569:61:0;;;;;;;;;;;;;;;61641:36;:19;61665:7;61674:2;61641:23;:36::i;61722:204::-;-1:-1:-1;;;;;61816:16:0;;61808:61;;;;;-1:-1:-1;;;61808:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;61808:61:0;;;;;;;;;;;;;;;61880:38;:21;61906:7;61915:2;61880:25;:38::i;61966:200::-;-1:-1:-1;;;;;62058:16:0;;62050:61;;;;;-1:-1:-1;;;62050:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;62050:61:0;;;;;;;;;;;;;;;62122:36;:19;62146:7;62155:2;62122:23;:36::i;62204:200::-;-1:-1:-1;;;;;62296:16:0;;62288:61;;;;;-1:-1:-1;;;62288:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;62288:61:0;;;;;;;;;;;;;;;62360:36;:19;62384:7;62393:2;62360:23;:36::i;62444:204::-;-1:-1:-1;;;;;62538:16:0;;62530:61;;;;;-1:-1:-1;;;62530:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;62530:61:0;;;;;;;;;;;;;;;62602:38;:21;62628:7;62637:2;62602:25;:38::i;59884:110::-;59960:26;59970:2;59974:7;59960:26;;;;;;;;;;;;:9;:26::i;73287:143::-;73352:4;73381:41;73402:5;73409:3;73414:7;73381:20;:41::i;73438:137::-;73500:4;73529:38;73547:5;73554:3;73559:7;73529:17;:38::i;14330:220::-;14388:7;14412:6;14408:20;;-1:-1:-1;14427:1:0;14420:8;;14408:20;14451:5;;;14455:1;14451;:5;:1;14475:5;;;;;:10;14467:56;;;;-1:-1:-1;;;14467:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45521:213;45628:7;45679:44;45684:3;45704;45710:12;45679:4;:44::i;90920:420::-;91010:7;91029:16;91061:6;91056:251;-1:-1:-1;;;;;91077:13:0;;;;;;:8;;;:13;;;;;:20;91073:24;;91056:251;;;-1:-1:-1;;;;;91123:14:0;;:9;:14;;;;;;;;;;;91138:8;;;:13;;;;;:16;;91123:14;;:9;91152:1;;91138:16;;;;;;;;;;;;;;;;;;91123:32;;;;;;;;;;;;:40;;;;;:86;;;;-1:-1:-1;;;;;;91168:14:0;;:9;:14;;;;;;;;;;;91183:8;;;:13;;;;;:16;;91168:14;;:9;91197:1;;91183:16;;;;;;;;;;;;;;91168:32;;;;;;;;;;;:41;;;;;;;;;;;;91167:42;91123:86;91119:177;;;-1:-1:-1;;;;;91242:14:0;;:9;:14;;;;;;;;;;;91257:8;;;:13;;;;;:16;;91242:14;;:9;91271:1;;91257:16;;;;;;;;;;;;;;91242:32;;;;;;;;;;;:38;;;91230:50;;;;91119:177;91099:3;;91056:251;;69959:151;70027:4;70056:46;70075:8;70085:3;70090:11;70056:18;:46::i;89521:167::-;-1:-1:-1;;;;;89645:14:0;;;;89616:4;89645:14;;;;;;;;;;;:27;;;;;;;;;:35;;;;;;89521:167::o;69732:204::-;69839:4;69868:60;69887:8;69897:3;69902:11;69915:5;69922;69868:18;:60::i;:::-;69861:67;69732:204;-1:-1:-1;;;;;69732:204:0:o;92993:310::-;-1:-1:-1;;;;;93157:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:35;;;93092:16;;;;93157:35;;93153:143;;;93216:23;;;;:10;;;:23;;;;;;;;;93209:30;;;;;;;;;;;;;;;;;93216:23;;93209:30;;93216:23;93209:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93153:143;93279:5;-1:-1:-1;93272:12:0;;91380:416;91467:7;91486:16;91518:6;91513:250;-1:-1:-1;;;;;91534:13:0;;;;;;:8;;;:13;;;;;:20;91530:24;;91513:250;;;-1:-1:-1;;;;;91580:14:0;;:9;:14;;;;;;;;;;;91595:8;;;:13;;;;;:16;;91580:14;;:9;91609:1;;91595:16;;;;;;;;;;;;;;;;;;91580:32;;;;;;;;;;;;:40;;;;;:85;;;;-1:-1:-1;;;;;;91624:14:0;;:9;:14;;;;;;;;;;;91639:8;;;:13;;;;;:16;;91624:14;;:9;91653:1;;91639:16;;;;;;;;;;;;;;91624:32;;;;;;;;;;;:41;;;;;;;;;;;;91580:85;91576:176;;;-1:-1:-1;;;;;91698:14:0;;:9;:14;;;;;;;;;;;91713:8;;;:13;;;;;:16;;91698:14;;:9;91727:1;;91713:16;;;;;;;;;;;;;;91698:32;;;;;;;;;;;:38;;;91686:50;;;;91576:176;91556:3;;91513:250;;89028:483;-1:-1:-1;;;;;89155:14:0;;89126:7;89155:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;:75;;;;-1:-1:-1;;;;;;89194:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:36;;;;;;;;89155:75;89151:353;;;-1:-1:-1;;;;;89251:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:36;;;89290:15;-1:-1:-1;89247:205:0;;;-1:-1:-1;;;;;;89333:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:36;;;89372:15;89333:54;;89326:61;;91853:501;91945:7;91964:16;91996:6;91991:330;-1:-1:-1;;;;;92012:13:0;;;;;;:8;;;:13;;;;;:20;92008:24;;91991:330;;;-1:-1:-1;;;;;92058:14:0;;:9;:14;;;;;;;;;;;92073:8;;;:13;;;;;:16;;92058:14;;:9;92087:1;;92073:16;;;;;;;;;;;;;;;;;;92058:32;;;;;;;;;;;;:40;;;;;:85;;;;-1:-1:-1;;;;;;92102:14:0;;:9;:14;;;;;;;;;;;92117:8;;;:13;;;;;:16;;92102:14;;:9;92131:1;;92117:16;;;;;;;;;;;;;;92102:32;;;;;;;;;;;:41;;;;;;;;;;;;92058:85;:165;;;;-1:-1:-1;;;;;;92164:14:0;;:9;:14;;;;;;;;;;;92179:8;;;:13;;;;;:16;;92208:15;;92164:9;92179:13;92193:1;;92179:16;;;;;;;;;;;;;;92164:32;;;;;;;;;;;:41;;;:59;92058:165;92054:256;;;-1:-1:-1;;;;;92256:14:0;;:9;:14;;;;;;;;;;;92271:8;;;:13;;;;;:16;;92256:14;;:9;92285:1;;92271:16;;;;;;;;;;;;;;92256:32;;;;;;;;;;;:38;;;92244:50;;;;92054:256;92034:3;;91991:330;;70312:151;70380:4;70409:46;70428:8;70438:3;70443:11;70409:18;:46::i;70137:153::-;70206:4;70235:47;70255:8;70265:3;70270:11;70235:19;:47::i;58307:272::-;58421:28;58431:4;58437:2;58441:7;58421:9;:28::i;:::-;58468:48;58491:4;58497:2;58501:7;58510:5;58468:22;:48::i;:::-;58460:111;;;;-1:-1:-1;;;58460:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89840:503;-1:-1:-1;;;;;90003:13:0;;89953:25;90003:13;;;:8;;;:13;;;;;:20;89925:16;;89953:25;89981:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;89981:44:0;;89953:72;;90036:6;90062;90057:253;-1:-1:-1;;;;;90078:13:0;;;;;;:8;;;:13;;;;;:20;90074:24;;90057:253;;;-1:-1:-1;;;;;90124:14:0;;:9;:14;;;;;;;;;;;90139:8;;;:13;;;;;:16;;90124:14;;:9;90153:1;;90139:16;;;;;;;;;;;;;;;;;;90124:32;;;;;;;;;;;;:40;;;;;:86;;;;-1:-1:-1;;;;;;90169:14:0;;:9;:14;;;;;;;;;;;90184:8;;;:13;;;;;:16;;90169:14;;:9;90198:1;;90184:16;;;;;;;;;;;;;;90169:32;;;;;;;;;;;:41;;;;;;;;;;;;90168:42;90124:86;90120:179;;;-1:-1:-1;;;;;90245:13:0;;;;;;:8;;;:13;;;;;:16;;90259:1;;90245:16;;;;;;;;;;;;;;90231:8;90240:1;90231:11;;;;;;;;;;;;;;;;;:30;90280:3;;;;;90120:179;90100:3;;90057:253;;45892:746;45948:13;46169:10;46165:53;;-1:-1:-1;46196:10:0;;;;;;;;;;;;-1:-1:-1;;;46196:10:0;;;;;;46165:53;46243:5;46228:12;46284:78;46291:9;;46284:78;;46317:8;;46348:2;46340:10;;;;46284:78;;;46372:19;46404:6;46394:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46394:17:0;-1:-1:-1;46466:5:0;;-1:-1:-1;46372:39:0;-1:-1:-1;;;46438:10:0;;46482:117;46489:9;;46482:117;;46558:2;46551:4;:9;46546:2;:14;46533:29;;46515:6;46522:7;;;;;;;46515:15;;;;;;;;;;;:47;-1:-1:-1;;;;;46515:47:0;;;;;;;;-1:-1:-1;46585:2:0;46577:10;;;;46482:117;;;-1:-1:-1;46623:6:0;45892:746;-1:-1:-1;;;;45892:746:0:o;94189:144::-;-1:-1:-1;;;;;94302:14:0;;:9;:14;;;;;;;;;;;;:23;;94295:30;;;;;;;;;;;;;;;;;94261:16;;94295:30;;;94302:23;94295:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94189:144;;;;:::o;93337:142::-;93424:4;93447:24;;;:16;;;;;:24;;;;;;;;;93337:142::o;43525:151::-;43609:4;43633:35;43643:3;43663;43633:9;:35::i;40279:110::-;40362:19;;40279:110::o;34657:137::-;34727:4;34751:35;34759:3;34779:5;34751:7;:35::i;34350:131::-;34417:4;34441:32;34446:3;34466:5;34441:4;:32::i;42948:185::-;43037:4;43061:64;43066:3;43086;-1:-1:-1;;;;;43100:23:0;;43061:4;:64::i;30588:204::-;30683:18;;30655:7;;30683:26;-1:-1:-1;30675:73:0;;;;-1:-1:-1;;;30675:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30766:3;:11;;30778:5;30766:18;;;;;;;;;;;;;;;;30759:25;;30588:204;;;;:::o;40754:279::-;40858:19;;40821:7;;;;40858:27;-1:-1:-1;40850:74:0;;;;-1:-1:-1;;;40850:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40937:22;40962:3;:12;;40975:5;40962:19;;;;;;;;;;;;;;;;;;40937:44;;41000:5;:10;;;41012:5;:12;;;40992:33;;;;;40754:279;;;;;:::o;60221:250::-;60317:18;60323:2;60327:7;60317:5;:18::i;:::-;60354:54;60385:1;60389:2;60393:7;60402:5;60354:22;:54::i;:::-;60346:117;;;;-1:-1:-1;;;60346:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93911:270;-1:-1:-1;;;;;94017:14:0;;;;93995:4;94017:14;;;;;;;;;;94040:1;94017:24;;;94052:22;;;:29;;-1:-1:-1;;94052:29:0;;;;;94092:23;;;;:37;;;;;;;;;;;;;;;;;;;94140:9;;;:11;;;;;;94040:1;93911:270::o;94341:205::-;-1:-1:-1;;;;;94444:14:0;;;;94422:4;94444:14;;;;;;;;;;94479:23;;:37;;;;;;;;;;;;;;;;;;;;94341:205::o;42287:337::-;42381:7;42420:17;;;:12;;;:17;;;;;;42471:12;42456:13;42448:36;;;;-1:-1:-1;;;42448:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42547:3;:12;;42571:1;42560:8;:12;42547:26;;;;;;;;;;;;;;;;;;:33;;;42540:40;;;42287:337;;;;;:::o;85902:449::-;-1:-1:-1;;;;;86016:14:0;;85990:4;86016:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;86012:332;;;-1:-1:-1;;;;;;86068:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;86107:4;86068:36;;;:43;;-1:-1:-1;;86068:43:0;;;;;86187:34;;;;86224:15;86187:52;86148:36;;;;:91;;;;86276:11;;85067:812;-1:-1:-1;;;;;85220:14:0;;85194:4;85220:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;85216:656;;;-1:-1:-1;85279:5:0;85272:12;;85216:656;-1:-1:-1;;;;;85317:14:0;;:9;:14;;;;;;;;;;;:27;;;;;;;;:53;;;85423:4;85385:35;;;:42;;-1:-1:-1;;85385:42:0;;;-1:-1:-1;;85442:44:0;;;85538:2;85501:34;;;;:39;;;;85555:33;;;;:42;;;85612:13;;;:8;;;:13;;;;;:31;;;;;;;;;;;;;;;;;;85658:23;;;:10;;;:23;;;;;:30;;;;;;;;:::i;:::-;;85708:6;85703:106;85724:4;:11;85720:1;:15;85703:106;;;85789:4;85761;:16;;:25;85778:4;85783:1;85778:7;;;;;;;;;;;;;;;;;;;85761:25;;;;;;;;;;-1:-1:-1;85761:25:0;:32;;-1:-1:-1;;85761:32:0;;;;;;;;;;-1:-1:-1;85737:3:0;85703:106;;;-1:-1:-1;;85823:9:0;;;:11;;;;;;;;;85067:812;;;;;;;:::o;86730:815::-;-1:-1:-1;;;;;86844:14:0;;86818:4;86844:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;86840:675;;;-1:-1:-1;;;;;86896:14:0;;86934:5;86896:14;;;;;;;;;;;:27;;;;;;;;:35;;;:43;;-1:-1:-1;;86954:44:0;;;87013:34;;;;;;;;;;;;;;;;;;;;87062:145;87083:23;;;;:10;;;:23;;;;;:30;87079:34;;87062:145;;;87186:5;87156:23;;;:10;;;:23;;;;;:26;;87139:16;;;;87186:5;;87180:1;;87156:26;;;;;;;;;;;;;;;;;;;87139:44;;;;;;;;;;;;:52;;-1:-1:-1;;87139:52:0;;;;;;;;;;-1:-1:-1;87115:3:0;87062:145;;;-1:-1:-1;87228:23:0;;;;:10;;;:23;;;;;87221:30;;;:::i;:::-;87271:6;87266:185;-1:-1:-1;;;;;87287:13:0;;;;;;:8;;;:13;;;;;:20;87283:24;;87266:185;;;-1:-1:-1;;;;;87337:13:0;;;;;;:8;;;:13;;;;;:16;;87357:11;;87337:13;87351:1;;87337:16;;;;;;;;;;;;;;:31;87333:103;;;-1:-1:-1;;;;;87400:13:0;;;;;;:8;;;:13;;;;;:16;;87414:1;;87400:16;;;;;;;;;;;;;;87393:23;87333:103;87309:3;;87266:185;;;-1:-1:-1;;87465:9:0;;;:12;;-1:-1:-1;;87465:12:0;;;;87492:11;;86840:675;-1:-1:-1;87532:5:0;86730:815;;;;;:::o;86380:329::-;-1:-1:-1;;;;;86495:14:0;;86469:4;86495:14;;;;;;;;;;;:27;;;;;;;;:35;;;;;86491:211;;;-1:-1:-1;;;;;;86547:14:0;;86586:5;86547:14;;;;;;;;;;;:27;;;;;;;;:36;;;;:44;;-1:-1:-1;;86547:44:0;;;86634:11;;65648:624;65765:4;65792:15;:2;-1:-1:-1;;;;;65792:13:0;;:15::i;:::-;65787:60;;-1:-1:-1;65831:4:0;65824:11;;65787:60;65857:23;65883:276;-1:-1:-1;;;66004:12:0;:10;:12::i;:::-;66035:4;66058:7;66084:5;65899:205;;;;;;-1:-1:-1;;;;;65899:205:0;;;;;;-1:-1:-1;;;;;65899:205:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65899:205:0;;;;;;;-1:-1:-1;;;;;65899:205:0;;;;;;;;;;;65883:276;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;65883:15:0;;;:276;:15;:276::i;:::-;65857:302;;66170:13;66197:10;66186:32;;;;;;;;;;;;;;;-1:-1:-1;66186:32:0;-1:-1:-1;;;;;;66237:26:0;-1:-1:-1;;;66237:26:0;;-1:-1:-1;;;65648:624:0;;;;;;:::o;40059:125::-;40130:4;40154:17;;;:12;;;;;:17;;;;;;:22;;;40059:125::o;28268:1556::-;28334:4;28473:19;;;:12;;;:19;;;;;;28509:15;;28505:1312;;28943:18;;-1:-1:-1;;28894:14:0;;;;28943:22;;;;28870:21;;28943:3;;:22;;29230;;;;;;;;;;;;;;29210:42;;29376:9;29347:3;:11;;29359:13;29347:26;;;;;;;;;;;;;;;;;;;:38;;;;29453:23;;;29495:1;29453:12;;;:23;;;;;;29479:17;;;29453:43;;29618:17;;29453:3;;29618:17;;;;;;;;;;;;;;;;;;;;;;29713:3;:12;;:19;29726:5;29713:19;;;;;;;;;;;29706:26;;;29756:4;29749:11;;;;;;;;28505:1312;29800:5;29793:12;;;;;27678:414;27741:4;27763:21;27773:3;27778:5;27763:9;:21::i;:::-;27758:327;;-1:-1:-1;27801:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;27984:18;;27962:19;;;:12;;;:19;;;;;;:40;;;;28017:11;;27758:327;-1:-1:-1;28068:5:0;28061:12;;37548:691;37624:4;37759:17;;;:12;;;:17;;;;;;37793:13;37789:443;;-1:-1:-1;;37877:38:0;;;;;;;;;;;;;;;;;;37859:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;38074:19;;38054:17;;;:12;;;:17;;;;;;;:39;38108:11;;37789:443;38188:5;38152:3;:12;;38176:1;38165:8;:12;38152:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;38215:5;38208:12;;;;;60807:406;-1:-1:-1;;;;;60887:16:0;;60879:61;;;;;-1:-1:-1;;;60879:61:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;60879:61:0;;;;;;;;;;;;;;;60962:16;60970:7;60962;:16::i;:::-;60961:17;60953:58;;;;;-1:-1:-1;;;60953:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;61024:45;61053:1;61057:2;61061:7;61024:20;:45::i;:::-;-1:-1:-1;;;;;61082:17:0;;;;;;:13;:17;;;;;:30;;61104:7;61082:21;:30::i;:::-;-1:-1:-1;61125:29:0;:12;61142:7;61151:2;61125:16;:29::i;:::-;-1:-1:-1;61172:33:0;;61197:7;;-1:-1:-1;;;;;61172:33:0;;;61189:1;;61172:33;;61189:1;;61172:33;60807:406;;:::o;18799:420::-;19165:20;19203:8;;;18799:420::o;21715:195::-;21818:12;21850:52;21872:6;21880:4;21886:1;21889:12;21818;23019:18;23030:6;23019:10;:18::i;:::-;23011:60;;;;;-1:-1:-1;;;23011:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;23145:12;23159:23;23186:6;-1:-1:-1;;;;;23186:11:0;23206:5;23213:4;23186:32;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23186:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23144:74;;;;23236:52;23254:7;23263:10;23275:12;23236:17;:52::i;:::-;23229:59;22767:529;-1:-1:-1;;;;;;;22767:529:0:o;25306:743::-;25422:12;25451:7;25447:595;;;-1:-1:-1;25482:10:0;25475:17;;25447:595;25596:17;;:21;25592:439;;25859:10;25853:17;25920:15;25907:10;25903:2;25899:19;25892:44;25807:148;25995:20;;-1:-1:-1;;;25995:20:0;;;;;;;;;;;;;;;;;26002:12;;25995:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://8995bd14f2b034c40afea9615b29dfb9283e37717fbbde643a0a974a552c6707
Block Transaction Gas Used Reward
Age Block Fee Address Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading