Token TripsNFT

Overview ERC721

Total Supply:
3,333 TRIP

Holders:
902 addresses

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
TripsNFT

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-01-06
*/

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

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

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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


// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721URIStorage: 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));
        }

        return super.tokenURI(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), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @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 override {
        super._burn(tokenId);

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

// File: TripsNFT.sol

pragma solidity >=0.8.0 <0.9.0;
//SPDX-License-Identifier: MIT








contract TripsNFT is ERC721, ERC721URIStorage, ERC721Enumerable, Ownable {
  using SafeMath for uint256;
  using Counters for Counters.Counter;

  Counters.Counter private _tokenIds;
  string private baseURI = "";
  uint256 private constant limit = 3333;
  uint256 private startPrice = 30000000;
  address private timeERC20Contract = 0x0000000000000000000000000000000000000000;
  address private daoWallet = 0x0000000000000000000000000000000000000000;
  address private devWallet = 0x0000000000000000000000000000000000000000;
  bool private publicCanMintNFT = false;

  event Mint(
      address indexed to,
      uint256 indexed tokenId
  );

  constructor() ERC721("TripsNFT", "TRIP") {}

  /// @notice Internal Mint an item for a given address
  /// @param to recipient address
  function _mintItem(address to)
      private
      returns (uint256)
  {
    _tokenIds.increment();
    uint256 id = _tokenIds.current();
    _mint(to, id);
    _setTokenURI(id, string(abi.encodePacked(uint2str(id), ".json")));

    emit Mint(to, id);
    return id;
  }

  modifier zeroAddressGuard(address addy) {
    /// @dev guard against zero address
    require(addy != address(0), "Address cannot be the zero address");
    _;
  }

  modifier allAdressesGuard() {
    /// @dev guard against timecontract, price contract, daowallet, and devwallet not being set.
    require(timeERC20Contract != address(0), "TimeERC20Contract is still zero address");
    require(daoWallet != address(0), "DAO Wallet is still zero address");
    require(devWallet != address(0), "DEV Wallet is still zero address");
    require(keccak256(abi.encodePacked(baseURI)) != keccak256(abi.encodePacked("")), "Base URI is not set");
    _;
  }

  /// @notice Check if this contract has been approved by the buyer to spend the required amount of TIME
  /// @param buyer address
  function approvedForTime(address buyer, uint256 amount)
  public
  view
  zeroAddressGuard(buyer)
  returns (bool) {
      IERC20 token = IERC20(timeERC20Contract);
      uint256 allowance = token.allowance(buyer, address(this));
      return allowance >= amount;
  }

  /// @notice The total number of NFTs the address has
  function totalNumberOfTokens(address tokenOwner)
  public
  view
  zeroAddressGuard(tokenOwner)
  returns (uint256) {
      return this.balanceOf(tokenOwner);
  }

  /// @notice The price for an nft
  /// @param id The ID of the nft
  function getNFTPrice(uint256 id)
  public
  view
  returns (uint256) {
    uint price = 0;
    uint priceIncrementer = 10000000; // 0.01 $TIME
    uint outerEpoch = limit / 3;
    if ((id >= 1) && (id <= outerEpoch)) {
        price = startPrice;
    } else if ((id >= outerEpoch + 1) && (id <= outerEpoch * 2)) {
        price = startPrice + priceIncrementer;
    } else {
        uint innerEpoch = ((outerEpoch * 2) + 1);
        uint epochIncrementer = outerEpoch / 3;
        uint firstEpochMin = innerEpoch;
        uint firstEpochMax = firstEpochMin + epochIncrementer - 1;
        uint secondEpochMin = firstEpochMax + 1;
        uint secondEpochMax = secondEpochMin + epochIncrementer - 1;
        uint thirdEpochMin = secondEpochMax + 1;
        uint thirdEpochMax = thirdEpochMin + epochIncrementer;
        uint remainder = limit - thirdEpochMax;
        thirdEpochMax += remainder;
        if ((id >= firstEpochMin) && (id <= firstEpochMax)) {
            price = startPrice + (priceIncrementer * 2);
        } else if ((id >= secondEpochMin) && (id <= secondEpochMax)) {
            price = startPrice + (priceIncrementer * 3);
        } else if ((id >= thirdEpochMin) && (id <= thirdEpochMax)) {
            price = startPrice + (priceIncrementer * 4);
        } else {
            price = 0;
        }
    }
    return price;
  }

  /// @notice Mint an item for a given address  
  /// @param to recipient address
  function requestMint(address to)
      public
      zeroAddressGuard(to)
      allAdressesGuard()
      returns (uint256)
  {
    // make sure trips are available to public for minting
    require(publicCanMintNFT, "TRIPS are not able to be minted at this time.");

    // make sure we have more left to mint
    require(_tokenIds.current() < limit , "None left to mint!");

    // increment the token - need to do this to get the price for the token they will get
    // the actual increment will happen in the _mint function
    uint256 tokenId = _tokenIds.current() + 1;

    // get the nft price in TIME
    uint256 epochNFTPrice = getNFTPrice(tokenId);

    // make sure this contract is approved for transfer TIME
    require(approvedForTime(to, epochNFTPrice), "Time hasn't been approved for transfer");

    // transfer the TIME tokens
    _transferTimeTokens(to, epochNFTPrice, timeERC20Contract);

    // do the mint
    return _mintItem(to);
  }

  /**
  * @dev Given an amount and a currency, transfer the currency to this contract.
  */
  function _transferTimeTokens(address from, uint256 amount, address currency) internal {
    uint256 daoAmount = amount * 80 / 100;
    uint256 devAmount = amount * 20 / 100;
    IERC20 token = IERC20(currency);
    token.transferFrom(from, daoWallet, daoAmount);
    token.transferFrom(from, devWallet, devAmount);
  }

  /// @notice Mint an item for a given address as the DAO 
  /// @param to recipient address
  function mintAsDAO(address to)
      public
      onlyOwner
      returns (uint256)
  {
    return _mintItem(to);
  }

  /// @notice Change the BaseURI 
  /// @param newBaseURI string of the new base URI
  function setBaseURI(string memory newBaseURI)
      public
      onlyOwner
  {
    baseURI = newBaseURI;
  }

  /// @notice Change the Current Price 
  /// @param newStartPrice value of the new current price
  function setStartPrice(uint256 newStartPrice)
      onlyOwner
      public
  {
    startPrice = newStartPrice;
  }

  /// @notice Set if the public can mint an NFT or not
  /// @param canMintNFT can the public mint an NFT
  function setPublicCanMintNFT(bool canMintNFT)
      onlyOwner
      public
  {
    publicCanMintNFT = canMintNFT;
  }

  /// @notice Set the TIME ERC20 contract address
  /// @param timeContract the time erc20 contract
  function setTimeContract(address timeContract)
      onlyOwner
      public
  {
    timeERC20Contract = timeContract;
  }

  /// @notice Set the DAO Wallet Address
  /// @param daoWalletAddress the DAO Wallet Address
  function setDAOWallet(address daoWalletAddress)
      onlyOwner
      public
  {
    daoWallet = daoWalletAddress;
  }

  /// @notice Set the Dev Wallet Address
  /// @param devWalletAddress the Dev Wallet Address
  function setDevWallet(address devWalletAddress)
      onlyOwner
      public
  {
    devWallet = devWalletAddress;
  }

  /// @notice Override of the burn function
  /// @param tokenId value of the token id to be burned
  function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
    super._burn(tokenId);
  }

  /// @notice Get the token URI for a given token Id
  /// @param tokenId value of the token id
  function tokenURI(uint256 tokenId)
    public
    view
    override(ERC721, ERC721URIStorage)
    returns (string memory)
  {
    return super.tokenURI(tokenId);
  }

  /// @notice Get the current base URI
  function _baseURI() internal override view virtual returns (string memory) {
    return baseURI;
  }
  
  /// @notice Override of the beforeTokenTransfer function
  /// @param from the from address
  /// @param to the to address
  /// @param tokenId value of the token id to be burned
  function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override(ERC721, ERC721Enumerable) {
    super._beforeTokenTransfer(from, to, tokenId);
  }

  /// @notice Override of the supportsInterface function
  /// @param interfaceId the id of the interface
  function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) {
    return super.supportsInterface(interfaceId);
  }

  function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
    if (_i == 0) {
        return "0";
    }
    uint j = _i;
    uint len;
    while (j != 0) {
        len++;
        j /= 10;
    }
    bytes memory bstr = new bytes(len);
    uint k = len;
    while (_i != 0) {
        k = k-1;
        uint8 temp = (48 + uint8(_i - _i / 10 * 10));
        bytes1 b1 = bytes1(temp);
        bstr[k] = b1;
        _i /= 10;
    }
    return string(bstr);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"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":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"buyer","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approvedForTime","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","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":"uint256","name":"id","type":"uint256"}],"name":"getNFTPrice","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":[{"internalType":"address","name":"to","type":"address"}],"name":"mintAsDAO","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"requestMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"daoWalletAddress","type":"address"}],"name":"setDAOWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"devWalletAddress","type":"address"}],"name":"setDevWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"canMintNFT","type":"bool"}],"name":"setPublicCanMintNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newStartPrice","type":"uint256"}],"name":"setStartPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"timeContract","type":"address"}],"name":"setTimeContract","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":[{"internalType":"address","name":"tokenOwner","type":"address"}],"name":"totalNumberOfTokens","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"}]

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

Deployed ByteCode Sourcemap

61906:8722:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69957:165;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41141:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42700:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42223:411;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67795:119;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54287:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63801:275;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68711:123;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43450:339;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53955:256;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68258:126;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43860:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54477:233;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67360:123;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67576:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40835:239;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40565:208;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16118:103;;;:::i;:::-;;15467:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64383:1377;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65851:983;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41310:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42993:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44116:328;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68028:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69155:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68486:123;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64138:168;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43219:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16376:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69957:165;70060:4;70080:36;70104:11;70080:23;:36::i;:::-;70073:43;;69957:165;;;:::o;41141:100::-;41195:13;41228:5;41221:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41141:100;:::o;42700:221::-;42776:7;42804:16;42812:7;42804;:16::i;:::-;42796:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;42889:15;:24;42905:7;42889:24;;;;;;;;;;;;;;;;;;;;;42882:31;;42700:221;;;:::o;42223:411::-;42304:13;42320:23;42335:7;42320:14;:23::i;:::-;42304:39;;42368:5;42362:11;;:2;:11;;;;42354:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;42462:5;42446:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;42471:37;42488:5;42495:12;:10;:12::i;:::-;42471:16;:37::i;:::-;42446:62;42424:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;42605:21;42614:2;42618:7;42605:8;:21::i;:::-;42223:411;;;:::o;67795:119::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67895:13:::1;67882:10;:26;;;;67795:119:::0;:::o;54287:113::-;54348:7;54375:10;:17;;;;54368:24;;54287:113;:::o;63801:275::-;63914:4;63895:5;63110:1;63094:18;;:4;:18;;;;63086:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;63929:12:::1;63951:17;;;;;;;;;;;63929:40;;63978:17;63998:5;:15;;;64014:5;64029:4;63998:37;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63978:57;;64064:6;64051:9;:19;;64044:26;;;;63801:275:::0;;;;;:::o;68711:123::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68812:16:::1;68800:9;;:28;;;;;;;;;;;;;;;;;;68711:123:::0;:::o;43450:339::-;43645:41;43664:12;:10;:12::i;:::-;43678:7;43645:18;:41::i;:::-;43637:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;43753:28;43763:4;43769:2;43773:7;43753:9;:28::i;:::-;43450:339;;;:::o;53955:256::-;54052:7;54088:23;54105:5;54088:16;:23::i;:::-;54080:5;:31;54072:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;54177:12;:19;54190:5;54177:19;;;;;;;;;;;;;;;:26;54197:5;54177:26;;;;;;;;;;;;54170:33;;53955:256;;;;:::o;68258:126::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68366:12:::1;68346:17;;:32;;;;;;;;;;;;;;;;;;68258:126:::0;:::o;43860:185::-;43998:39;44015:4;44021:2;44025:7;43998:39;;;;;;;;;;;;:16;:39::i;:::-;43860:185;;;:::o;54477:233::-;54552:7;54588:30;:28;:30::i;:::-;54580:5;:38;54572:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;54685:10;54696:5;54685:17;;;;;;;;;;;;;;;;;;;;;;;;54678:24;;54477:233;;;:::o;67360:123::-;67438:7;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67464:13:::1;67474:2;67464:9;:13::i;:::-;67457:20;;67360:123:::0;;;:::o;67576:113::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67673:10:::1;67663:7;:20;;;;;;;;;;;;:::i;:::-;;67576:113:::0;:::o;40835:239::-;40907:7;40927:13;40943:7;:16;40951:7;40943:16;;;;;;;;;;;;;;;;;;;;;40927:32;;40995:1;40978:19;;:5;:19;;;;40970:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;41061:5;41054:12;;;40835:239;;;:::o;40565:208::-;40637:7;40682:1;40665:19;;:5;:19;;;;40657:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;40749:9;:16;40759:5;40749:16;;;;;;;;;;;;;;;;40742:23;;40565:208;;;:::o;16118:103::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;16183:30:::1;16210:1;16183:18;:30::i;:::-;16118:103::o:0;15467:87::-;15513:7;15540:6;;;;;;;;;;;15533:13;;15467:87;:::o;64383:1377::-;64446:7;64462:10;64475:1;64462:14;;64483:21;64507:8;64483:32;;64536:15;64562:1;62161:4;64554:9;;;;:::i;:::-;64536:27;;64581:1;64575:2;:7;;64574:31;;;;;64594:10;64588:2;:16;;64574:31;64570:1166;;;64626:10;;64618:18;;64570:1166;;;64674:1;64661:10;:14;;;;:::i;:::-;64655:2;:20;;64654:48;;;;;64700:1;64687:10;:14;;;;:::i;:::-;64681:2;:20;;64654:48;64650:1086;;;64736:16;64723:10;;:29;;;;:::i;:::-;64715:37;;64650:1086;;;64777:15;64815:1;64810;64797:10;:14;;;;:::i;:::-;64796:20;;;;:::i;:::-;64777:40;;64828:21;64865:1;64852:10;:14;;;;:::i;:::-;64828:38;;64877:18;64898:10;64877:31;;64919:18;64975:1;64956:16;64940:13;:32;;;;:::i;:::-;:36;;;;:::i;:::-;64919:57;;64987:19;65025:1;65009:13;:17;;;;:::i;:::-;64987:39;;65037:19;65095:1;65076:16;65059:14;:33;;;;:::i;:::-;:37;;;;:::i;:::-;65037:59;;65107:18;65145:1;65128:14;:18;;;;:::i;:::-;65107:39;;65157:18;65194:16;65178:13;:32;;;;:::i;:::-;65157:53;;65221:14;65246:13;62161:4;65238:21;;;;:::i;:::-;65221:38;;65287:9;65270:26;;;;;:::i;:::-;;;65318:13;65312:2;:19;;65311:46;;;;;65343:13;65337:2;:19;;65311:46;65307:422;;;65415:1;65396:16;:20;;;;:::i;:::-;65382:10;;:35;;;;:::i;:::-;65374:43;;65307:422;;;65446:14;65440:2;:20;;65439:48;;;;;65472:14;65466:2;:20;;65439:48;65435:294;;;65545:1;65526:16;:20;;;;:::i;:::-;65512:10;;:35;;;;:::i;:::-;65504:43;;65435:294;;;65576:13;65570:2;:19;;65569:46;;;;;65601:13;65595:2;:19;;65569:46;65565:164;;;65673:1;65654:16;:20;;;;:::i;:::-;65640:10;;:35;;;;:::i;:::-;65632:43;;65565:164;;;65716:1;65708:9;;65565:164;65435:294;65307:422;64650:1086;;;;;;;;;;64570:1166;65749:5;65742:12;;;;;64383:1377;;;:::o;65851:983::-;65968:7;65922:2;63110:1;63094:18;;:4;:18;;;;63086:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;63341:1:::1;63312:31;;:17;;;;;;;;;;;:31;;;;63304:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;63423:1;63402:23;;:9;;;;;;;;;;;:23;;;;63394:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63498:1;63477:23;;:9;;;;;;;;;;;:23;;;;63469:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63602:20;;;;;;;:::i;:::-;;;;;;;;;;;;;63592:31;;;;;;63579:7;63562:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;63552:36;;;;;;:71;;63544:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;66055:16:::2;;;;;;;;;;;66047:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;62161:4;66182:19;:9;:17;:19::i;:::-;:27;66174:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;66396:15;66436:1;66414:19;:9;:17;:19::i;:::-;:23;;;;:::i;:::-;66396:41;;66480:21;66504:20;66516:7;66504:11;:20::i;:::-;66480:44;;66603:34;66619:2;66623:13;66603:15;:34::i;:::-;66595:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;66722:57;66742:2;66746:13;66761:17;;;;;;;;;;;66722:19;:57::i;:::-;66815:13;66825:2;66815:9;:13::i;:::-;66808:20;;;;65851:983:::0;;;;:::o;41310:104::-;41366:13;41399:7;41392:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41310:104;:::o;42993:155::-;43088:52;43107:12;:10;:12::i;:::-;43121:8;43131;43088:18;:52::i;:::-;42993:155;;:::o;44116:328::-;44291:41;44310:12;:10;:12::i;:::-;44324:7;44291:18;:41::i;:::-;44283:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;44397:39;44411:4;44417:2;44421:7;44430:5;44397:13;:39::i;:::-;44116:328;;;;:::o;68028:122::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68134:10:::1;68115:16;;:29;;;;;;;;;;;;;;;;;;68028:122:::0;:::o;69155:172::-;69266:13;69298:23;69313:7;69298:14;:23::i;:::-;69291:30;;69155:172;;;:::o;68486:123::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68587:16:::1;68575:9;;:28;;;;;;;;;;;;;;;;;;68486:123:::0;:::o;64138:168::-;64249:7;64225:10;63110:1;63094:18;;:4;:18;;;;63086:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;64274:4:::1;:14;;;64289:10;64274:26;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64267:33;;64138:168:::0;;;;:::o;43219:164::-;43316:4;43340:18;:25;43359:5;43340:25;;;;;;;;;;;;;;;:35;43366:8;43340:35;;;;;;;;;;;;;;;;;;;;;;;;;43333:42;;43219:164;;;;:::o;16376:201::-;15698:12;:10;:12::i;:::-;15687:23;;:7;:5;:7::i;:::-;:23;;;15679:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;16485:1:::1;16465:22;;:8;:22;;;;16457:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;16541:28;16560:8;16541:18;:28::i;:::-;16376:201:::0;:::o;53647:224::-;53749:4;53788:35;53773:50;;;:11;:50;;;;:90;;;;53827:36;53851:11;53827:23;:36::i;:::-;53773:90;53766:97;;53647:224;;;:::o;45954:127::-;46019:4;46071:1;46043:30;;:7;:16;46051:7;46043:16;;;;;;;;;;;;;;;;;;;;;:30;;;;46036:37;;45954:127;;;:::o;14191:98::-;14244:7;14271:10;14264:17;;14191:98;:::o;49936:174::-;50038:2;50011:15;:24;50027:7;50011:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;50094:7;50090:2;50056:46;;50065:23;50080:7;50065:14;:23::i;:::-;50056:46;;;;;;;;;;;;49936:174;;:::o;46248:348::-;46341:4;46366:16;46374:7;46366;:16::i;:::-;46358:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;46442:13;46458:23;46473:7;46458:14;:23::i;:::-;46442:39;;46511:5;46500:16;;:7;:16;;;:51;;;;46544:7;46520:31;;:20;46532:7;46520:11;:20::i;:::-;:31;;;46500:51;:87;;;;46555:32;46572:5;46579:7;46555:16;:32::i;:::-;46500:87;46492:96;;;46248:348;;;;:::o;49240:578::-;49399:4;49372:31;;:23;49387:7;49372:14;:23::i;:::-;:31;;;49364:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;49482:1;49468:16;;:2;:16;;;;49460:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;49538:39;49559:4;49565:2;49569:7;49538:20;:39::i;:::-;49642:29;49659:1;49663:7;49642:8;:29::i;:::-;49703:1;49684:9;:15;49694:4;49684:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;49732:1;49715:9;:13;49725:2;49715:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;49763:2;49744:7;:16;49752:7;49744:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;49802:7;49798:2;49783:27;;49792:4;49783:27;;;;;;;;;;;;49240:578;;;:::o;62711:281::-;62773:7;62792:21;:9;:19;:21::i;:::-;62820:10;62833:19;:9;:17;:19::i;:::-;62820:32;;62859:13;62865:2;62869;62859:5;:13::i;:::-;62879:65;62892:2;62920:12;62929:2;62920:8;:12::i;:::-;62903:39;;;;;;;;:::i;:::-;;;;;;;;;;;;;62879:12;:65::i;:::-;62967:2;62963;62958:12;;;;;;;;;;;;62984:2;62977:9;;;62711:281;;;:::o;16737:191::-;16811:16;16830:6;;;;;;;;;;;16811:25;;16856:8;16847:6;;:17;;;;;;;;;;;;;;;;;;16911:8;16880:40;;16901:8;16880:40;;;;;;;;;;;;16737:191;;:::o;7899:114::-;7964:7;7991;:14;;;7984:21;;7899:114;;;:::o;66935:324::-;67028:17;67062:3;67057:2;67048:6;:11;;;;:::i;:::-;:17;;;;:::i;:::-;67028:37;;67072:17;67106:3;67101:2;67092:6;:11;;;;:::i;:::-;:17;;;;:::i;:::-;67072:37;;67116:12;67138:8;67116:31;;67154:5;:18;;;67173:4;67179:9;;;;;;;;;;;67190;67154:46;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;67207:5;:18;;;67226:4;67232:9;;;;;;;;;;;67243;67207:46;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;66935:324;;;;;;:::o;50252:315::-;50407:8;50398:17;;:5;:17;;;;50390:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;50494:8;50456:18;:25;50475:5;50456:25;;;;;;;;;;;;;;;:35;50482:8;50456:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;50540:8;50518:41;;50533:5;50518:41;;;50550:8;50518:41;;;;;;:::i;:::-;;;;;;;;50252:315;;;:::o;45326:::-;45483:28;45493:4;45499:2;45503:7;45483:9;:28::i;:::-;45530:48;45553:4;45559:2;45563:7;45572:5;45530:22;:48::i;:::-;45522:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;45326:315;;;;:::o;60306:679::-;60379:13;60413:16;60421:7;60413;:16::i;:::-;60405:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;60496:23;60522:10;:19;60533:7;60522:19;;;;;;;;;;;60496:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60552:18;60573:10;:8;:10::i;:::-;60552:31;;60681:1;60665:4;60659:18;:23;60655:72;;;60706:9;60699:16;;;;;;60655:72;60857:1;60837:9;60831:23;:27;60827:108;;;60906:4;60912:9;60889:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60875:48;;;;;;60827:108;60954:23;60969:7;60954:14;:23::i;:::-;60947:30;;;;60306:679;;;;:::o;40196:305::-;40298:4;40350:25;40335:40;;;:11;:40;;;;:105;;;;40407:33;40392:48;;;:11;:48;;;;40335:105;:158;;;;40457:36;40481:11;40457:23;:36::i;:::-;40335:158;40315:178;;40196:305;;;:::o;69668:175::-;69792:45;69819:4;69825:2;69829:7;69792:26;:45::i;:::-;69668:175;;;:::o;8021:127::-;8128:1;8110:7;:14;;;:19;;;;;;;;;;;8021:127;:::o;47932:382::-;48026:1;48012:16;;:2;:16;;;;48004:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;48085:16;48093:7;48085;:16::i;:::-;48084:17;48076:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;48147:45;48176:1;48180:2;48184:7;48147:20;:45::i;:::-;48222:1;48205:9;:13;48215:2;48205:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;48253:2;48234:7;:16;48242:7;48234:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;48298:7;48294:2;48273:33;;48290:1;48273:33;;;;;;;;;;;;47932:382;;:::o;70128:497::-;70178:27;70224:1;70218:2;:7;70214:42;;;70238:10;;;;;;;;;;;;;;;;;;;;;70214:42;70262:6;70271:2;70262:11;;70280:8;70295:57;70307:1;70302;:6;70295:57;;70321:5;;;;;:::i;:::-;;;;70342:2;70337:7;;;;;:::i;:::-;;;70295:57;;;70358:17;70388:3;70378:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70358:34;;70399:6;70408:3;70399:12;;70418:174;70431:1;70425:2;:7;70418:174;;70451:1;70449;:3;;;;:::i;:::-;70445:7;;70463:10;70503:2;70498;70493;:7;;;;:::i;:::-;:12;;;;:::i;:::-;70488:2;:17;;;;:::i;:::-;70477:2;:29;;;;:::i;:::-;70463:44;;70518:9;70537:4;70530:12;;70518:24;;70563:2;70553:4;70558:1;70553:7;;;;;;;;;;;;;;;;;;;:12;;;;;;;;;;;70582:2;70576:8;;;;;:::i;:::-;;;70418:174;;;;;70612:4;70598:19;;;;;;70128:497;;;;:::o;61141:217::-;61241:16;61249:7;61241;:16::i;:::-;61233:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;61341:9;61319:10;:19;61330:7;61319:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;61141:217;;:::o;51132:799::-;51287:4;51308:15;:2;:13;;;:15::i;:::-;51304:620;;;51360:2;51344:36;;;51381:12;:10;:12::i;:::-;51395:4;51401:7;51410:5;51344:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;51340:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51603:1;51586:6;:13;:18;51582:272;;;51629:60;;;;;;;;;;:::i;:::-;;;;;;;;51582:272;51804:6;51798:13;51789:6;51785:2;51781:15;51774:38;51340:529;51477:41;;;51467:51;;;:6;:51;;;;51460:58;;;;;51304:620;51908:4;51901:11;;51132:799;;;;;;;:::o;69373:102::-;69433:13;69462:7;69455:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69373:102;:::o;41485:334::-;41558:13;41592:16;41600:7;41592;:16::i;:::-;41584:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;41673:21;41697:10;:8;:10::i;:::-;41673:34;;41749:1;41731:7;41725:21;:25;:86;;;;;;;;;;;;;;;;;41777:7;41786:18;:7;:16;:18::i;:::-;41760:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;41725:86;41718:93;;;41485:334;;;:::o;31892:157::-;31977:4;32016:25;32001:40;;;:11;:40;;;;31994:47;;31892:157;;;:::o;55323:589::-;55467:45;55494:4;55500:2;55504:7;55467:26;:45::i;:::-;55545:1;55529:18;;:4;:18;;;55525:187;;;55564:40;55596:7;55564:31;:40::i;:::-;55525:187;;;55634:2;55626:10;;:4;:10;;;55622:90;;55653:47;55686:4;55692:7;55653:32;:47::i;:::-;55622:90;55525:187;55740:1;55726:16;;:2;:16;;;55722:183;;;55759:45;55796:7;55759:36;:45::i;:::-;55722:183;;;55832:4;55826:10;;:2;:10;;;55822:83;;55853:40;55881:2;55885:7;55853:27;:40::i;:::-;55822:83;55722:183;55323:589;;;:::o;17755:387::-;17815:4;18023:12;18090:7;18078:20;18070:28;;18133:1;18126:4;:8;18119:15;;;17755:387;;;:::o;11753:723::-;11809:13;12039:1;12030:5;:10;12026:53;;;12057:10;;;;;;;;;;;;;;;;;;;;;12026:53;12089:12;12104:5;12089:20;;12120:14;12145:78;12160:1;12152:4;:9;12145:78;;12178:8;;;;;:::i;:::-;;;;12209:2;12201:10;;;;;:::i;:::-;;;12145:78;;;12233:19;12265:6;12255:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12233:39;;12283:154;12299:1;12290:5;:10;12283:154;;12327:1;12317:11;;;;;:::i;:::-;;;12394:2;12386:5;:10;;;;:::i;:::-;12373:2;:24;;;;:::i;:::-;12360:39;;12343:6;12350;12343:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;12423:2;12414:11;;;;;:::i;:::-;;;12283:154;;;12461:6;12447:21;;;;;11753:723;;;;:::o;52503:126::-;;;;:::o;56635:164::-;56739:10;:17;;;;56712:15;:24;56728:7;56712:24;;;;;;;;;;;:44;;;;56767:10;56783:7;56767:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56635:164;:::o;57426:988::-;57692:22;57742:1;57717:22;57734:4;57717:16;:22::i;:::-;:26;;;;:::i;:::-;57692:51;;57754:18;57775:17;:26;57793:7;57775:26;;;;;;;;;;;;57754:47;;57922:14;57908:10;:28;57904:328;;57953:19;57975:12;:18;57988:4;57975:18;;;;;;;;;;;;;;;:34;57994:14;57975:34;;;;;;;;;;;;57953:56;;58059:11;58026:12;:18;58039:4;58026:18;;;;;;;;;;;;;;;:30;58045:10;58026:30;;;;;;;;;;;:44;;;;58176:10;58143:17;:30;58161:11;58143:30;;;;;;;;;;;:43;;;;57904:328;;58328:17;:26;58346:7;58328:26;;;;;;;;;;;58321:33;;;58372:12;:18;58385:4;58372:18;;;;;;;;;;;;;;;:34;58391:14;58372:34;;;;;;;;;;;58365:41;;;57426:988;;;;:::o;58709:1079::-;58962:22;59007:1;58987:10;:17;;;;:21;;;;:::i;:::-;58962:46;;59019:18;59040:15;:24;59056:7;59040:24;;;;;;;;;;;;59019:45;;59391:19;59413:10;59424:14;59413:26;;;;;;;;;;;;;;;;;;;;;;;;59391:48;;59477:11;59452:10;59463;59452:22;;;;;;;;;;;;;;;;;;;;;;;:36;;;;59588:10;59557:15;:28;59573:11;59557:28;;;;;;;;;;;:41;;;;59729:15;:24;59745:7;59729:24;;;;;;;;;;;59722:31;;;59764:10;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58709:1079;;;;:::o;56213:221::-;56298:14;56315:20;56332:2;56315:16;:20::i;:::-;56298:37;;56373:7;56346:12;:16;56359:2;56346:16;;;;;;;;;;;;;;;:24;56363:6;56346:24;;;;;;;;;;;:34;;;;56420:6;56391:17;:26;56409:7;56391:26;;;;;;;;;;;:35;;;;56213:221;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:343:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:2;;;290:1;287;280:12;249:2;303:41;337:6;332:3;327;303:41;:::i;:::-;90:260;;;;;;:::o;356:345::-;434:5;459:66;475:49;517:6;475:49;:::i;:::-;459:66;:::i;:::-;450:75;;548:6;541:5;534:21;586:4;579:5;575:16;624:3;615:6;610:3;606:16;603:25;600:2;;;641:1;638;631:12;600:2;654:41;688:6;683:3;678;654:41;:::i;:::-;440:261;;;;;;:::o;707:139::-;753:5;791:6;778:20;769:29;;807:33;834:5;807:33;:::i;:::-;759:87;;;;:::o;852:133::-;895:5;933:6;920:20;911:29;;949:30;973:5;949:30;:::i;:::-;901:84;;;;:::o;991:137::-;1045:5;1076:6;1070:13;1061:22;;1092:30;1116:5;1092:30;:::i;:::-;1051:77;;;;:::o;1134:137::-;1179:5;1217:6;1204:20;1195:29;;1233:32;1259:5;1233:32;:::i;:::-;1185:86;;;;:::o;1277:141::-;1333:5;1364:6;1358:13;1349:22;;1380:32;1406:5;1380:32;:::i;:::-;1339:79;;;;:::o;1437:271::-;1492:5;1541:3;1534:4;1526:6;1522:17;1518:27;1508:2;;1559:1;1556;1549:12;1508:2;1599:6;1586:20;1624:78;1698:3;1690:6;1683:4;1675:6;1671:17;1624:78;:::i;:::-;1615:87;;1498:210;;;;;:::o;1728:273::-;1784:5;1833:3;1826:4;1818:6;1814:17;1810:27;1800:2;;1851:1;1848;1841:12;1800:2;1891:6;1878:20;1916:79;1991:3;1983:6;1976:4;1968:6;1964:17;1916:79;:::i;:::-;1907:88;;1790:211;;;;;:::o;2007:139::-;2053:5;2091:6;2078:20;2069:29;;2107:33;2134:5;2107:33;:::i;:::-;2059:87;;;;:::o;2152:143::-;2209:5;2240:6;2234:13;2225:22;;2256:33;2283:5;2256:33;:::i;:::-;2215:80;;;;:::o;2301:262::-;2360:6;2409:2;2397:9;2388:7;2384:23;2380:32;2377:2;;;2425:1;2422;2415:12;2377:2;2468:1;2493:53;2538:7;2529:6;2518:9;2514:22;2493:53;:::i;:::-;2483:63;;2439:117;2367:196;;;;:::o;2569:407::-;2637:6;2645;2694:2;2682:9;2673:7;2669:23;2665:32;2662:2;;;2710:1;2707;2700:12;2662:2;2753:1;2778:53;2823:7;2814:6;2803:9;2799:22;2778:53;:::i;:::-;2768:63;;2724:117;2880:2;2906:53;2951:7;2942:6;2931:9;2927:22;2906:53;:::i;:::-;2896:63;;2851:118;2652:324;;;;;:::o;2982:552::-;3059:6;3067;3075;3124:2;3112:9;3103:7;3099:23;3095:32;3092:2;;;3140:1;3137;3130:12;3092:2;3183:1;3208:53;3253:7;3244:6;3233:9;3229:22;3208:53;:::i;:::-;3198:63;;3154:117;3310:2;3336:53;3381:7;3372:6;3361:9;3357:22;3336:53;:::i;:::-;3326:63;;3281:118;3438:2;3464:53;3509:7;3500:6;3489:9;3485:22;3464:53;:::i;:::-;3454:63;;3409:118;3082:452;;;;;:::o;3540:809::-;3635:6;3643;3651;3659;3708:3;3696:9;3687:7;3683:23;3679:33;3676:2;;;3725:1;3722;3715:12;3676:2;3768:1;3793:53;3838:7;3829:6;3818:9;3814:22;3793:53;:::i;:::-;3783:63;;3739:117;3895:2;3921:53;3966:7;3957:6;3946:9;3942:22;3921:53;:::i;:::-;3911:63;;3866:118;4023:2;4049:53;4094:7;4085:6;4074:9;4070:22;4049:53;:::i;:::-;4039:63;;3994:118;4179:2;4168:9;4164:18;4151:32;4210:18;4202:6;4199:30;4196:2;;;4242:1;4239;4232:12;4196:2;4270:62;4324:7;4315:6;4304:9;4300:22;4270:62;:::i;:::-;4260:72;;4122:220;3666:683;;;;;;;:::o;4355:401::-;4420:6;4428;4477:2;4465:9;4456:7;4452:23;4448:32;4445:2;;;4493:1;4490;4483:12;4445:2;4536:1;4561:53;4606:7;4597:6;4586:9;4582:22;4561:53;:::i;:::-;4551:63;;4507:117;4663:2;4689:50;4731:7;4722:6;4711:9;4707:22;4689:50;:::i;:::-;4679:60;;4634:115;4435:321;;;;;:::o;4762:407::-;4830:6;4838;4887:2;4875:9;4866:7;4862:23;4858:32;4855:2;;;4903:1;4900;4893:12;4855:2;4946:1;4971:53;5016:7;5007:6;4996:9;4992:22;4971:53;:::i;:::-;4961:63;;4917:117;5073:2;5099:53;5144:7;5135:6;5124:9;5120:22;5099:53;:::i;:::-;5089:63;;5044:118;4845:324;;;;;:::o;5175:256::-;5231:6;5280:2;5268:9;5259:7;5255:23;5251:32;5248:2;;;5296:1;5293;5286:12;5248:2;5339:1;5364:50;5406:7;5397:6;5386:9;5382:22;5364:50;:::i;:::-;5354:60;;5310:114;5238:193;;;;:::o;5437:278::-;5504:6;5553:2;5541:9;5532:7;5528:23;5524:32;5521:2;;;5569:1;5566;5559:12;5521:2;5612:1;5637:61;5690:7;5681:6;5670:9;5666:22;5637:61;:::i;:::-;5627:71;;5583:125;5511:204;;;;:::o;5721:260::-;5779:6;5828:2;5816:9;5807:7;5803:23;5799:32;5796:2;;;5844:1;5841;5834:12;5796:2;5887:1;5912:52;5956:7;5947:6;5936:9;5932:22;5912:52;:::i;:::-;5902:62;;5858:116;5786:195;;;;:::o;5987:282::-;6056:6;6105:2;6093:9;6084:7;6080:23;6076:32;6073:2;;;6121:1;6118;6111:12;6073:2;6164:1;6189:63;6244:7;6235:6;6224:9;6220:22;6189:63;:::i;:::-;6179:73;;6135:127;6063:206;;;;:::o;6275:375::-;6344:6;6393:2;6381:9;6372:7;6368:23;6364:32;6361:2;;;6409:1;6406;6399:12;6361:2;6480:1;6469:9;6465:17;6452:31;6510:18;6502:6;6499:30;6496:2;;;6542:1;6539;6532:12;6496:2;6570:63;6625:7;6616:6;6605:9;6601:22;6570:63;:::i;:::-;6560:73;;6423:220;6351:299;;;;:::o;6656:262::-;6715:6;6764:2;6752:9;6743:7;6739:23;6735:32;6732:2;;;6780:1;6777;6770:12;6732:2;6823:1;6848:53;6893:7;6884:6;6873:9;6869:22;6848:53;:::i;:::-;6838:63;;6794:117;6722:196;;;;:::o;6924:284::-;6994:6;7043:2;7031:9;7022:7;7018:23;7014:32;7011:2;;;7059:1;7056;7049:12;7011:2;7102:1;7127:64;7183:7;7174:6;7163:9;7159:22;7127:64;:::i;:::-;7117:74;;7073:128;7001:207;;;;:::o;7214:118::-;7301:24;7319:5;7301:24;:::i;:::-;7296:3;7289:37;7279:53;;:::o;7338:109::-;7419:21;7434:5;7419:21;:::i;:::-;7414:3;7407:34;7397:50;;:::o;7453:360::-;7539:3;7567:38;7599:5;7567:38;:::i;:::-;7621:70;7684:6;7679:3;7621:70;:::i;:::-;7614:77;;7700:52;7745:6;7740:3;7733:4;7726:5;7722:16;7700:52;:::i;:::-;7777:29;7799:6;7777:29;:::i;:::-;7772:3;7768:39;7761:46;;7543:270;;;;;:::o;7819:364::-;7907:3;7935:39;7968:5;7935:39;:::i;:::-;7990:71;8054:6;8049:3;7990:71;:::i;:::-;7983:78;;8070:52;8115:6;8110:3;8103:4;8096:5;8092:16;8070:52;:::i;:::-;8147:29;8169:6;8147:29;:::i;:::-;8142:3;8138:39;8131:46;;7911:272;;;;;:::o;8189:377::-;8295:3;8323:39;8356:5;8323:39;:::i;:::-;8378:89;8460:6;8455:3;8378:89;:::i;:::-;8371:96;;8476:52;8521:6;8516:3;8509:4;8502:5;8498:16;8476:52;:::i;:::-;8553:6;8548:3;8544:16;8537:23;;8299:267;;;;;:::o;8596:845::-;8699:3;8736:5;8730:12;8765:36;8791:9;8765:36;:::i;:::-;8817:89;8899:6;8894:3;8817:89;:::i;:::-;8810:96;;8937:1;8926:9;8922:17;8953:1;8948:137;;;;9099:1;9094:341;;;;8915:520;;8948:137;9032:4;9028:9;9017;9013:25;9008:3;9001:38;9068:6;9063:3;9059:16;9052:23;;8948:137;;9094:341;9161:38;9193:5;9161:38;:::i;:::-;9221:1;9235:154;9249:6;9246:1;9243:13;9235:154;;;9323:7;9317:14;9313:1;9308:3;9304:11;9297:35;9373:1;9364:7;9360:15;9349:26;;9271:4;9268:1;9264:12;9259:17;;9235:154;;;9418:6;9413:3;9409:16;9402:23;;9101:334;;8915:520;;8703:738;;;;;;:::o;9447:366::-;9589:3;9610:67;9674:2;9669:3;9610:67;:::i;:::-;9603:74;;9686:93;9775:3;9686:93;:::i;:::-;9804:2;9799:3;9795:12;9788:19;;9593:220;;;:::o;9819:366::-;9961:3;9982:67;10046:2;10041:3;9982:67;:::i;:::-;9975:74;;10058:93;10147:3;10058:93;:::i;:::-;10176:2;10171:3;10167:12;10160:19;;9965:220;;;:::o;10191:366::-;10333:3;10354:67;10418:2;10413:3;10354:67;:::i;:::-;10347:74;;10430:93;10519:3;10430:93;:::i;:::-;10548:2;10543:3;10539:12;10532:19;;10337:220;;;:::o;10563:366::-;10705:3;10726:67;10790:2;10785:3;10726:67;:::i;:::-;10719:74;;10802:93;10891:3;10802:93;:::i;:::-;10920:2;10915:3;10911:12;10904:19;;10709:220;;;:::o;10935:366::-;11077:3;11098:67;11162:2;11157:3;11098:67;:::i;:::-;11091:74;;11174:93;11263:3;11174:93;:::i;:::-;11292:2;11287:3;11283:12;11276:19;;11081:220;;;:::o;11307:366::-;11449:3;11470:67;11534:2;11529:3;11470:67;:::i;:::-;11463:74;;11546:93;11635:3;11546:93;:::i;:::-;11664:2;11659:3;11655:12;11648:19;;11453:220;;;:::o;11679:366::-;11821:3;11842:67;11906:2;11901:3;11842:67;:::i;:::-;11835:74;;11918:93;12007:3;11918:93;:::i;:::-;12036:2;12031:3;12027:12;12020:19;;11825:220;;;:::o;12051:366::-;12193:3;12214:67;12278:2;12273:3;12214:67;:::i;:::-;12207:74;;12290:93;12379:3;12290:93;:::i;:::-;12408:2;12403:3;12399:12;12392:19;;12197:220;;;:::o;12423:366::-;12565:3;12586:67;12650:2;12645:3;12586:67;:::i;:::-;12579:74;;12662:93;12751:3;12662:93;:::i;:::-;12780:2;12775:3;12771:12;12764:19;;12569:220;;;:::o;12795:366::-;12937:3;12958:67;13022:2;13017:3;12958:67;:::i;:::-;12951:74;;13034:93;13123:3;13034:93;:::i;:::-;13152:2;13147:3;13143:12;13136:19;;12941:220;;;:::o;13167:366::-;13309:3;13330:67;13394:2;13389:3;13330:67;:::i;:::-;13323:74;;13406:93;13495:3;13406:93;:::i;:::-;13524:2;13519:3;13515:12;13508:19;;13313:220;;;:::o;13539:366::-;13681:3;13702:67;13766:2;13761:3;13702:67;:::i;:::-;13695:74;;13778:93;13867:3;13778:93;:::i;:::-;13896:2;13891:3;13887:12;13880:19;;13685:220;;;:::o;13911:366::-;14053:3;14074:67;14138:2;14133:3;14074:67;:::i;:::-;14067:74;;14150:93;14239:3;14150:93;:::i;:::-;14268:2;14263:3;14259:12;14252:19;;14057:220;;;:::o;14283:366::-;14425:3;14446:67;14510:2;14505:3;14446:67;:::i;:::-;14439:74;;14522:93;14611:3;14522:93;:::i;:::-;14640:2;14635:3;14631:12;14624:19;;14429:220;;;:::o;14655:366::-;14797:3;14818:67;14882:2;14877:3;14818:67;:::i;:::-;14811:74;;14894:93;14983:3;14894:93;:::i;:::-;15012:2;15007:3;15003:12;14996:19;;14801:220;;;:::o;15027:366::-;15169:3;15190:67;15254:2;15249:3;15190:67;:::i;:::-;15183:74;;15266:93;15355:3;15266:93;:::i;:::-;15384:2;15379:3;15375:12;15368:19;;15173:220;;;:::o;15399:366::-;15541:3;15562:67;15626:2;15621:3;15562:67;:::i;:::-;15555:74;;15638:93;15727:3;15638:93;:::i;:::-;15756:2;15751:3;15747:12;15740:19;;15545:220;;;:::o;15771:366::-;15913:3;15934:67;15998:2;15993:3;15934:67;:::i;:::-;15927:74;;16010:93;16099:3;16010:93;:::i;:::-;16128:2;16123:3;16119:12;16112:19;;15917:220;;;:::o;16143:366::-;16285:3;16306:67;16370:2;16365:3;16306:67;:::i;:::-;16299:74;;16382:93;16471:3;16382:93;:::i;:::-;16500:2;16495:3;16491:12;16484:19;;16289:220;;;:::o;16515:366::-;16657:3;16678:67;16742:2;16737:3;16678:67;:::i;:::-;16671:74;;16754:93;16843:3;16754:93;:::i;:::-;16872:2;16867:3;16863:12;16856:19;;16661:220;;;:::o;16887:400::-;17047:3;17068:84;17150:1;17145:3;17068:84;:::i;:::-;17061:91;;17161:93;17250:3;17161:93;:::i;:::-;17279:1;17274:3;17270:11;17263:18;;17051:236;;;:::o;17293:366::-;17435:3;17456:67;17520:2;17515:3;17456:67;:::i;:::-;17449:74;;17532:93;17621:3;17532:93;:::i;:::-;17650:2;17645:3;17641:12;17634:19;;17439:220;;;:::o;17665:366::-;17807:3;17828:67;17892:2;17887:3;17828:67;:::i;:::-;17821:74;;17904:93;17993:3;17904:93;:::i;:::-;18022:2;18017:3;18013:12;18006:19;;17811:220;;;:::o;18037:366::-;18179:3;18200:67;18264:2;18259:3;18200:67;:::i;:::-;18193:74;;18276:93;18365:3;18276:93;:::i;:::-;18394:2;18389:3;18385:12;18378:19;;18183:220;;;:::o;18409:366::-;18551:3;18572:67;18636:2;18631:3;18572:67;:::i;:::-;18565:74;;18648:93;18737:3;18648:93;:::i;:::-;18766:2;18761:3;18757:12;18750:19;;18555:220;;;:::o;18781:366::-;18923:3;18944:67;19008:2;19003:3;18944:67;:::i;:::-;18937:74;;19020:93;19109:3;19020:93;:::i;:::-;19138:2;19133:3;19129:12;19122:19;;18927:220;;;:::o;19153:400::-;19313:3;19334:84;19416:1;19411:3;19334:84;:::i;:::-;19327:91;;19427:93;19516:3;19427:93;:::i;:::-;19545:1;19540:3;19536:11;19529:18;;19317:236;;;:::o;19559:366::-;19701:3;19722:67;19786:2;19781:3;19722:67;:::i;:::-;19715:74;;19798:93;19887:3;19798:93;:::i;:::-;19916:2;19911:3;19907:12;19900:19;;19705:220;;;:::o;19931:366::-;20073:3;20094:67;20158:2;20153:3;20094:67;:::i;:::-;20087:74;;20170:93;20259:3;20170:93;:::i;:::-;20288:2;20283:3;20279:12;20272:19;;20077:220;;;:::o;20303:366::-;20445:3;20466:67;20530:2;20525:3;20466:67;:::i;:::-;20459:74;;20542:93;20631:3;20542:93;:::i;:::-;20660:2;20655:3;20651:12;20644:19;;20449:220;;;:::o;20675:118::-;20762:24;20780:5;20762:24;:::i;:::-;20757:3;20750:37;20740:53;;:::o;20799:435::-;20979:3;21001:95;21092:3;21083:6;21001:95;:::i;:::-;20994:102;;21113:95;21204:3;21195:6;21113:95;:::i;:::-;21106:102;;21225:3;21218:10;;20983:251;;;;;:::o;21240:541::-;21473:3;21495:95;21586:3;21577:6;21495:95;:::i;:::-;21488:102;;21607:148;21751:3;21607:148;:::i;:::-;21600:155;;21772:3;21765:10;;21477:304;;;;:::o;21787:269::-;21916:3;21938:92;22026:3;22017:6;21938:92;:::i;:::-;21931:99;;22047:3;22040:10;;21920:136;;;;:::o;22062:381::-;22247:3;22269:148;22413:3;22269:148;:::i;:::-;22262:155;;22434:3;22427:10;;22251:192;;;:::o;22449:222::-;22542:4;22580:2;22569:9;22565:18;22557:26;;22593:71;22661:1;22650:9;22646:17;22637:6;22593:71;:::i;:::-;22547:124;;;;:::o;22677:332::-;22798:4;22836:2;22825:9;22821:18;22813:26;;22849:71;22917:1;22906:9;22902:17;22893:6;22849:71;:::i;:::-;22930:72;22998:2;22987:9;22983:18;22974:6;22930:72;:::i;:::-;22803:206;;;;;:::o;23015:442::-;23164:4;23202:2;23191:9;23187:18;23179:26;;23215:71;23283:1;23272:9;23268:17;23259:6;23215:71;:::i;:::-;23296:72;23364:2;23353:9;23349:18;23340:6;23296:72;:::i;:::-;23378;23446:2;23435:9;23431:18;23422:6;23378:72;:::i;:::-;23169:288;;;;;;:::o;23463:640::-;23658:4;23696:3;23685:9;23681:19;23673:27;;23710:71;23778:1;23767:9;23763:17;23754:6;23710:71;:::i;:::-;23791:72;23859:2;23848:9;23844:18;23835:6;23791:72;:::i;:::-;23873;23941:2;23930:9;23926:18;23917:6;23873:72;:::i;:::-;23992:9;23986:4;23982:20;23977:2;23966:9;23962:18;23955:48;24020:76;24091:4;24082:6;24020:76;:::i;:::-;24012:84;;23663:440;;;;;;;:::o;24109:210::-;24196:4;24234:2;24223:9;24219:18;24211:26;;24247:65;24309:1;24298:9;24294:17;24285:6;24247:65;:::i;:::-;24201:118;;;;:::o;24325:313::-;24438:4;24476:2;24465:9;24461:18;24453:26;;24525:9;24519:4;24515:20;24511:1;24500:9;24496:17;24489:47;24553:78;24626:4;24617:6;24553:78;:::i;:::-;24545:86;;24443:195;;;;:::o;24644:419::-;24810:4;24848:2;24837:9;24833:18;24825:26;;24897:9;24891:4;24887:20;24883:1;24872:9;24868:17;24861:47;24925:131;25051:4;24925:131;:::i;:::-;24917:139;;24815:248;;;:::o;25069:419::-;25235:4;25273:2;25262:9;25258:18;25250:26;;25322:9;25316:4;25312:20;25308:1;25297:9;25293:17;25286:47;25350:131;25476:4;25350:131;:::i;:::-;25342:139;;25240:248;;;:::o;25494:419::-;25660:4;25698:2;25687:9;25683:18;25675:26;;25747:9;25741:4;25737:20;25733:1;25722:9;25718:17;25711:47;25775:131;25901:4;25775:131;:::i;:::-;25767:139;;25665:248;;;:::o;25919:419::-;26085:4;26123:2;26112:9;26108:18;26100:26;;26172:9;26166:4;26162:20;26158:1;26147:9;26143:17;26136:47;26200:131;26326:4;26200:131;:::i;:::-;26192:139;;26090:248;;;:::o;26344:419::-;26510:4;26548:2;26537:9;26533:18;26525:26;;26597:9;26591:4;26587:20;26583:1;26572:9;26568:17;26561:47;26625:131;26751:4;26625:131;:::i;:::-;26617:139;;26515:248;;;:::o;26769:419::-;26935:4;26973:2;26962:9;26958:18;26950:26;;27022:9;27016:4;27012:20;27008:1;26997:9;26993:17;26986:47;27050:131;27176:4;27050:131;:::i;:::-;27042:139;;26940:248;;;:::o;27194:419::-;27360:4;27398:2;27387:9;27383:18;27375:26;;27447:9;27441:4;27437:20;27433:1;27422:9;27418:17;27411:47;27475:131;27601:4;27475:131;:::i;:::-;27467:139;;27365:248;;;:::o;27619:419::-;27785:4;27823:2;27812:9;27808:18;27800:26;;27872:9;27866:4;27862:20;27858:1;27847:9;27843:17;27836:47;27900:131;28026:4;27900:131;:::i;:::-;27892:139;;27790:248;;;:::o;28044:419::-;28210:4;28248:2;28237:9;28233:18;28225:26;;28297:9;28291:4;28287:20;28283:1;28272:9;28268:17;28261:47;28325:131;28451:4;28325:131;:::i;:::-;28317:139;;28215:248;;;:::o;28469:419::-;28635:4;28673:2;28662:9;28658:18;28650:26;;28722:9;28716:4;28712:20;28708:1;28697:9;28693:17;28686:47;28750:131;28876:4;28750:131;:::i;:::-;28742:139;;28640:248;;;:::o;28894:419::-;29060:4;29098:2;29087:9;29083:18;29075:26;;29147:9;29141:4;29137:20;29133:1;29122:9;29118:17;29111:47;29175:131;29301:4;29175:131;:::i;:::-;29167:139;;29065:248;;;:::o;29319:419::-;29485:4;29523:2;29512:9;29508:18;29500:26;;29572:9;29566:4;29562:20;29558:1;29547:9;29543:17;29536:47;29600:131;29726:4;29600:131;:::i;:::-;29592:139;;29490:248;;;:::o;29744:419::-;29910:4;29948:2;29937:9;29933:18;29925:26;;29997:9;29991:4;29987:20;29983:1;29972:9;29968:17;29961:47;30025:131;30151:4;30025:131;:::i;:::-;30017:139;;29915:248;;;:::o;30169:419::-;30335:4;30373:2;30362:9;30358:18;30350:26;;30422:9;30416:4;30412:20;30408:1;30397:9;30393:17;30386:47;30450:131;30576:4;30450:131;:::i;:::-;30442:139;;30340:248;;;:::o;30594:419::-;30760:4;30798:2;30787:9;30783:18;30775:26;;30847:9;30841:4;30837:20;30833:1;30822:9;30818:17;30811:47;30875:131;31001:4;30875:131;:::i;:::-;30867:139;;30765:248;;;:::o;31019:419::-;31185:4;31223:2;31212:9;31208:18;31200:26;;31272:9;31266:4;31262:20;31258:1;31247:9;31243:17;31236:47;31300:131;31426:4;31300:131;:::i;:::-;31292:139;;31190:248;;;:::o;31444:419::-;31610:4;31648:2;31637:9;31633:18;31625:26;;31697:9;31691:4;31687:20;31683:1;31672:9;31668:17;31661:47;31725:131;31851:4;31725:131;:::i;:::-;31717:139;;31615:248;;;:::o;31869:419::-;32035:4;32073:2;32062:9;32058:18;32050:26;;32122:9;32116:4;32112:20;32108:1;32097:9;32093:17;32086:47;32150:131;32276:4;32150:131;:::i;:::-;32142:139;;32040:248;;;:::o;32294:419::-;32460:4;32498:2;32487:9;32483:18;32475:26;;32547:9;32541:4;32537:20;32533:1;32522:9;32518:17;32511:47;32575:131;32701:4;32575:131;:::i;:::-;32567:139;;32465:248;;;:::o;32719:419::-;32885:4;32923:2;32912:9;32908:18;32900:26;;32972:9;32966:4;32962:20;32958:1;32947:9;32943:17;32936:47;33000:131;33126:4;33000:131;:::i;:::-;32992:139;;32890:248;;;:::o;33144:419::-;33310:4;33348:2;33337:9;33333:18;33325:26;;33397:9;33391:4;33387:20;33383:1;33372:9;33368:17;33361:47;33425:131;33551:4;33425:131;:::i;:::-;33417:139;;33315:248;;;:::o;33569:419::-;33735:4;33773:2;33762:9;33758:18;33750:26;;33822:9;33816:4;33812:20;33808:1;33797:9;33793:17;33786:47;33850:131;33976:4;33850:131;:::i;:::-;33842:139;;33740:248;;;:::o;33994:419::-;34160:4;34198:2;34187:9;34183:18;34175:26;;34247:9;34241:4;34237:20;34233:1;34222:9;34218:17;34211:47;34275:131;34401:4;34275:131;:::i;:::-;34267:139;;34165:248;;;:::o;34419:419::-;34585:4;34623:2;34612:9;34608:18;34600:26;;34672:9;34666:4;34662:20;34658:1;34647:9;34643:17;34636:47;34700:131;34826:4;34700:131;:::i;:::-;34692:139;;34590:248;;;:::o;34844:419::-;35010:4;35048:2;35037:9;35033:18;35025:26;;35097:9;35091:4;35087:20;35083:1;35072:9;35068:17;35061:47;35125:131;35251:4;35125:131;:::i;:::-;35117:139;;35015:248;;;:::o;35269:419::-;35435:4;35473:2;35462:9;35458:18;35450:26;;35522:9;35516:4;35512:20;35508:1;35497:9;35493:17;35486:47;35550:131;35676:4;35550:131;:::i;:::-;35542:139;;35440:248;;;:::o;35694:419::-;35860:4;35898:2;35887:9;35883:18;35875:26;;35947:9;35941:4;35937:20;35933:1;35922:9;35918:17;35911:47;35975:131;36101:4;35975:131;:::i;:::-;35967:139;;35865:248;;;:::o;36119:419::-;36285:4;36323:2;36312:9;36308:18;36300:26;;36372:9;36366:4;36362:20;36358:1;36347:9;36343:17;36336:47;36400:131;36526:4;36400:131;:::i;:::-;36392:139;;36290:248;;;:::o;36544:222::-;36637:4;36675:2;36664:9;36660:18;36652:26;;36688:71;36756:1;36745:9;36741:17;36732:6;36688:71;:::i;:::-;36642:124;;;;:::o;36772:129::-;36806:6;36833:20;;:::i;:::-;36823:30;;36862:33;36890:4;36882:6;36862:33;:::i;:::-;36813:88;;;:::o;36907:75::-;36940:6;36973:2;36967:9;36957:19;;36947:35;:::o;36988:307::-;37049:4;37139:18;37131:6;37128:30;37125:2;;;37161:18;;:::i;:::-;37125:2;37199:29;37221:6;37199:29;:::i;:::-;37191:37;;37283:4;37277;37273:15;37265:23;;37054:241;;;:::o;37301:308::-;37363:4;37453:18;37445:6;37442:30;37439:2;;;37475:18;;:::i;:::-;37439:2;37513:29;37535:6;37513:29;:::i;:::-;37505:37;;37597:4;37591;37587:15;37579:23;;37368:241;;;:::o;37615:141::-;37664:4;37687:3;37679:11;;37710:3;37707:1;37700:14;37744:4;37741:1;37731:18;37723:26;;37669:87;;;:::o;37762:98::-;37813:6;37847:5;37841:12;37831:22;;37820:40;;;:::o;37866:99::-;37918:6;37952:5;37946:12;37936:22;;37925:40;;;:::o;37971:168::-;38054:11;38088:6;38083:3;38076:19;38128:4;38123:3;38119:14;38104:29;;38066:73;;;;:::o;38145:169::-;38229:11;38263:6;38258:3;38251:19;38303:4;38298:3;38294:14;38279:29;;38241:73;;;;:::o;38320:148::-;38422:11;38459:3;38444:18;;38434:34;;;;:::o;38474:305::-;38514:3;38533:20;38551:1;38533:20;:::i;:::-;38528:25;;38567:20;38585:1;38567:20;:::i;:::-;38562:25;;38721:1;38653:66;38649:74;38646:1;38643:81;38640:2;;;38727:18;;:::i;:::-;38640:2;38771:1;38768;38764:9;38757:16;;38518:261;;;;:::o;38785:237::-;38823:3;38842:18;38858:1;38842:18;:::i;:::-;38837:23;;38874:18;38890:1;38874:18;:::i;:::-;38869:23;;38964:1;38958:4;38954:12;38951:1;38948:19;38945:2;;;38970:18;;:::i;:::-;38945:2;39014:1;39011;39007:9;39000:16;;38827:195;;;;:::o;39028:185::-;39068:1;39085:20;39103:1;39085:20;:::i;:::-;39080:25;;39119:20;39137:1;39119:20;:::i;:::-;39114:25;;39158:1;39148:2;;39163:18;;:::i;:::-;39148:2;39205:1;39202;39198:9;39193:14;;39070:143;;;;:::o;39219:348::-;39259:7;39282:20;39300:1;39282:20;:::i;:::-;39277:25;;39316:20;39334:1;39316:20;:::i;:::-;39311:25;;39504:1;39436:66;39432:74;39429:1;39426:81;39421:1;39414:9;39407:17;39403:105;39400:2;;;39511:18;;:::i;:::-;39400:2;39559:1;39556;39552:9;39541:20;;39267:300;;;;:::o;39573:191::-;39613:4;39633:20;39651:1;39633:20;:::i;:::-;39628:25;;39667:20;39685:1;39667:20;:::i;:::-;39662:25;;39706:1;39703;39700:8;39697:2;;;39711:18;;:::i;:::-;39697:2;39756:1;39753;39749:9;39741:17;;39618:146;;;;:::o;39770:96::-;39807:7;39836:24;39854:5;39836:24;:::i;:::-;39825:35;;39815:51;;;:::o;39872:90::-;39906:7;39949:5;39942:13;39935:21;39924:32;;39914:48;;;:::o;39968:149::-;40004:7;40044:66;40037:5;40033:78;40022:89;;40012:105;;;:::o;40123:126::-;40160:7;40200:42;40193:5;40189:54;40178:65;;40168:81;;;:::o;40255:77::-;40292:7;40321:5;40310:16;;40300:32;;;:::o;40338:86::-;40373:7;40413:4;40406:5;40402:16;40391:27;;40381:43;;;:::o;40430:154::-;40514:6;40509:3;40504;40491:30;40576:1;40567:6;40562:3;40558:16;40551:27;40481:103;;;:::o;40590:307::-;40658:1;40668:113;40682:6;40679:1;40676:13;40668:113;;;40767:1;40762:3;40758:11;40752:18;40748:1;40743:3;40739:11;40732:39;40704:2;40701:1;40697:10;40692:15;;40668:113;;;40799:6;40796:1;40793:13;40790:2;;;40879:1;40870:6;40865:3;40861:16;40854:27;40790:2;40639:258;;;;:::o;40903:320::-;40947:6;40984:1;40978:4;40974:12;40964:22;;41031:1;41025:4;41021:12;41052:18;41042:2;;41108:4;41100:6;41096:17;41086:27;;41042:2;41170;41162:6;41159:14;41139:18;41136:38;41133:2;;;41189:18;;:::i;:::-;41133:2;40954:269;;;;:::o;41229:281::-;41312:27;41334:4;41312:27;:::i;:::-;41304:6;41300:40;41442:6;41430:10;41427:22;41406:18;41394:10;41391:34;41388:62;41385:2;;;41453:18;;:::i;:::-;41385:2;41493:10;41489:2;41482:22;41272:238;;;:::o;41516:233::-;41555:3;41578:24;41596:5;41578:24;:::i;:::-;41569:33;;41624:66;41617:5;41614:77;41611:2;;;41694:18;;:::i;:::-;41611:2;41741:1;41734:5;41730:13;41723:20;;41559:190;;;:::o;41755:176::-;41787:1;41804:20;41822:1;41804:20;:::i;:::-;41799:25;;41838:20;41856:1;41838:20;:::i;:::-;41833:25;;41877:1;41867:2;;41882:18;;:::i;:::-;41867:2;41923:1;41920;41916:9;41911:14;;41789:142;;;;:::o;41937:180::-;41985:77;41982:1;41975:88;42082:4;42079:1;42072:15;42106:4;42103:1;42096:15;42123:180;42171:77;42168:1;42161:88;42268:4;42265:1;42258:15;42292:4;42289:1;42282:15;42309:180;42357:77;42354:1;42347:88;42454:4;42451:1;42444:15;42478:4;42475:1;42468:15;42495:180;42543:77;42540:1;42533:88;42640:4;42637:1;42630:15;42664:4;42661:1;42654:15;42681:102;42722:6;42773:2;42769:7;42764:2;42757:5;42753:14;42749:28;42739:38;;42729:54;;;:::o;42789:230::-;42929:34;42925:1;42917:6;42913:14;42906:58;42998:13;42993:2;42985:6;42981:15;42974:38;42895:124;:::o;43025:237::-;43165:34;43161:1;43153:6;43149:14;43142:58;43234:20;43229:2;43221:6;43217:15;43210:45;43131:131;:::o;43268:225::-;43408:34;43404:1;43396:6;43392:14;43385:58;43477:8;43472:2;43464:6;43460:15;43453:33;43374:119;:::o;43499:178::-;43639:30;43635:1;43627:6;43623:14;43616:54;43605:72;:::o;43683:226::-;43823:34;43819:1;43811:6;43807:14;43800:58;43892:9;43887:2;43879:6;43875:15;43868:34;43789:120;:::o;43915:169::-;44055:21;44051:1;44043:6;44039:14;44032:45;44021:63;:::o;44090:223::-;44230:34;44226:1;44218:6;44214:14;44207:58;44299:6;44294:2;44286:6;44282:15;44275:31;44196:117;:::o;44319:175::-;44459:27;44455:1;44447:6;44443:14;44436:51;44425:69;:::o;44500:221::-;44640:34;44636:1;44628:6;44624:14;44617:58;44709:4;44704:2;44696:6;44692:15;44685:29;44606:115;:::o;44727:231::-;44867:34;44863:1;44855:6;44851:14;44844:58;44936:14;44931:2;44923:6;44919:15;44912:39;44833:125;:::o;44964:243::-;45104:34;45100:1;45092:6;45088:14;45081:58;45173:26;45168:2;45160:6;45156:15;45149:51;45070:137;:::o;45213:182::-;45353:34;45349:1;45341:6;45337:14;45330:58;45319:76;:::o;45401:229::-;45541:34;45537:1;45529:6;45525:14;45518:58;45610:12;45605:2;45597:6;45593:15;45586:37;45507:123;:::o;45636:228::-;45776:34;45772:1;45764:6;45760:14;45753:58;45845:11;45840:2;45832:6;45828:15;45821:36;45742:122;:::o;45870:233::-;46010:34;46006:1;45998:6;45994:14;45987:58;46079:16;46074:2;46066:6;46062:15;46055:41;45976:127;:::o;46109:232::-;46249:34;46245:1;46237:6;46233:14;46226:58;46318:15;46313:2;46305:6;46301:15;46294:40;46215:126;:::o;46347:182::-;46487:34;46483:1;46475:6;46471:14;46464:58;46453:76;:::o;46535:236::-;46675:34;46671:1;46663:6;46659:14;46652:58;46744:19;46739:2;46731:6;46727:15;46720:44;46641:130;:::o;46777:168::-;46917:20;46913:1;46905:6;46901:14;46894:44;46883:62;:::o;46951:231::-;47091:34;47087:1;47079:6;47075:14;47068:58;47160:14;47155:2;47147:6;47143:15;47136:39;47057:125;:::o;47188:155::-;47328:7;47324:1;47316:6;47312:14;47305:31;47294:49;:::o;47349:182::-;47489:34;47485:1;47477:6;47473:14;47466:58;47455:76;:::o;47537:228::-;47677:34;47673:1;47665:6;47661:14;47654:58;47746:11;47741:2;47733:6;47729:15;47722:36;47643:122;:::o;47771:234::-;47911:34;47907:1;47899:6;47895:14;47888:58;47980:17;47975:2;47967:6;47963:15;47956:42;47877:128;:::o;48011:220::-;48151:34;48147:1;48139:6;48135:14;48128:58;48220:3;48215:2;48207:6;48203:15;48196:28;48117:114;:::o;48237:182::-;48377:34;48373:1;48365:6;48361:14;48354:58;48343:76;:::o;48425:114::-;48531:8;:::o;48545:236::-;48685:34;48681:1;48673:6;48669:14;48662:58;48754:19;48749:2;48741:6;48737:15;48730:44;48651:130;:::o;48787:231::-;48927:34;48923:1;48915:6;48911:14;48904:58;48996:14;48991:2;48983:6;48979:15;48972:39;48893:125;:::o;49024:225::-;49164:34;49160:1;49152:6;49148:14;49141:58;49233:8;49228:2;49220:6;49216:15;49209:33;49130:119;:::o;49255:122::-;49328:24;49346:5;49328:24;:::i;:::-;49321:5;49318:35;49308:2;;49367:1;49364;49357:12;49308:2;49298:79;:::o;49383:116::-;49453:21;49468:5;49453:21;:::i;:::-;49446:5;49443:32;49433:2;;49489:1;49486;49479:12;49433:2;49423:76;:::o;49505:120::-;49577:23;49594:5;49577:23;:::i;:::-;49570:5;49567:34;49557:2;;49615:1;49612;49605:12;49557:2;49547:78;:::o;49631:122::-;49704:24;49722:5;49704:24;:::i;:::-;49697:5;49694:35;49684:2;;49743:1;49740;49733:12;49684:2;49674:79;:::o

Swarm Source

ipfs://33072d23d9ed4832e0175d973fdbe0f1b083ad3c3abcbbcc971b8dfa1cc2790a
Loading