Token BitVoyagers

 

Overview ERC-721

Total Supply:
140 VOYAGER

Holders:
54 addresses

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
Loading

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

Contract Source Code Verified (Exact Match)

Contract Name:
BitVoyagers

Compiler Version
v0.8.7+commit.e28d00a7

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

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

// SPDX-License-Identifier: MIT
// Created by lil esper 2022
// https://twitter.com/lil_esper

// ██████╗ ██╗████████╗    ██╗   ██╗ ██████╗ ██╗   ██╗ █████╗  ██████╗ ███████╗██████╗ ███████╗
// ██╔══██╗██║╚══██╔══╝    ██║   ██║██╔═══██╗╚██╗ ██╔╝██╔══██╗██╔════╝ ██╔════╝██╔══██╗██╔════╝
// ██████╔╝██║   ██║       ██║   ██║██║   ██║ ╚████╔╝ ███████║██║  ███╗█████╗  ██████╔╝███████╗
// ██╔══██╗██║   ██║       ╚██╗ ██╔╝██║   ██║  ╚██╔╝  ██╔══██║██║   ██║██╔══╝  ██╔══██╗╚════██║
// ██████╔╝██║   ██║        ╚████╔╝ ╚██████╔╝   ██║   ██║  ██║╚██████╔╝███████╗██║  ██║███████║
// ╚═════╝ ╚═╝   ╚═╝         ╚═══╝   ╚═════╝    ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚══════╝
                                                                                            
// File: @openzeppelin/contracts/utils/Counters.sol


// OpenZeppelin Contracts v4.4.1 (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 (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens 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 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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


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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.5.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);

    /**
     * @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.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


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

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

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

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


// OpenZeppelin Contracts (last updated v4.6.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 overridden 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 || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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);

        _afterTokenTransfer(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);

        _afterTokenTransfer(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 from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

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


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

pragma solidity ^0.8.0;



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: contracts/BitAvatars.sol


// Created by lil esper 2022
// https://twitter.com/lil_esper

pragma solidity ^0.8.4;






contract BitVoyagers is ERC721, ERC721Enumerable,  Ownable {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;

    string public baseURI;
    ERC20 POTION = ERC20(0x3edA36088b931098e8E472748840b3dF78268c72);
    uint256 public _mintPrice = 100 ether;
    uint256 public _potionMintPrice = 10;
    uint256 public maxSupply = 140;
    string public fileExtension = ".json";
    constructor() ERC721("BitVoyagers", "VOYAGER") {
        
    }
    function updateTotalSupply(uint256 supply) public onlyOwner {
        maxSupply = supply;
    }
    function updateMintPrice(uint256 FTMPRICE) public onlyOwner {
        _mintPrice = FTMPRICE;
    }
    function updatePotionMintPrice(uint256 POTIONPRICE) public onlyOwner {
        _potionMintPrice = POTIONPRICE;
    }
    function updateFileExtension(string memory extension) public onlyOwner {
        fileExtension = extension;
    }
    function potionMint() public {
        require(
            POTION.allowance(address(msg.sender), address(this)) >= _potionMintPrice*1000000000000000000,
            "Please approve Potion fee to continue"
        );
        // Send potion back to the palace directly
        POTION.transferFrom(address(msg.sender), address(0x71909A03f9076c6330EeD80d34196E6498d2C921), _potionMintPrice*1000000000000000000);
        _tokenIdCounter.increment();
        uint256 tokenId = _tokenIdCounter.current();
        require(tokenId <= maxSupply,"Max supply reached");
        _safeMint(msg.sender, tokenId);
    }

    function withdraw() public onlyOwner {
        require(address(this).balance > 0);
        require(address(msg.sender) == owner());
        payable(msg.sender).transfer(address(this).balance);
    }

    function mint() public payable {
        if (msg.sender != owner()) {
            require(msg.value >= _mintPrice);
        }
        _tokenIdCounter.increment();
        uint256 tokenId = _tokenIdCounter.current();
        require(tokenId <= maxSupply,"Max supply reached");
        _safeMint(msg.sender, tokenId);
    }

    function setMetadataURI(string memory metadata) public onlyOwner{
        baseURI = metadata;
    }


    function _beforeTokenTransfer(address from, address to, uint256 tokenId)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function _burn(uint256 tokenId) internal override(ERC721) {
        super._burn(tokenId);
    }


    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721)
        returns (string memory)
    {
        require(_exists(tokenId));
        return
            string(
                abi.encodePacked(baseURI, Strings.toString(tokenId), fileExtension)
            ); 
   }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_potionMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fileExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"potionMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"metadata","type":"string"}],"name":"setMetadataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"extension","type":"string"}],"name":"updateFileExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"FTMPRICE","type":"uint256"}],"name":"updateMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"POTIONPRICE","type":"uint256"}],"name":"updatePotionMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"supply","type":"uint256"}],"name":"updateTotalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

65296:3085:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65896:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68166:212;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65554:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45825:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47385:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46908:411;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67080:329;;;:::i;:::-;;59646:113;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48135:339;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66002:118;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59314:256;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66870:202;;;;;;;;;;;;;:::i;:::-;;48545:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59836:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45519:239;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65793:97;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65455:21;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45249:208;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11442:103;;;;;;;;;;;;;:::i;:::-;;67417:101;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10791:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65678:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45994:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66126:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47678:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66247:615;;;;;;;;;;;;;:::i;:::-;;48801:328;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67847:311;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65641:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47904:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65598:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11700:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65896:100;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;65980:8:::1;65967:10;:21;;;;65896:100:::0;:::o;68166:212::-;68305:4;68334:36;68358:11;68334:23;:36::i;:::-;68327:43;;68166:212;;;:::o;65554:37::-;;;;:::o;45825:100::-;45879:13;45912:5;45905:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45825:100;:::o;47385:221::-;47461:7;47489:16;47497:7;47489;:16::i;:::-;47481:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;47574:15;:24;47590:7;47574:24;;;;;;;;;;;;;;;;;;;;;47567:31;;47385:221;;;:::o;46908:411::-;46989:13;47005:23;47020:7;47005:14;:23::i;:::-;46989:39;;47053:5;47047:11;;:2;:11;;;;47039:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;47147:5;47131:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;47156:37;47173:5;47180:12;:10;:12::i;:::-;47156:16;:37::i;:::-;47131:62;47109:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;47290:21;47299:2;47303:7;47290:8;:21::i;:::-;46978:341;46908:411;;:::o;67080:329::-;67140:7;:5;:7::i;:::-;67126:21;;:10;:21;;;67122:86;;67185:10;;67172:9;:23;;67164:32;;;;;;67122:86;67218:27;:15;:25;:27::i;:::-;67256:15;67274:25;:15;:23;:25::i;:::-;67256:43;;67329:9;;67318:7;:20;;67310:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;67371:30;67381:10;67393:7;67371:9;:30::i;:::-;67111:298;67080:329::o;59646:113::-;59707:7;59734:10;:17;;;;59727:24;;59646:113;:::o;48135:339::-;48330:41;48349:12;:10;:12::i;:::-;48363:7;48330:18;:41::i;:::-;48322:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;48438:28;48448:4;48454:2;48458:7;48438:9;:28::i;:::-;48135:339;;;:::o;66002:118::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66101:11:::1;66082:16;:30;;;;66002:118:::0;:::o;59314:256::-;59411:7;59447:23;59464:5;59447:16;:23::i;:::-;59439:5;:31;59431:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;59536:12;:19;59549:5;59536:19;;;;;;;;;;;;;;;:26;59556:5;59536:26;;;;;;;;;;;;59529:33;;59314:256;;;;:::o;66870:202::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66950:1:::1;66926:21;:25;66918:34;;;::::0;::::1;;66994:7;:5;:7::i;:::-;66971:30;;66979:10;66971:30;;;66963:39;;;::::0;::::1;;67021:10;67013:28;;:51;67042:21;67013:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;66870:202::o:0;48545:185::-;48683:39;48700:4;48706:2;48710:7;48683:39;;;;;;;;;;;;:16;:39::i;:::-;48545:185;;;:::o;59836:233::-;59911:7;59947:30;:28;:30::i;:::-;59939:5;:38;59931:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;60044:10;60055:5;60044:17;;;;;;;;:::i;:::-;;;;;;;;;;60037:24;;59836:233;;;:::o;45519:239::-;45591:7;45611:13;45627:7;:16;45635:7;45627:16;;;;;;;;;;;;;;;;;;;;;45611:32;;45679:1;45662:19;;:5;:19;;;;45654:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;45745:5;45738:12;;;45519:239;;;:::o;65793:97::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;65876:6:::1;65864:9;:18;;;;65793:97:::0;:::o;65455:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45249:208::-;45321:7;45366:1;45349:19;;:5;:19;;;;45341:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;45433:9;:16;45443:5;45433:16;;;;;;;;;;;;;;;;45426:23;;45249:208;;;:::o;11442:103::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;11507:30:::1;11534:1;11507:18;:30::i;:::-;11442:103::o:0;67417:101::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67502:8:::1;67492:7;:18;;;;;;;;;;;;:::i;:::-;;67417:101:::0;:::o;10791:87::-;10837:7;10864:6;;;;;;;;;;;10857:13;;10791:87;:::o;65678:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45994:104::-;46050:13;46083:7;46076:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45994:104;:::o;66126:115::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66224:9:::1;66208:13;:25;;;;;;;;;;;;:::i;:::-;;66126:115:::0;:::o;47678:155::-;47773:52;47792:12;:10;:12::i;:::-;47806:8;47816;47773:18;:52::i;:::-;47678:155;;:::o;66247:615::-;66382:19;66365:16;;:36;;;;:::i;:::-;66309:6;;;;;;;;;;;:16;;;66334:10;66355:4;66309:52;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:92;;66287:179;;;;;;;;;;;;:::i;:::-;;;;;;;;;66529:6;;;;;;;;;;;:19;;;66557:10;66578:42;66640:19;66623:16;;:36;;;;:::i;:::-;66529:131;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;66671:27;:15;:25;:27::i;:::-;66709:15;66727:25;:15;:23;:25::i;:::-;66709:43;;66782:9;;66771:7;:20;;66763:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;66824:30;66834:10;66846:7;66824:9;:30::i;:::-;66276:586;66247:615::o;48801:328::-;48976:41;48995:12;:10;:12::i;:::-;49009:7;48976:18;:41::i;:::-;48968:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;49082:39;49096:4;49102:2;49106:7;49115:5;49082:13;:39::i;:::-;48801:328;;;;:::o;67847:311::-;67956:13;67995:16;68003:7;67995;:16::i;:::-;67987:25;;;;;;68085:7;68094:25;68111:7;68094:16;:25::i;:::-;68121:13;68068:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;68023:127;;67847:311;;;:::o;65641:30::-;;;;:::o;47904:164::-;48001:4;48025:18;:25;48044:5;48025:25;;;;;;;;;;;;;;;:35;48051:8;48025:35;;;;;;;;;;;;;;;;;;;;;;;;;48018:42;;47904:164;;;;:::o;65598:36::-;;;;:::o;11700:201::-;11022:12;:10;:12::i;:::-;11011:23;;:7;:5;:7::i;:::-;:23;;;11003:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;11809:1:::1;11789:22;;:8;:22;;;;11781:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;11865:28;11884:8;11865:18;:28::i;:::-;11700:201:::0;:::o;9515:98::-;9568:7;9595:10;9588:17;;9515:98;:::o;59006:224::-;59108:4;59147:35;59132:50;;;:11;:50;;;;:90;;;;59186:36;59210:11;59186:23;:36::i;:::-;59132:90;59125:97;;59006:224;;;:::o;50639:127::-;50704:4;50756:1;50728:30;;:7;:16;50736:7;50728:16;;;;;;;;;;;;;;;;;;;;;:30;;;;50721:37;;50639:127;;;:::o;54785:174::-;54887:2;54860:15;:24;54876:7;54860:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;54943:7;54939:2;54905:46;;54914:23;54929:7;54914:14;:23::i;:::-;54905:46;;;;;;;;;;;;54785:174;;:::o;2627:127::-;2734:1;2716:7;:14;;;:19;;;;;;;;;;;2627:127;:::o;2505:114::-;2570:7;2597;:14;;;2590:21;;2505:114;;;:::o;51623:110::-;51699:26;51709:2;51713:7;51699:26;;;;;;;;;;;;:9;:26::i;:::-;51623:110;;:::o;50933:348::-;51026:4;51051:16;51059:7;51051;:16::i;:::-;51043:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;51127:13;51143:23;51158:7;51143:14;:23::i;:::-;51127:39;;51196:5;51185:16;;:7;:16;;;:52;;;;51205:32;51222:5;51229:7;51205:16;:32::i;:::-;51185:52;:87;;;;51265:7;51241:31;;:20;51253:7;51241:11;:20::i;:::-;:31;;;51185:87;51177:96;;;50933:348;;;;:::o;54042:625::-;54201:4;54174:31;;:23;54189:7;54174:14;:23::i;:::-;:31;;;54166:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;54280:1;54266:16;;:2;:16;;;;54258:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;54336:39;54357:4;54363:2;54367:7;54336:20;:39::i;:::-;54440:29;54457:1;54461:7;54440:8;:29::i;:::-;54501:1;54482:9;:15;54492:4;54482:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;54530:1;54513:9;:13;54523:2;54513:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;54561:2;54542:7;:16;54550:7;54542:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;54600:7;54596:2;54581:27;;54590:4;54581:27;;;;;;;;;;;;54621:38;54641:4;54647:2;54651:7;54621:19;:38::i;:::-;54042:625;;;:::o;12061:191::-;12135:16;12154:6;;;;;;;;;;;12135:25;;12180:8;12171:6;;:17;;;;;;;;;;;;;;;;;;12235:8;12204:40;;12225:8;12204:40;;;;;;;;;;;;12124:128;12061:191;:::o;55101:315::-;55256:8;55247:17;;:5;:17;;;;55239:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;55343:8;55305:18;:25;55324:5;55305:25;;;;;;;;;;;;;;;:35;55331:8;55305:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;55389:8;55367:41;;55382:5;55367:41;;;55399:8;55367:41;;;;;;:::i;:::-;;;;;;;;55101:315;;;:::o;50011:::-;50168:28;50178:4;50184:2;50188:7;50168:9;:28::i;:::-;50215:48;50238:4;50244:2;50248:7;50257:5;50215:22;:48::i;:::-;50207:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;50011:315;;;;:::o;7077:723::-;7133:13;7363:1;7354:5;:10;7350:53;;;7381:10;;;;;;;;;;;;;;;;;;;;;7350:53;7413:12;7428:5;7413:20;;7444:14;7469:78;7484:1;7476:4;:9;7469:78;;7502:8;;;;;:::i;:::-;;;;7533:2;7525:10;;;;;:::i;:::-;;;7469:78;;;7557:19;7589:6;7579:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7557:39;;7607:154;7623:1;7614:5;:10;7607:154;;7651:1;7641:11;;;;;:::i;:::-;;;7718:2;7710:5;:10;;;;:::i;:::-;7697:2;:24;;;;:::i;:::-;7684:39;;7667:6;7674;7667:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;7747:2;7738:11;;;;;:::i;:::-;;;7607:154;;;7785:6;7771:21;;;;;7077:723;;;;:::o;44880:305::-;44982:4;45034:25;45019:40;;;:11;:40;;;;:105;;;;45091:33;45076:48;;;:11;:48;;;;45019:105;:158;;;;45141:36;45165:11;45141:23;:36::i;:::-;45019:158;44999:178;;44880:305;;;:::o;51960:321::-;52090:18;52096:2;52100:7;52090:5;:18::i;:::-;52141:54;52172:1;52176:2;52180:7;52189:5;52141:22;:54::i;:::-;52119:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;51960:321;;;:::o;67528:204::-;67679:45;67706:4;67712:2;67716:7;67679:26;:45::i;:::-;67528:204;;;:::o;57863:125::-;;;;:::o;55981:799::-;56136:4;56157:15;:2;:13;;;:15::i;:::-;56153:620;;;56209:2;56193:36;;;56230:12;:10;:12::i;:::-;56244:4;56250:7;56259:5;56193:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;56189:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56452:1;56435:6;:13;:18;56431:272;;;56478:60;;;;;;;;;;:::i;:::-;;;;;;;;56431:272;56653:6;56647:13;56638:6;56634:2;56630:15;56623:38;56189:529;56326:41;;;56316:51;;;:6;:51;;;;56309:58;;;;;56153:620;56757:4;56750:11;;55981:799;;;;;;;:::o;36539:157::-;36624:4;36663:25;36648:40;;;:11;:40;;;;36641:47;;36539:157;;;:::o;52617:439::-;52711:1;52697:16;;:2;:16;;;;52689:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;52770:16;52778:7;52770;:16::i;:::-;52769:17;52761:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;52832:45;52861:1;52865:2;52869:7;52832:20;:45::i;:::-;52907:1;52890:9;:13;52900:2;52890:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;52938:2;52919:7;:16;52927:7;52919:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;52983:7;52979:2;52958:33;;52975:1;52958:33;;;;;;;;;;;;53004:44;53032:1;53036:2;53040:7;53004:19;:44::i;:::-;52617:439;;:::o;60682:589::-;60826:45;60853:4;60859:2;60863:7;60826:26;:45::i;:::-;60904:1;60888:18;;:4;:18;;;60884:187;;;60923:40;60955:7;60923:31;:40::i;:::-;60884:187;;;60993:2;60985:10;;:4;:10;;;60981:90;;61012:47;61045:4;61051:7;61012:32;:47::i;:::-;60981:90;60884:187;61099:1;61085:16;;:2;:16;;;61081:183;;;61118:45;61155:7;61118:36;:45::i;:::-;61081:183;;;61191:4;61185:10;;:2;:10;;;61181:83;;61212:40;61240:2;61244:7;61212:27;:40::i;:::-;61181:83;61081:183;60682:589;;;:::o;26433:326::-;26493:4;26750:1;26728:7;:19;;;:23;26721:30;;26433:326;;;:::o;57352:126::-;;;;:::o;61994:164::-;62098:10;:17;;;;62071:15;:24;62087:7;62071:24;;;;;;;;;;;:44;;;;62126:10;62142:7;62126:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61994:164;:::o;62785:988::-;63051:22;63101:1;63076:22;63093:4;63076:16;:22::i;:::-;:26;;;;:::i;:::-;63051:51;;63113:18;63134:17;:26;63152:7;63134:26;;;;;;;;;;;;63113:47;;63281:14;63267:10;:28;63263:328;;63312:19;63334:12;:18;63347:4;63334:18;;;;;;;;;;;;;;;:34;63353:14;63334:34;;;;;;;;;;;;63312:56;;63418:11;63385:12;:18;63398:4;63385:18;;;;;;;;;;;;;;;:30;63404:10;63385:30;;;;;;;;;;;:44;;;;63535:10;63502:17;:30;63520:11;63502:30;;;;;;;;;;;:43;;;;63297:294;63263:328;63687:17;:26;63705:7;63687:26;;;;;;;;;;;63680:33;;;63731:12;:18;63744:4;63731:18;;;;;;;;;;;;;;;:34;63750:14;63731:34;;;;;;;;;;;63724:41;;;62866:907;;62785:988;;:::o;64068:1079::-;64321:22;64366:1;64346:10;:17;;;;:21;;;;:::i;:::-;64321:46;;64378:18;64399:15;:24;64415:7;64399:24;;;;;;;;;;;;64378:45;;64750:19;64772:10;64783:14;64772:26;;;;;;;;:::i;:::-;;;;;;;;;;64750:48;;64836:11;64811:10;64822;64811:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;64947:10;64916:15;:28;64932:11;64916:28;;;;;;;;;;;:41;;;;65088:15;:24;65104:7;65088:24;;;;;;;;;;;65081:31;;;65123:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64139:1008;;;64068:1079;:::o;61572:221::-;61657:14;61674:20;61691:2;61674:16;:20::i;:::-;61657:37;;61732:7;61705:12;:16;61718:2;61705:16;;;;;;;;;;;;;;;:24;61722:6;61705:24;;;;;;;;;;;:34;;;;61779:6;61750:17;:26;61768:7;61750:26;;;;;;;;;;;:35;;;;61646:147;61572:221;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410: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:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:412::-;501:5;526:66;542:49;584:6;542:49;:::i;:::-;526:66;:::i;:::-;517:75;;615:6;608:5;601:21;653:4;646:5;642:16;691:3;682:6;677:3;673:16;670:25;667:112;;;698:79;;:::i;:::-;667:112;788:41;822:6;817:3;812;788:41;:::i;:::-;507:328;423:412;;;;;:::o;841:139::-;887:5;925:6;912:20;903:29;;941:33;968:5;941:33;:::i;:::-;841:139;;;;:::o;986:133::-;1029:5;1067:6;1054:20;1045:29;;1083:30;1107:5;1083:30;:::i;:::-;986:133;;;;:::o;1125:137::-;1179:5;1210:6;1204:13;1195:22;;1226:30;1250:5;1226:30;:::i;:::-;1125:137;;;;:::o;1268:::-;1313:5;1351:6;1338:20;1329:29;;1367:32;1393:5;1367:32;:::i;:::-;1268:137;;;;:::o;1411:141::-;1467:5;1498:6;1492:13;1483:22;;1514:32;1540:5;1514:32;:::i;:::-;1411:141;;;;:::o;1571:338::-;1626:5;1675:3;1668:4;1660:6;1656:17;1652:27;1642:122;;1683:79;;:::i;:::-;1642:122;1800:6;1787:20;1825:78;1899:3;1891:6;1884:4;1876:6;1872:17;1825:78;:::i;:::-;1816:87;;1632:277;1571:338;;;;:::o;1929:340::-;1985:5;2034:3;2027:4;2019:6;2015:17;2011:27;2001:122;;2042:79;;:::i;:::-;2001:122;2159:6;2146:20;2184:79;2259:3;2251:6;2244:4;2236:6;2232:17;2184:79;:::i;:::-;2175:88;;1991:278;1929:340;;;;:::o;2275:139::-;2321:5;2359:6;2346:20;2337:29;;2375:33;2402:5;2375:33;:::i;:::-;2275:139;;;;:::o;2420:143::-;2477:5;2508:6;2502:13;2493:22;;2524:33;2551:5;2524:33;:::i;:::-;2420:143;;;;:::o;2569:329::-;2628:6;2677:2;2665:9;2656:7;2652:23;2648:32;2645:119;;;2683:79;;:::i;:::-;2645:119;2803:1;2828:53;2873:7;2864:6;2853:9;2849:22;2828:53;:::i;:::-;2818:63;;2774:117;2569:329;;;;:::o;2904:474::-;2972:6;2980;3029:2;3017:9;3008:7;3004:23;3000:32;2997:119;;;3035:79;;:::i;:::-;2997:119;3155:1;3180:53;3225:7;3216:6;3205:9;3201:22;3180:53;:::i;:::-;3170:63;;3126:117;3282:2;3308:53;3353:7;3344:6;3333:9;3329:22;3308:53;:::i;:::-;3298:63;;3253:118;2904:474;;;;;:::o;3384:619::-;3461:6;3469;3477;3526:2;3514:9;3505:7;3501:23;3497:32;3494:119;;;3532:79;;:::i;:::-;3494:119;3652:1;3677:53;3722:7;3713:6;3702:9;3698:22;3677:53;:::i;:::-;3667:63;;3623:117;3779:2;3805:53;3850:7;3841:6;3830:9;3826:22;3805:53;:::i;:::-;3795:63;;3750:118;3907:2;3933:53;3978:7;3969:6;3958:9;3954:22;3933:53;:::i;:::-;3923:63;;3878:118;3384:619;;;;;:::o;4009:943::-;4104:6;4112;4120;4128;4177:3;4165:9;4156:7;4152:23;4148:33;4145:120;;;4184:79;;:::i;:::-;4145:120;4304:1;4329:53;4374:7;4365:6;4354:9;4350:22;4329:53;:::i;:::-;4319:63;;4275:117;4431:2;4457:53;4502:7;4493:6;4482:9;4478:22;4457:53;:::i;:::-;4447:63;;4402:118;4559:2;4585:53;4630:7;4621:6;4610:9;4606:22;4585:53;:::i;:::-;4575:63;;4530:118;4715:2;4704:9;4700:18;4687:32;4746:18;4738:6;4735:30;4732:117;;;4768:79;;:::i;:::-;4732:117;4873:62;4927:7;4918:6;4907:9;4903:22;4873:62;:::i;:::-;4863:72;;4658:287;4009:943;;;;;;;:::o;4958:468::-;5023:6;5031;5080:2;5068:9;5059:7;5055:23;5051:32;5048:119;;;5086:79;;:::i;:::-;5048:119;5206:1;5231:53;5276:7;5267:6;5256:9;5252:22;5231:53;:::i;:::-;5221:63;;5177:117;5333:2;5359:50;5401:7;5392:6;5381:9;5377:22;5359:50;:::i;:::-;5349:60;;5304:115;4958:468;;;;;:::o;5432:474::-;5500:6;5508;5557:2;5545:9;5536:7;5532:23;5528:32;5525:119;;;5563:79;;:::i;:::-;5525:119;5683:1;5708:53;5753:7;5744:6;5733:9;5729:22;5708:53;:::i;:::-;5698:63;;5654:117;5810:2;5836:53;5881:7;5872:6;5861:9;5857:22;5836:53;:::i;:::-;5826:63;;5781:118;5432:474;;;;;:::o;5912:345::-;5979:6;6028:2;6016:9;6007:7;6003:23;5999:32;5996:119;;;6034:79;;:::i;:::-;5996:119;6154:1;6179:61;6232:7;6223:6;6212:9;6208:22;6179:61;:::i;:::-;6169:71;;6125:125;5912:345;;;;:::o;6263:327::-;6321:6;6370:2;6358:9;6349:7;6345:23;6341:32;6338:119;;;6376:79;;:::i;:::-;6338:119;6496:1;6521:52;6565:7;6556:6;6545:9;6541:22;6521:52;:::i;:::-;6511:62;;6467:116;6263:327;;;;:::o;6596:349::-;6665:6;6714:2;6702:9;6693:7;6689:23;6685:32;6682:119;;;6720:79;;:::i;:::-;6682:119;6840:1;6865:63;6920:7;6911:6;6900:9;6896:22;6865:63;:::i;:::-;6855:73;;6811:127;6596:349;;;;:::o;6951:509::-;7020:6;7069:2;7057:9;7048:7;7044:23;7040:32;7037:119;;;7075:79;;:::i;:::-;7037:119;7223:1;7212:9;7208:17;7195:31;7253:18;7245:6;7242:30;7239:117;;;7275:79;;:::i;:::-;7239:117;7380:63;7435:7;7426:6;7415:9;7411:22;7380:63;:::i;:::-;7370:73;;7166:287;6951:509;;;;:::o;7466:329::-;7525:6;7574:2;7562:9;7553:7;7549:23;7545:32;7542:119;;;7580:79;;:::i;:::-;7542:119;7700:1;7725:53;7770:7;7761:6;7750:9;7746:22;7725:53;:::i;:::-;7715:63;;7671:117;7466:329;;;;:::o;7801:351::-;7871:6;7920:2;7908:9;7899:7;7895:23;7891:32;7888:119;;;7926:79;;:::i;:::-;7888:119;8046:1;8071:64;8127:7;8118:6;8107:9;8103:22;8071:64;:::i;:::-;8061:74;;8017:128;7801:351;;;;:::o;8158:118::-;8245:24;8263:5;8245:24;:::i;:::-;8240:3;8233:37;8158:118;;:::o;8282:109::-;8363:21;8378:5;8363:21;:::i;:::-;8358:3;8351:34;8282:109;;:::o;8397:360::-;8483:3;8511:38;8543:5;8511:38;:::i;:::-;8565:70;8628:6;8623:3;8565:70;:::i;:::-;8558:77;;8644:52;8689:6;8684:3;8677:4;8670:5;8666:16;8644:52;:::i;:::-;8721:29;8743:6;8721:29;:::i;:::-;8716:3;8712:39;8705:46;;8487:270;8397:360;;;;:::o;8763:364::-;8851:3;8879:39;8912:5;8879:39;:::i;:::-;8934:71;8998:6;8993:3;8934:71;:::i;:::-;8927:78;;9014:52;9059:6;9054:3;9047:4;9040:5;9036:16;9014:52;:::i;:::-;9091:29;9113:6;9091:29;:::i;:::-;9086:3;9082:39;9075:46;;8855:272;8763:364;;;;:::o;9133:377::-;9239:3;9267:39;9300:5;9267:39;:::i;:::-;9322:89;9404:6;9399:3;9322:89;:::i;:::-;9315:96;;9420:52;9465:6;9460:3;9453:4;9446:5;9442:16;9420:52;:::i;:::-;9497:6;9492:3;9488:16;9481:23;;9243:267;9133:377;;;;:::o;9540:845::-;9643:3;9680:5;9674:12;9709:36;9735:9;9709:36;:::i;:::-;9761:89;9843:6;9838:3;9761:89;:::i;:::-;9754:96;;9881:1;9870:9;9866:17;9897:1;9892:137;;;;10043:1;10038:341;;;;9859:520;;9892:137;9976:4;9972:9;9961;9957:25;9952:3;9945:38;10012:6;10007:3;10003:16;9996:23;;9892:137;;10038:341;10105:38;10137:5;10105:38;:::i;:::-;10165:1;10179:154;10193:6;10190:1;10187:13;10179:154;;;10267:7;10261:14;10257:1;10252:3;10248:11;10241:35;10317:1;10308:7;10304:15;10293:26;;10215:4;10212:1;10208:12;10203:17;;10179:154;;;10362:6;10357:3;10353:16;10346:23;;10045:334;;9859:520;;9647:738;;9540:845;;;;:::o;10391:366::-;10533:3;10554:67;10618:2;10613:3;10554:67;:::i;:::-;10547:74;;10630:93;10719:3;10630:93;:::i;:::-;10748:2;10743:3;10739:12;10732:19;;10391:366;;;:::o;10763:::-;10905:3;10926:67;10990:2;10985:3;10926:67;:::i;:::-;10919:74;;11002:93;11091:3;11002:93;:::i;:::-;11120:2;11115:3;11111:12;11104:19;;10763:366;;;:::o;11135:::-;11277:3;11298:67;11362:2;11357:3;11298:67;:::i;:::-;11291:74;;11374:93;11463:3;11374:93;:::i;:::-;11492:2;11487:3;11483:12;11476:19;;11135:366;;;:::o;11507:::-;11649:3;11670:67;11734:2;11729:3;11670:67;:::i;:::-;11663:74;;11746:93;11835:3;11746:93;:::i;:::-;11864:2;11859:3;11855:12;11848:19;;11507:366;;;:::o;11879:::-;12021:3;12042:67;12106:2;12101:3;12042:67;:::i;:::-;12035:74;;12118:93;12207:3;12118:93;:::i;:::-;12236:2;12231:3;12227:12;12220:19;;11879:366;;;:::o;12251:::-;12393:3;12414:67;12478:2;12473:3;12414:67;:::i;:::-;12407:74;;12490:93;12579:3;12490:93;:::i;:::-;12608:2;12603:3;12599:12;12592:19;;12251:366;;;:::o;12623:::-;12765:3;12786:67;12850:2;12845:3;12786:67;:::i;:::-;12779:74;;12862:93;12951:3;12862:93;:::i;:::-;12980:2;12975:3;12971:12;12964:19;;12623:366;;;:::o;12995:::-;13137:3;13158:67;13222:2;13217:3;13158:67;:::i;:::-;13151:74;;13234:93;13323:3;13234:93;:::i;:::-;13352:2;13347:3;13343:12;13336:19;;12995:366;;;:::o;13367:::-;13509:3;13530:67;13594:2;13589:3;13530:67;:::i;:::-;13523:74;;13606:93;13695:3;13606:93;:::i;:::-;13724:2;13719:3;13715:12;13708:19;;13367:366;;;:::o;13739:::-;13881:3;13902:67;13966:2;13961:3;13902:67;:::i;:::-;13895:74;;13978:93;14067:3;13978:93;:::i;:::-;14096:2;14091:3;14087:12;14080:19;;13739:366;;;:::o;14111:::-;14253:3;14274:67;14338:2;14333:3;14274:67;:::i;:::-;14267:74;;14350:93;14439:3;14350:93;:::i;:::-;14468:2;14463:3;14459:12;14452:19;;14111:366;;;:::o;14483:::-;14625:3;14646:67;14710:2;14705:3;14646:67;:::i;:::-;14639:74;;14722:93;14811:3;14722:93;:::i;:::-;14840:2;14835:3;14831:12;14824:19;;14483:366;;;:::o;14855:::-;14997:3;15018:67;15082:2;15077:3;15018:67;:::i;:::-;15011:74;;15094:93;15183:3;15094:93;:::i;:::-;15212:2;15207:3;15203:12;15196:19;;14855:366;;;:::o;15227:::-;15369:3;15390:67;15454:2;15449:3;15390:67;:::i;:::-;15383:74;;15466:93;15555:3;15466:93;:::i;:::-;15584:2;15579:3;15575:12;15568:19;;15227:366;;;:::o;15599:::-;15741:3;15762:67;15826:2;15821:3;15762:67;:::i;:::-;15755:74;;15838:93;15927:3;15838:93;:::i;:::-;15956:2;15951:3;15947:12;15940:19;;15599:366;;;:::o;15971:::-;16113:3;16134:67;16198:2;16193:3;16134:67;:::i;:::-;16127:74;;16210:93;16299:3;16210:93;:::i;:::-;16328:2;16323:3;16319:12;16312:19;;15971:366;;;:::o;16343:::-;16485:3;16506:67;16570:2;16565:3;16506:67;:::i;:::-;16499:74;;16582:93;16671:3;16582:93;:::i;:::-;16700:2;16695:3;16691:12;16684:19;;16343:366;;;:::o;16715:::-;16857:3;16878:67;16942:2;16937:3;16878:67;:::i;:::-;16871:74;;16954:93;17043:3;16954:93;:::i;:::-;17072:2;17067:3;17063:12;17056:19;;16715:366;;;:::o;17087:::-;17229:3;17250:67;17314:2;17309:3;17250:67;:::i;:::-;17243:74;;17326:93;17415:3;17326:93;:::i;:::-;17444:2;17439:3;17435:12;17428:19;;17087:366;;;:::o;17459:118::-;17546:24;17564:5;17546:24;:::i;:::-;17541:3;17534:37;17459:118;;:::o;17583:583::-;17805:3;17827:92;17915:3;17906:6;17827:92;:::i;:::-;17820:99;;17936:95;18027:3;18018:6;17936:95;:::i;:::-;17929:102;;18048:92;18136:3;18127:6;18048:92;:::i;:::-;18041:99;;18157:3;18150:10;;17583:583;;;;;;:::o;18172:222::-;18265:4;18303:2;18292:9;18288:18;18280:26;;18316:71;18384:1;18373:9;18369:17;18360:6;18316:71;:::i;:::-;18172:222;;;;:::o;18400:332::-;18521:4;18559:2;18548:9;18544:18;18536:26;;18572:71;18640:1;18629:9;18625:17;18616:6;18572:71;:::i;:::-;18653:72;18721:2;18710:9;18706:18;18697:6;18653:72;:::i;:::-;18400:332;;;;;:::o;18738:442::-;18887:4;18925:2;18914:9;18910:18;18902:26;;18938:71;19006:1;18995:9;18991:17;18982:6;18938:71;:::i;:::-;19019:72;19087:2;19076:9;19072:18;19063:6;19019:72;:::i;:::-;19101;19169:2;19158:9;19154:18;19145:6;19101:72;:::i;:::-;18738:442;;;;;;:::o;19186:640::-;19381:4;19419:3;19408:9;19404:19;19396:27;;19433:71;19501:1;19490:9;19486:17;19477:6;19433:71;:::i;:::-;19514:72;19582:2;19571:9;19567:18;19558:6;19514:72;:::i;:::-;19596;19664:2;19653:9;19649:18;19640:6;19596:72;:::i;:::-;19715:9;19709:4;19705:20;19700:2;19689:9;19685:18;19678:48;19743:76;19814:4;19805:6;19743:76;:::i;:::-;19735:84;;19186:640;;;;;;;:::o;19832:210::-;19919:4;19957:2;19946:9;19942:18;19934:26;;19970:65;20032:1;20021:9;20017:17;20008:6;19970:65;:::i;:::-;19832:210;;;;:::o;20048:313::-;20161:4;20199:2;20188:9;20184:18;20176:26;;20248:9;20242:4;20238:20;20234:1;20223:9;20219:17;20212:47;20276:78;20349:4;20340:6;20276:78;:::i;:::-;20268:86;;20048:313;;;;:::o;20367:419::-;20533:4;20571:2;20560:9;20556:18;20548:26;;20620:9;20614:4;20610:20;20606:1;20595:9;20591:17;20584:47;20648:131;20774:4;20648:131;:::i;:::-;20640:139;;20367:419;;;:::o;20792:::-;20958:4;20996:2;20985:9;20981:18;20973:26;;21045:9;21039:4;21035:20;21031:1;21020:9;21016:17;21009:47;21073:131;21199:4;21073:131;:::i;:::-;21065:139;;20792:419;;;:::o;21217:::-;21383:4;21421:2;21410:9;21406:18;21398:26;;21470:9;21464:4;21460:20;21456:1;21445:9;21441:17;21434:47;21498:131;21624:4;21498:131;:::i;:::-;21490:139;;21217:419;;;:::o;21642:::-;21808:4;21846:2;21835:9;21831:18;21823:26;;21895:9;21889:4;21885:20;21881:1;21870:9;21866:17;21859:47;21923:131;22049:4;21923:131;:::i;:::-;21915:139;;21642:419;;;:::o;22067:::-;22233:4;22271:2;22260:9;22256:18;22248:26;;22320:9;22314:4;22310:20;22306:1;22295:9;22291:17;22284:47;22348:131;22474:4;22348:131;:::i;:::-;22340:139;;22067:419;;;:::o;22492:::-;22658:4;22696:2;22685:9;22681:18;22673:26;;22745:9;22739:4;22735:20;22731:1;22720:9;22716:17;22709:47;22773:131;22899:4;22773:131;:::i;:::-;22765:139;;22492:419;;;:::o;22917:::-;23083:4;23121:2;23110:9;23106:18;23098:26;;23170:9;23164:4;23160:20;23156:1;23145:9;23141:17;23134:47;23198:131;23324:4;23198:131;:::i;:::-;23190:139;;22917:419;;;:::o;23342:::-;23508:4;23546:2;23535:9;23531:18;23523:26;;23595:9;23589:4;23585:20;23581:1;23570:9;23566:17;23559:47;23623:131;23749:4;23623:131;:::i;:::-;23615:139;;23342:419;;;:::o;23767:::-;23933:4;23971:2;23960:9;23956:18;23948:26;;24020:9;24014:4;24010:20;24006:1;23995:9;23991:17;23984:47;24048:131;24174:4;24048:131;:::i;:::-;24040:139;;23767:419;;;:::o;24192:::-;24358:4;24396:2;24385:9;24381:18;24373:26;;24445:9;24439:4;24435:20;24431:1;24420:9;24416:17;24409:47;24473:131;24599:4;24473:131;:::i;:::-;24465:139;;24192:419;;;:::o;24617:::-;24783:4;24821:2;24810:9;24806:18;24798:26;;24870:9;24864:4;24860:20;24856:1;24845:9;24841:17;24834:47;24898:131;25024:4;24898:131;:::i;:::-;24890:139;;24617:419;;;:::o;25042:::-;25208:4;25246:2;25235:9;25231:18;25223:26;;25295:9;25289:4;25285:20;25281:1;25270:9;25266:17;25259:47;25323:131;25449:4;25323:131;:::i;:::-;25315:139;;25042:419;;;:::o;25467:::-;25633:4;25671:2;25660:9;25656:18;25648:26;;25720:9;25714:4;25710:20;25706:1;25695:9;25691:17;25684:47;25748:131;25874:4;25748:131;:::i;:::-;25740:139;;25467:419;;;:::o;25892:::-;26058:4;26096:2;26085:9;26081:18;26073:26;;26145:9;26139:4;26135:20;26131:1;26120:9;26116:17;26109:47;26173:131;26299:4;26173:131;:::i;:::-;26165:139;;25892:419;;;:::o;26317:::-;26483:4;26521:2;26510:9;26506:18;26498:26;;26570:9;26564:4;26560:20;26556:1;26545:9;26541:17;26534:47;26598:131;26724:4;26598:131;:::i;:::-;26590:139;;26317:419;;;:::o;26742:::-;26908:4;26946:2;26935:9;26931:18;26923:26;;26995:9;26989:4;26985:20;26981:1;26970:9;26966:17;26959:47;27023:131;27149:4;27023:131;:::i;:::-;27015:139;;26742:419;;;:::o;27167:::-;27333:4;27371:2;27360:9;27356:18;27348:26;;27420:9;27414:4;27410:20;27406:1;27395:9;27391:17;27384:47;27448:131;27574:4;27448:131;:::i;:::-;27440:139;;27167:419;;;:::o;27592:::-;27758:4;27796:2;27785:9;27781:18;27773:26;;27845:9;27839:4;27835:20;27831:1;27820:9;27816:17;27809:47;27873:131;27999:4;27873:131;:::i;:::-;27865:139;;27592:419;;;:::o;28017:::-;28183:4;28221:2;28210:9;28206:18;28198:26;;28270:9;28264:4;28260:20;28256:1;28245:9;28241:17;28234:47;28298:131;28424:4;28298:131;:::i;:::-;28290:139;;28017:419;;;:::o;28442:222::-;28535:4;28573:2;28562:9;28558:18;28550:26;;28586:71;28654:1;28643:9;28639:17;28630:6;28586:71;:::i;:::-;28442:222;;;;:::o;28670:129::-;28704:6;28731:20;;:::i;:::-;28721:30;;28760:33;28788:4;28780:6;28760:33;:::i;:::-;28670:129;;;:::o;28805:75::-;28838:6;28871:2;28865:9;28855:19;;28805:75;:::o;28886:307::-;28947:4;29037:18;29029:6;29026:30;29023:56;;;29059:18;;:::i;:::-;29023:56;29097:29;29119:6;29097:29;:::i;:::-;29089:37;;29181:4;29175;29171:15;29163:23;;28886:307;;;:::o;29199:308::-;29261:4;29351:18;29343:6;29340:30;29337:56;;;29373:18;;:::i;:::-;29337:56;29411:29;29433:6;29411:29;:::i;:::-;29403:37;;29495:4;29489;29485:15;29477:23;;29199:308;;;:::o;29513:141::-;29562:4;29585:3;29577:11;;29608:3;29605:1;29598:14;29642:4;29639:1;29629:18;29621:26;;29513:141;;;:::o;29660:98::-;29711:6;29745:5;29739:12;29729:22;;29660:98;;;:::o;29764:99::-;29816:6;29850:5;29844:12;29834:22;;29764:99;;;:::o;29869:168::-;29952:11;29986:6;29981:3;29974:19;30026:4;30021:3;30017:14;30002:29;;29869:168;;;;:::o;30043:169::-;30127:11;30161:6;30156:3;30149:19;30201:4;30196:3;30192:14;30177:29;;30043:169;;;;:::o;30218:148::-;30320:11;30357:3;30342:18;;30218:148;;;;:::o;30372:305::-;30412:3;30431:20;30449:1;30431:20;:::i;:::-;30426:25;;30465:20;30483:1;30465:20;:::i;:::-;30460:25;;30619:1;30551:66;30547:74;30544:1;30541:81;30538:107;;;30625:18;;:::i;:::-;30538:107;30669:1;30666;30662:9;30655:16;;30372:305;;;;:::o;30683:185::-;30723:1;30740:20;30758:1;30740:20;:::i;:::-;30735:25;;30774:20;30792:1;30774:20;:::i;:::-;30769:25;;30813:1;30803:35;;30818:18;;:::i;:::-;30803:35;30860:1;30857;30853:9;30848:14;;30683:185;;;;:::o;30874:348::-;30914:7;30937:20;30955:1;30937:20;:::i;:::-;30932:25;;30971:20;30989:1;30971:20;:::i;:::-;30966:25;;31159:1;31091:66;31087:74;31084:1;31081:81;31076:1;31069:9;31062:17;31058:105;31055:131;;;31166:18;;:::i;:::-;31055:131;31214:1;31211;31207:9;31196:20;;30874:348;;;;:::o;31228:191::-;31268:4;31288:20;31306:1;31288:20;:::i;:::-;31283:25;;31322:20;31340:1;31322:20;:::i;:::-;31317:25;;31361:1;31358;31355:8;31352:34;;;31366:18;;:::i;:::-;31352:34;31411:1;31408;31404:9;31396:17;;31228:191;;;;:::o;31425:96::-;31462:7;31491:24;31509:5;31491:24;:::i;:::-;31480:35;;31425:96;;;:::o;31527:90::-;31561:7;31604:5;31597:13;31590:21;31579:32;;31527:90;;;:::o;31623:149::-;31659:7;31699:66;31692:5;31688:78;31677:89;;31623:149;;;:::o;31778:126::-;31815:7;31855:42;31848:5;31844:54;31833:65;;31778:126;;;:::o;31910:77::-;31947:7;31976:5;31965:16;;31910:77;;;:::o;31993:154::-;32077:6;32072:3;32067;32054:30;32139:1;32130:6;32125:3;32121:16;32114:27;31993:154;;;:::o;32153:307::-;32221:1;32231:113;32245:6;32242:1;32239:13;32231:113;;;32330:1;32325:3;32321:11;32315:18;32311:1;32306:3;32302:11;32295:39;32267:2;32264:1;32260:10;32255:15;;32231:113;;;32362:6;32359:1;32356:13;32353:101;;;32442:1;32433:6;32428:3;32424:16;32417:27;32353:101;32202:258;32153:307;;;:::o;32466:320::-;32510:6;32547:1;32541:4;32537:12;32527:22;;32594:1;32588:4;32584:12;32615:18;32605:81;;32671:4;32663:6;32659:17;32649:27;;32605:81;32733:2;32725:6;32722:14;32702:18;32699:38;32696:84;;;32752:18;;:::i;:::-;32696:84;32517:269;32466:320;;;:::o;32792:281::-;32875:27;32897:4;32875:27;:::i;:::-;32867:6;32863:40;33005:6;32993:10;32990:22;32969:18;32957:10;32954:34;32951:62;32948:88;;;33016:18;;:::i;:::-;32948:88;33056:10;33052:2;33045:22;32835:238;32792:281;;:::o;33079:233::-;33118:3;33141:24;33159:5;33141:24;:::i;:::-;33132:33;;33187:66;33180:5;33177:77;33174:103;;;33257:18;;:::i;:::-;33174:103;33304:1;33297:5;33293:13;33286:20;;33079:233;;;:::o;33318:176::-;33350:1;33367:20;33385:1;33367:20;:::i;:::-;33362:25;;33401:20;33419:1;33401:20;:::i;:::-;33396:25;;33440:1;33430:35;;33445:18;;:::i;:::-;33430:35;33486:1;33483;33479:9;33474:14;;33318:176;;;;:::o;33500:180::-;33548:77;33545:1;33538:88;33645:4;33642:1;33635:15;33669:4;33666:1;33659:15;33686:180;33734:77;33731:1;33724:88;33831:4;33828:1;33821:15;33855:4;33852:1;33845:15;33872:180;33920:77;33917:1;33910:88;34017:4;34014:1;34007:15;34041:4;34038:1;34031:15;34058:180;34106:77;34103:1;34096:88;34203:4;34200:1;34193:15;34227:4;34224:1;34217:15;34244:180;34292:77;34289:1;34282:88;34389:4;34386:1;34379:15;34413:4;34410:1;34403:15;34430:180;34478:77;34475:1;34468:88;34575:4;34572:1;34565:15;34599:4;34596:1;34589:15;34616:117;34725:1;34722;34715:12;34739:117;34848:1;34845;34838:12;34862:117;34971:1;34968;34961:12;34985:117;35094:1;35091;35084:12;35108:102;35149:6;35200:2;35196:7;35191:2;35184:5;35180:14;35176:28;35166:38;;35108:102;;;:::o;35216:224::-;35356:34;35352:1;35344:6;35340:14;35333:58;35425:7;35420:2;35412:6;35408:15;35401:32;35216:224;:::o;35446:230::-;35586:34;35582:1;35574:6;35570:14;35563:58;35655:13;35650:2;35642:6;35638:15;35631:38;35446:230;:::o;35682:237::-;35822:34;35818:1;35810:6;35806:14;35799:58;35891:20;35886:2;35878:6;35874:15;35867:45;35682:237;:::o;35925:225::-;36065:34;36061:1;36053:6;36049:14;36042:58;36134:8;36129:2;36121:6;36117:15;36110:33;35925:225;:::o;36156:224::-;36296:34;36292:1;36284:6;36280:14;36273:58;36365:7;36360:2;36352:6;36348:15;36341:32;36156:224;:::o;36386:178::-;36526:30;36522:1;36514:6;36510:14;36503:54;36386:178;:::o;36570:223::-;36710:34;36706:1;36698:6;36694:14;36687:58;36779:6;36774:2;36766:6;36762:15;36755:31;36570:223;:::o;36799:175::-;36939:27;36935:1;36927:6;36923:14;36916:51;36799:175;:::o;36980:231::-;37120:34;37116:1;37108:6;37104:14;37097:58;37189:14;37184:2;37176:6;37172:15;37165:39;36980:231;:::o;37217:243::-;37357:34;37353:1;37345:6;37341:14;37334:58;37426:26;37421:2;37413:6;37409:15;37402:51;37217:243;:::o;37466:229::-;37606:34;37602:1;37594:6;37590:14;37583:58;37675:12;37670:2;37662:6;37658:15;37651:37;37466:229;:::o;37701:228::-;37841:34;37837:1;37829:6;37825:14;37818:58;37910:11;37905:2;37897:6;37893:15;37886:36;37701:228;:::o;37935:182::-;38075:34;38071:1;38063:6;38059:14;38052:58;37935:182;:::o;38123:231::-;38263:34;38259:1;38251:6;38247:14;38240:58;38332:14;38327:2;38319:6;38315:15;38308:39;38123:231;:::o;38360:182::-;38500:34;38496:1;38488:6;38484:14;38477:58;38360:182;:::o;38548:220::-;38688:34;38684:1;38676:6;38672:14;38665:58;38757:3;38752:2;38744:6;38740:15;38733:28;38548:220;:::o;38774:236::-;38914:34;38910:1;38902:6;38898:14;38891:58;38983:19;38978:2;38970:6;38966:15;38959:44;38774:236;:::o;39016:168::-;39156:20;39152:1;39144:6;39140:14;39133:44;39016:168;:::o;39190:231::-;39330:34;39326:1;39318:6;39314:14;39307:58;39399:14;39394:2;39386:6;39382:15;39375:39;39190:231;:::o;39427:122::-;39500:24;39518:5;39500:24;:::i;:::-;39493:5;39490:35;39480:63;;39539:1;39536;39529:12;39480:63;39427:122;:::o;39555:116::-;39625:21;39640:5;39625:21;:::i;:::-;39618:5;39615:32;39605:60;;39661:1;39658;39651:12;39605:60;39555:116;:::o;39677:120::-;39749:23;39766:5;39749:23;:::i;:::-;39742:5;39739:34;39729:62;;39787:1;39784;39777:12;39729:62;39677:120;:::o;39803:122::-;39876:24;39894:5;39876:24;:::i;:::-;39869:5;39866:35;39856:63;;39915:1;39912;39905:12;39856:63;39803:122;:::o

Swarm Source

ipfs://3b6fc0ae46c6192ace4237212b64771bac3ca36c93c8d28c272e19a1ed34823e
Loading