Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Counters
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
• library EnumerableMap
•    - function _set(Map storage map, bytes3 ...
•    - function _remove(Map storage map, byt ...
•    - function _contains(Map storage map, b ...
•    - function _length(Map storage map)
•    - function _at(Map storage map, uint256 ...
•    - function _tryGet(Map storage map, byt ...
•    - function _get(Map storage map, bytes3 ...
•    - function _get(Map storage map, bytes3 ...
•    - function set(UintToAddressMap storage ...
•    - function remove(UintToAddressMap stor ...
•    - function contains(UintToAddressMap st ...
•    - function length(UintToAddressMap stor ...
•    - function at(UintToAddressMap storage ...
•    - function tryGet(UintToAddressMap stor ...
•    - function get(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• interface IERC1155 is IERC165
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(address[] cal ...
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function mint(address to, uint256 tok ...
•    - function mint(address to)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
• interface IERC721Receiver
•    - function onERC721Received(address ope ...
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _msgSender()
•    - function _msgData()
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function baseURI()
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _safeTransfer(address from, ...
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(address from, addr ...
•    - function _setTokenURI(uint256 tokenId ...
•    - function _setBaseURI(string memory ba ...
•    - function _checkOnERC721Received(addre ...
•    - function _approve(address to, uint256 ...
•    - function _beforeTokenTransfer(address ...
•  contract Ownable
•    - function getOwner()
•    - function transferOwnership(address _n ...
•    - function mintToCaller(address caller, ...
•    - function setManager(address _newManag ...
•    - function mint(address to, uint256 tok ...
•    - function mint(address to)
• interface INFT
•    - function mintToCaller(address caller, ...
•    - function transferFrom(address _from, ...
•    - function balanceOf(address who)
•    - function allowance(address owner, add ...
•    - function transfer(address to, uint256 ...
•  contract Dropys is Ownable *
•    - function uint2str(uint _i)
•    - function giveChange(uint256 _price)
•    - function setRate(uint256 _newRate)
•    - function setNFTAddress(address _newNF ...
•    - function getTokenAllowance(address _a ...
•    - function stringsAreEqual(string memor ...
•    - function singleValueEthAirdrop(addres ...
•    - function _getTotalEthValue(uint256[] ...
•    - function multiValueEthAirdrop(address ...
•    - function singleValueTokenAirdrop(addr ...
•    - function multiValueTokenAirdrop(addre ...
•    - function distributeCommission(uint256 ...
•    - function withdrawERC20Tokens(address ...
•    - function nftAirdrop(address[] memory ...
•    - function existingNftAirdrop(address[] ...
•    - function existing1155NftAirdrop(addre ...
•    - function existingMintNftAirdrop(addre ...
•    - function existingSimpleMintNftAirdrop ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Counters.sol


pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. 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;
        }
    }
}

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol


pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant alphabet = "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] = alphabet[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

}

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/EnumerableMap.sol


pragma solidity ^0.8.0;


/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;

        mapping (bytes32 => bytes32) _values;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        delete map._values[key];
        return map._keys.remove(key);
    }

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (_contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), "EnumerableMap: nonexistent key");
        return value;
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), errorMessage);
        return value;
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/EnumerableSet.sol


pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol


pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/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: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/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;
    }
}

interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol


pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Mint `tokenId` token to `to`
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must not yet exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     */
    function mint(address to, uint256 tokenId) external;

    /**
     * @dev Mint to `to`
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     */
    function mint(address to) 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721Receiver.sol

pragma solidity ^0.8.0;

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721Enumerable.sol


pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/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: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol


pragma solidity ^0.8.0;

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

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

// File: github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol


pragma solidity ^0.8.0;











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

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

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Base URI
    string private _baseURI;

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

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

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

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

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

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

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

contract Ownable {
    
    address public owner;
    
    event OwnershipTransferred(address indexed from, address indexed to);
    
    
    /**
     * Constructor assigns ownership to the address used to deploy the contract.
     * */
    constructor() {
        owner = msg.sender;
    }


    function getOwner() public view returns(address) {
        return owner;
    }


    /**
     * Any function with this modifier in its method signature can only be executed by
     * the owner of the contract. Any attempt made by any other account to invoke the 
     * functions with this modifier will result in a loss of gas and the contract's state
     * will remain untampered.
     * */
    modifier onlyOwner {
        require(msg.sender == owner, "Function restricted to owner of contract");
        _;
    }

    /**
     * Allows for the transfer of ownership to another address;
     * 
     * @param _newOwner The address to be assigned new ownership.
     * */
    function transferOwnership(address _newOwner) public onlyOwner {
        require(
            _newOwner != address(0)
            && _newOwner != owner 
        );
        emit OwnershipTransferred(owner, _newOwner);
        owner = _newOwner;
    }
}

// File: browser/NFTminter.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

 contract NFT is Context, Ownable, ERC721 {
    
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    address public manager;
    event ManagerChanged(address indexed from, address indexed to);

    constructor() ERC721("Dropys", "Dropys") {}


    function mintToCaller(address caller, string memory tokenURI) 
        public
        returns (uint256)
    {
        require(_msgSender() == manager, "NFT: Only can be called by manager");
        _tokenIds.increment();
        uint256 newItemId = _tokenIds.current();
        _mint(caller, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
    // tokenURI points to a JSON file that conforms to the "ERC721 Metadata JSON Schema".

    function setManager(address _newManager) public onlyOwner returns(bool) {
        emit ManagerChanged(manager, _newManager);
        manager = _newManager;
        return true;
    }

    function mint(address to, uint256 tokenId) external override {}
    function mint(address to) external override {}
}

interface INFT {
    function mintToCaller(address caller, string memory tokenURI)  external returns (uint256);
}


/**
 * Contract acts as an interface between the DappleAirdrops contract and all ERC20 compliant
 * tokens. 
 * */
abstract contract ERCInterface {
    function transferFrom(address _from, address _to, uint256 _value) public virtual;
    function balanceOf(address who)  public virtual returns (uint256);
    function allowance(address owner, address spender)  public view virtual returns (uint256);
    function transfer(address to, uint256 value) public virtual returns(bool);
}



contract Dropys is Ownable {
    using SafeMath for uint256;
         
    uint256 public rate;
    uint256 public dropUnitPrice;
    address public nftAddress;

    event TokenAirdrop(address indexed by, address indexed tokenAddress, uint256 totalTransfers);
    event EthAirdrop(address indexed by, uint256 totalTransfers, uint256 ethValue);
    event NFTAirdrop(address indexed by, address indexed tokenAddress, uint256 totalTransfers);

    event RateChanged(uint256 from, uint256 to);
    event NFTAddressChanged(address indexed from, address indexed to);
    event RefundIssued(address indexed to, uint256 totalWei);
    event ERC20TokensWithdrawn(address token, address sentTo, uint256 value);
    event CommissionPaid(address indexed to, uint256 value);
    event NewAffiliatePartnership(address indexed newAffiliate, string indexed affiliateCode);
    event AffiliatePartnershipRevoked(address indexed affiliate, string indexed affiliateCode);
    
    constructor() {
        rate = 50000000000000000;
        dropUnitPrice = 1e14; 
    }
    
    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len;
        while (_i != 0) {
            k = k-1;
            uint8 temp = (48 + uint8(_i - _i / 10 * 10));
            bytes1 b1 = bytes1(temp);
            bstr[k] = b1;
            _i /= 10;
        }
        return string(bstr);
    }


    /**
    * Used to give change to users who accidentally send too much ETH to payable functions. 
    *
    * @param _price The service fee the user has to pay for function execution. 
    **/
    function giveChange(uint256 _price) internal {
        if(msg.value > _price) {
            uint256 change = msg.value.sub(_price);
            payable(msg.sender).transfer(change);
        }
    }
    
    /**
     * Allows for the price of drops to be changed by the owner of the contract. Any attempt made by 
     * any other account to invoke the function will result in a loss of gas and the price will remain 
     * untampered.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function setRate(uint256 _newRate) public onlyOwner returns(bool) {
        require(
            _newRate != rate 
            && _newRate > 0
        );
        emit RateChanged(rate, _newRate);
        rate = _newRate;
        uint256 eth = 1 ether;
        dropUnitPrice = eth.div(rate);
        return true;
    }
    
     /**
     * Allows for the NFT contract address to be changed by the owner of the contract. Any attempt made by 
     * any other account to invoke the function will result in a loss of gas and the nft address will remain 
     * untampered.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function setNFTAddress(address _newNFTAddress) public onlyOwner returns(bool) {
        emit NFTAddressChanged(nftAddress, _newNFTAddress);
        nftAddress = _newNFTAddress;
        return true;
    } 

    /**
     * Allows for the allowance of a token from its owner to this contract to be queried. 
     * 
     * As part of the ERC20 standard all tokens which fall under this category have an allowance 
     * function which enables owners of tokens to allow (or give permission) to another address 
     * to spend tokens on behalf of the owner. This contract uses this as part of its protocol.
     * Users must first give permission to the contract to transfer tokens on their behalf, however,
     * this does not mean that the tokens will ever be transferrable without the permission of the 
     * owner. This is a security feature which was implemented on this contract. It is not possible
     * for the owner of this contract or anyone else to transfer the tokens which belong to others. 
     * 
     * @param _addr The address of the token's owner.
     * @param _addressOfToken The contract address of the ERC20 token.
     * 
     * @return The ERC20 token allowance from token owner to this contract. 
     * */
    function getTokenAllowance(address _addr, address _addressOfToken) public view returns(uint256) {
        ERCInterface token = ERCInterface(_addressOfToken);
        return token.allowance(_addr, address(this));
    }
    
    
    fallback() external payable {
        revert();
    }


    receive() external payable {
        revert();
    }
    
    
    /**
    * Checks if two strings are the same.
    *
    * @param _a String 1
    * @param _b String 2
    *
    * @return True if both strings are the same. False otherwise. 
    **/
    function stringsAreEqual(string memory _a, string memory _b) internal pure returns(bool) {
        bytes32 hashA = keccak256(abi.encodePacked(_a));
        bytes32 hashB = keccak256(abi.encodePacked(_b));
        return hashA == hashB;
    }
 
    
    /**
     * Allows for the distribution of Ether to be transferred to multiple recipients at 
     * a time. This function only facilitates batch transfers of constant values (i.e., all recipients
     * will receive the same amount of tokens).
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _value The amount of tokens all addresses will receive. 
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function singleValueEthAirdrop(address[] memory _recipients, uint256 _value, address _affiliateAddress) public payable returns(bool) {
        
        uint256 price = _recipients.length.mul(dropUnitPrice);
        uint256 totalCost = _value.mul(_recipients.length).add(price);

        require(
            msg.value >= totalCost,
            "Not enough ETH sent with transaction!"
        );
        
        distributeCommission(_recipients.length, _affiliateAddress);

        giveChange(totalCost);
        
        for(uint i=0; i<_recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                payable(_recipients[i]).transfer(_value);
            }
        }

        emit EthAirdrop(msg.sender, _recipients.length, _value.mul(_recipients.length));
        
        return true;
    }
    

    
    function _getTotalEthValue(uint256[] memory _values) internal pure returns(uint256) {
        uint256 totalVal = 0;
        for(uint i = 0; i < _values.length; i++) {
            totalVal = totalVal.add(_values[i]);
        }
        return totalVal;
    }
    
    
    /**
     * Allows for the distribution of Ether to be transferred to multiple recipients at 
     * a time. 
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _values The corresponding amounts that the recipients will receive 
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function multiValueEthAirdrop(address[] memory _recipients, uint256[] memory _values, address _affiliateAddress) public payable returns(bool) {
        require(_recipients.length == _values.length, "Total number of recipients and values are not equal");

        uint256 totalEthValue = _getTotalEthValue(_values);
        uint256 price = _recipients.length.mul(dropUnitPrice);
        uint256 totalCost = totalEthValue.add(price);

        require(
            msg.value >= totalCost, 
            "Not enough ETH sent with transaction!"
        );
                
        distributeCommission(_recipients.length, _affiliateAddress);

        giveChange(totalCost);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0) && _values[i] > 0) {
                payable(_recipients[i]).transfer(_values[i]);
            }
        }
        
        emit EthAirdrop(msg.sender, _recipients.length, totalEthValue);
        return true;
    }
    
    
    /**
     * Allows for the distribution of an ERC20 token to be transferred to multiple recipients at 
     * a time. This function only facilitates batch transfers of constant values (i.e., all recipients
     * will receive the same amount of tokens).
     * 
     * @param _addressOfToken The contract address of an ERC20 token.
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _value The amount of tokens all addresses will receive. 
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function singleValueTokenAirdrop(address _addressOfToken,  address[] memory _recipients, uint256 _value, address _affiliateAddress) public payable returns(bool) {
        ERCInterface token = ERCInterface(_addressOfToken);

        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                token.transferFrom(msg.sender, _recipients[i], _value);
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);

        emit TokenAirdrop(msg.sender, _addressOfToken, _recipients.length);
        return true;
    }
    
    
    /**
     * Allows for the distribution of an ERC20 token to be transferred to multiple recipients at 
     * a time. This function facilitates batch transfers of differing values (i.e., all recipients
     * can receive different amounts of tokens).
     * 
     * @param _addressOfToken The contract address of an ERC20 token.
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _values The corresponding values of tokens which each address will receive.
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */    
    function multiValueTokenAirdrop(address _addressOfToken,  address[] memory _recipients, uint256[] memory _values, address _affiliateAddress) public payable returns(bool) {
        ERCInterface token = ERCInterface(_addressOfToken);
        require(_recipients.length == _values.length, "Total number of recipients and values are not equal");

        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
                
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0) && _values[i] > 0) {
                token.transferFrom(msg.sender, _recipients[i], _values[i]);
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);

        emit TokenAirdrop(msg.sender, _addressOfToken, _recipients.length);
        return true;
    }
        

    /**
    * Send the owner and affiliates commissions.
    **/
    function distributeCommission(uint256 _drops, address _affiliateAddress) internal {
        if(_affiliateAddress != address(0)) {
            uint256 profitSplit = _drops.mul(dropUnitPrice).div(2);
            payable(owner).transfer(profitSplit);
            payable(_affiliateAddress).transfer(profitSplit);
            emit CommissionPaid(_affiliateAddress, profitSplit);
        } else {
            payable(owner).transfer(_drops.mul(dropUnitPrice));
        }
    }
    
    
    

    /**
     * Allows for any ERC20 tokens which have been mistakenly  sent to this contract to be returned 
     * to the original sender by the owner of the contract. Any attempt made by any other account 
     * to invoke the function will result in a loss of gas and no tokens will be transferred out.
     * 
     * @param _addressOfToken The contract address of an ERC20 token.
     * @param _recipient The address which will receive tokens. 
     * @param _value The amount of tokens to refund.
     * 
     * @return true if function executes successfully, false otherwise.
     * */  
    function withdrawERC20Tokens(address _addressOfToken,  address _recipient, uint256 _value) public onlyOwner returns(bool){
        require(
            _addressOfToken != address(0)
            && _recipient != address(0)
            && _value > 0
        );
        ERCInterface token = ERCInterface(_addressOfToken);
        token.transfer(_recipient, _value);
        emit ERC20TokensWithdrawn(_addressOfToken, _recipient, _value);
        return true;
    }

    /**
     * Allows for the minting and distribution of an ERC721 token to be transferred to multiple recipients at 
     * a time.
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _nftContract The NFT collection contract where tokens are sent from. 
     * @param _tokenURI The URI for the NFT metadata.
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function nftAirdrop(address[] memory _recipients, address _nftContract, string memory _tokenURI, address _affiliateAddress) public payable returns(bool) {
        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                INFT(_nftContract).mintToCaller(_recipients[i], _tokenURI);
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);
            

        emit NFTAirdrop(msg.sender, nftAddress, _recipients.length);
        return true;
    }

    /**
     * Allows for the distribution of an ERC721 token to be transferred to multiple recipients at 
     * a time.
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _nftContract The NFT collection contract where tokens are sent from. 
     * @param _tokenIds The list of ids being sent.
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function existingNftAirdrop(address[] memory _recipients, address _nftContract, uint256[] memory _tokenIds, address _affiliateAddress) public payable returns(bool) {
        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                IERC721(_nftContract).safeTransferFrom(msg.sender, _recipients[i], _tokenIds[i]);
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);
            

        emit NFTAirdrop(msg.sender, _nftContract, _recipients.length);
        return true;
    }

    /**
     * Allows for the distribution of an ERC721 token to be transferred to multiple recipients at 
     * a time.
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _nftContract The NFT collection contract where tokens are sent from. 
     * @param _tokenIds The list of ids being sent.
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function existing1155NftAirdrop(address[] memory _recipients, address _nftContract, uint256[] memory _tokenIds, uint256[] memory _amounts, address _affiliateAddress) public payable returns(bool) {
        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                IERC1155(_nftContract).safeTransferFrom(msg.sender, _recipients[i], _tokenIds[i], _amounts[i], "");
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);
            

        emit NFTAirdrop(msg.sender, _nftContract, _recipients.length);
        return true;
    }

    /**
     * Allows for the minting and distribution of an ERC721 token to be transferred to multiple recipients at 
     * a time.
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _nftContract The NFT collection contract where tokens are sent from. 
     * @param _tokenIds The list of ids being sent.
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function existingMintNftAirdrop(address[] memory _recipients, address _nftContract, uint256[] memory _tokenIds, address _affiliateAddress) public payable returns(bool) {
        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                IERC721(_nftContract).mint(_recipients[i], _tokenIds[i]);
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);
            

        emit NFTAirdrop(msg.sender, _nftContract, _recipients.length);
        return true;
    }

    /**
     * Allows for the minting and distribution of an ERC721 token to be transferred to multiple recipients at 
     * a time.
     * 
     * @param _recipients The list of addresses which will receive tokens. 
     * @param _nftContract The NFT collection contract where tokens are sent from. 
     * @param _affiliateAddress The affiliate address that is paid a commission.affiliated with a partner, they will provide this code so that 
     * the parter is paid commission.
     * 
     * @return true if function executes successfully, false otherwise.
     * */
    function existingSimpleMintNftAirdrop(address[] memory _recipients, address _nftContract, address _affiliateAddress) public payable returns(bool) {
        uint256 price = _recipients.length.mul(dropUnitPrice);

        require(
            msg.value >= price,
            "Not enough ETH sent with transaction!"
        );

        giveChange(price);
        
        for(uint i = 0; i < _recipients.length; i++) {
            if(_recipients[i] != address(0)) {
                IERC721(_nftContract).mint(_recipients[i]);
            }
        }

        distributeCommission(_recipients.length, _affiliateAddress);
            

        emit NFTAirdrop(msg.sender, _nftContract, _recipients.length);
        return true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"affiliate","type":"address"},{"indexed":true,"internalType":"string","name":"affiliateCode","type":"string"}],"name":"AffiliatePartnershipRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"CommissionPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"sentTo","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"ERC20TokensWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalTransfers","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethValue","type":"uint256"}],"name":"EthAirdrop","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"NFTAddressChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalTransfers","type":"uint256"}],"name":"NFTAirdrop","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAffiliate","type":"address"},{"indexed":true,"internalType":"string","name":"affiliateCode","type":"string"}],"name":"NewAffiliatePartnership","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"from","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"to","type":"uint256"}],"name":"RateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalWei","type":"uint256"}],"name":"RefundIssued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"by","type":"address"},{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalTransfers","type":"uint256"}],"name":"TokenAirdrop","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"dropUnitPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"existing1155NftAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"existingMintNftAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"existingNftAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"existingSimpleMintNftAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"address","name":"_addressOfToken","type":"address"}],"name":"getTokenAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"multiValueEthAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_addressOfToken","type":"address"},{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"multiValueTokenAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"nftAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"string","name":"_tokenURI","type":"string"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"nftAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newNFTAddress","type":"address"}],"name":"setNFTAddress","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newRate","type":"uint256"}],"name":"setRate","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"singleValueEthAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_addressOfToken","type":"address"},{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"address","name":"_affiliateAddress","type":"address"}],"name":"singleValueTokenAirdrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addressOfToken","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"withdrawERC20Tokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

70293:20776:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74986:8;;;70293:20776;74922:8;;;77866:1014;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70371:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;87439:854;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72703:327;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81300:980;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70432:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73385:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;88939:785;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;90317:749;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67518:80;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67235:20;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70397:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84596:770;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76162:842;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83477:471;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86000:805;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74645:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68218:256;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;79665:830;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77866:1014;78002:4;78049:7;:14;78027:11;:18;:36;78019:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;78132:21;78156:26;78174:7;78156:17;:26::i;:::-;78132:50;;78193:13;78209:37;78232:13;;78209:11;:18;:22;;:37;;;;:::i;:::-;78193:53;;78257:17;78277:24;78295:5;78277:13;:17;;:24;;;;:::i;:::-;78257:44;;78349:9;78336;:22;;78314:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;78453:59;78474:11;:18;78494:17;78453:20;:59::i;:::-;78525:21;78536:9;78525:10;:21::i;:::-;78571:6;78567:201;78587:11;:18;78583:1;:22;78567:201;;;78656:1;78630:28;;:11;78642:1;78630:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;;:46;;;;;78675:1;78662:7;78670:1;78662:10;;;;;;;;:::i;:::-;;;;;;;;:14;78630:46;78627:130;;;78705:11;78717:1;78705:14;;;;;;;;:::i;:::-;;;;;;;;78697:32;;:44;78730:7;78738:1;78730:10;;;;;;;;:::i;:::-;;;;;;;;78697:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78627:130;78607:3;;;;;:::i;:::-;;;;78567:201;;;;78804:10;78793:57;;;78816:11;:18;78836:13;78793:57;;;;;;;:::i;:::-;;;;;;;;78868:4;78861:11;;;;;77866:1014;;;;;:::o;70371:19::-;;;;:::o;87439:854::-;87628:4;87645:13;87661:37;87684:13;;87661:11;:18;:22;;:37;;;;:::i;:::-;87645:53;;87746:5;87733:9;:18;;87711:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;87829:17;87840:5;87829:10;:17::i;:::-;87871:6;87867:237;87887:11;:18;87883:1;:22;87867:237;;;87956:1;87930:28;;:11;87942:1;87930:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;87927:166;;87988:12;87979:39;;;88019:10;88031:11;88043:1;88031:14;;;;;;;;:::i;:::-;;;;;;;;88047:9;88057:1;88047:12;;;;;;;;:::i;:::-;;;;;;;;88061:8;88070:1;88061:11;;;;;;;;:::i;:::-;;;;;;;;87979:98;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87927:166;87907:3;;;;;:::i;:::-;;;;87867:237;;;;88116:59;88137:11;:18;88157:17;88116:20;:59::i;:::-;88230:12;88207:56;;88218:10;88207:56;;;88244:11;:18;88207:56;;;;;;:::i;:::-;;;;;;;;88281:4;88274:11;;;87439:854;;;;;;;:::o;72703:327::-;72763:4;67979:5;;;;;;;;;;;67965:19;;:10;:19;;;67957:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;72814:4:::1;;72802:8;:16;;:46;;;;;72847:1;72836:8;:12;72802:46;72780:79;;;::::0;::::1;;72875:27;72887:4;;72893:8;72875:27;;;;;;;:::i;:::-;;;;;;;;72920:8;72913:4;:15;;;;72939:11;72953:7;72939:21;;72987:13;72995:4;;72987:3;:7;;:13;;;;:::i;:::-;72971;:29;;;;73018:4;73011:11;;;72703:327:::0;;;:::o;81300:980::-;81464:4;81481:18;81515:15;81481:50;;81572:7;:14;81550:11;:18;:36;81542:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;81655:13;81671:37;81694:13;;81671:11;:18;:22;;:37;;;;:::i;:::-;81655:53;;81756:5;81743:9;:18;;81721:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;81839:17;81850:5;81839:10;:17::i;:::-;81889:6;81885:215;81905:11;:18;81901:1;:22;81885:215;;;81974:1;81948:28;;:11;81960:1;81948:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;;:46;;;;;81993:1;81980:7;81988:1;81980:10;;;;;;;;:::i;:::-;;;;;;;;:14;81948:46;81945:144;;;82015:5;:18;;;82034:10;82046:11;82058:1;82046:14;;;;;;;;:::i;:::-;;;;;;;;82062:7;82070:1;82062:10;;;;;;;;:::i;:::-;;;;;;;;82015:58;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81945:144;81925:3;;;;;:::i;:::-;;;;81885:215;;;;82112:59;82133:11;:18;82153:17;82112:20;:59::i;:::-;82214:15;82189:61;;82202:10;82189:61;;;82231:11;:18;82189:61;;;;;;:::i;:::-;;;;;;;;82268:4;82261:11;;;;81300:980;;;;;;:::o;70432:25::-;;;;;;;;;;;;;:::o;73385:207::-;73457:4;67979:5;;;;;;;;;;;67965:19;;:10;:19;;;67957:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;73509:14:::1;73479:45;;73497:10;;;;;;;;;;;73479:45;;;;;;;;;;;;73548:14;73535:10;;:27;;;;;;;;;;;;;;;;;;73580:4;73573:11;;73385:207:::0;;;:::o;88939:785::-;89101:4;89118:13;89134:37;89157:13;;89134:11;:18;:22;;:37;;;;:::i;:::-;89118:53;;89219:5;89206:9;:18;;89184:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;89302:17;89313:5;89302:10;:17::i;:::-;89344:6;89340:195;89360:11;:18;89356:1;:22;89340:195;;;89429:1;89403:28;;:11;89415:1;89403:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;89400:124;;89460:12;89452:26;;;89479:11;89491:1;89479:14;;;;;;;;:::i;:::-;;;;;;;;89495:9;89505:1;89495:12;;;;;;;;:::i;:::-;;;;;;;;89452:56;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89400:124;89380:3;;;;;:::i;:::-;;;;89340:195;;;;89547:59;89568:11;:18;89588:17;89547:20;:59::i;:::-;89661:12;89638:56;;89649:10;89638:56;;;89675:11;:18;89638:56;;;;;;:::i;:::-;;;;;;;;89712:4;89705:11;;;88939:785;;;;;;:::o;90317:749::-;90457:4;90474:13;90490:37;90513:13;;90490:11;:18;:22;;:37;;;;:::i;:::-;90474:53;;90575:5;90562:9;:18;;90540:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;90658:17;90669:5;90658:10;:17::i;:::-;90700:6;90696:181;90716:11;:18;90712:1;:22;90696:181;;;90785:1;90759:28;;:11;90771:1;90759:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;90756:110;;90816:12;90808:26;;;90835:11;90847:1;90835:14;;;;;;;;:::i;:::-;;;;;;;;90808:42;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90756:110;90736:3;;;;;:::i;:::-;;;;90696:181;;;;90889:59;90910:11;:18;90930:17;90889:20;:59::i;:::-;91003:12;90980:56;;90991:10;90980:56;;;91017:11;:18;90980:56;;;;;;:::i;:::-;;;;;;;;91054:4;91047:11;;;90317:749;;;;;:::o;67518:80::-;67558:7;67585:5;;;;;;;;;;;67578:12;;67518:80;:::o;67235:20::-;;;;;;;;;;;;:::o;70397:28::-;;;;:::o;84596:770::-;84743:4;84760:13;84776:37;84799:13;;84776:11;:18;:22;;:37;;;;:::i;:::-;84760:53;;84861:5;84848:9;:18;;84826:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;84944:17;84955:5;84944:10;:17::i;:::-;84986:6;84982:197;85002:11;:18;84998:1;:22;84982:197;;;85071:1;85045:28;;:11;85057:1;85045:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;85042:126;;85099:12;85094:31;;;85126:11;85138:1;85126:14;;;;;;;;:::i;:::-;;;;;;;;85142:9;85094:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;85042:126;85022:3;;;;;:::i;:::-;;;;84982:197;;;;85191:59;85212:11;:18;85232:17;85191:20;:59::i;:::-;85305:10;;;;;;;;;;;85282:54;;85293:10;85282:54;;;85317:11;:18;85282:54;;;;;;:::i;:::-;;;;;;;;85354:4;85347:11;;;84596:770;;;;;;:::o;76162:842::-;76289:4;76316:13;76332:37;76355:13;;76332:11;:18;:22;;:37;;;;:::i;:::-;76316:53;;76380:17;76400:41;76435:5;76400:30;76411:11;:18;76400:6;:10;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;76380:61;;76489:9;76476;:22;;76454:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;76584:59;76605:11;:18;76625:17;76584:20;:59::i;:::-;76656:21;76667:9;76656:10;:21::i;:::-;76702:6;76698:175;76714:11;:18;76712:1;:20;76698:175;;;76783:1;76757:28;;:11;76769:1;76757:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;76754:108;;76814:11;76826:1;76814:14;;;;;;;;:::i;:::-;;;;;;;;76806:32;;:40;76839:6;76806:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76754:108;76734:3;;;;;:::i;:::-;;;;76698:175;;;;76901:10;76890:74;;;76913:11;:18;76933:30;76944:11;:18;76933:6;:10;;:30;;;;:::i;:::-;76890:74;;;;;;;:::i;:::-;;;;;;;;76992:4;76985:11;;;;76162:842;;;;;:::o;83477:471::-;83593:4;67979:5;;;;;;;;;;;67965:19;;:10;:19;;;67957:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;83658:1:::1;83631:29;;:15;:29;;;;:70;;;;;83699:1;83677:24;;:10;:24;;;;83631:70;:97;;;;;83727:1;83718:6;:10;83631:97;83609:130;;;::::0;::::1;;83750:18;83784:15;83750:50;;83811:5;:14;;;83826:10;83838:6;83811:34;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;83861:57;83882:15;83899:10;83911:6;83861:57;;;;;;;;:::i;:::-;;;;;;;;83936:4;83929:11;;;83477:471:::0;;;;;:::o;86000:805::-;86158:4;86175:13;86191:37;86214:13;;86191:11;:18;:22;;:37;;;;:::i;:::-;86175:53;;86276:5;86263:9;:18;;86241:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;86359:17;86370:5;86359:10;:17::i;:::-;86401:6;86397:219;86417:11;:18;86413:1;:22;86397:219;;;86486:1;86460:28;;:11;86472:1;86460:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;86457:148;;86517:12;86509:38;;;86548:10;86560:11;86572:1;86560:14;;;;;;;;:::i;:::-;;;;;;;;86576:9;86586:1;86576:12;;;;;;;;:::i;:::-;;;;;;;;86509:80;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86457:148;86437:3;;;;;:::i;:::-;;;;86397:219;;;;86628:59;86649:11;:18;86669:17;86628:20;:59::i;:::-;86742:12;86719:56;;86730:10;86719:56;;;86756:11;:18;86719:56;;;;;;:::i;:::-;;;;;;;;86793:4;86786:11;;;86000:805;;;;;;:::o;74645:220::-;74732:7;74752:18;74786:15;74752:50;;74820:5;:15;;;74836:5;74851:4;74820:37;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74813:44;;;74645:220;;;;:::o;68218:256::-;67979:5;;;;;;;;;;67965:19;;:10;:19;;;67957:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;68335:1:::1;68314:23;;:9;:23;;;;:58;;;;;68367:5;::::0;::::1;;;;;;;;68354:18;;:9;:18;;;;68314:58;68292:92;;;::::0;::::1;;68428:9;68400:38;;68421:5;::::0;::::1;;;;;;;;68400:38;;;;;;;;;;;;68457:9;68449:5;::::0;:17:::1;;;;;;;;;;;;;;;;;;68218:256:::0;:::o;79665:830::-;79820:4;79837:18;79871:15;79837:50;;79900:13;79916:37;79939:13;;79916:11;:18;:22;;:37;;;;:::i;:::-;79900:53;;80001:5;79988:9;:18;;79966:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;80084:17;80095:5;80084:10;:17::i;:::-;80126:6;80122:193;80142:11;:18;80138:1;:22;80122:193;;;80211:1;80185:28;;:11;80197:1;80185:14;;;;;;;;:::i;:::-;;;;;;;;:28;;;80182:122;;80234:5;:18;;;80253:10;80265:11;80277:1;80265:14;;;;;;;;:::i;:::-;;;;;;;;80281:6;80234:54;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80182:122;80162:3;;;;;:::i;:::-;;;;80122:193;;;;80327:59;80348:11;:18;80368:17;80327:20;:59::i;:::-;80429:15;80404:61;;80417:10;80404:61;;;80446:11;:18;80404:61;;;;;;:::i;:::-;;;;;;;;80483:4;80476:11;;;;79665:830;;;;;;:::o;77024:262::-;77099:7;77119:16;77138:1;77119:20;;77154:6;77150:103;77170:7;:14;77166:1;:18;77150:103;;;77217:24;77230:7;77238:1;77230:10;;;;;;;;:::i;:::-;;;;;;;;77217:8;:12;;:24;;;;:::i;:::-;77206:35;;77186:3;;;;;:::i;:::-;;;;77150:103;;;;77270:8;77263:15;;;77024:262;;;:::o;3571:98::-;3629:7;3660:1;3656;:5;;;;:::i;:::-;3649:12;;3571:98;;;;:::o;2833:::-;2891:7;2922:1;2918;:5;;;;:::i;:::-;2911:12;;2833:98;;;;:::o;82366:480::-;82491:1;82462:31;;:17;:31;;;82459:380;;82510:19;82532:32;82562:1;82532:25;82543:13;;82532:6;:10;;:25;;;;:::i;:::-;:29;;:32;;;;:::i;:::-;82510:54;;82587:5;;;;;;;;;;82579:23;;:36;82603:11;82579:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82638:17;82630:35;;:48;82666:11;82630:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82713:17;82698:46;;;82732:11;82698:46;;;;;;:::i;:::-;;;;;;;;82495:261;82459:380;;;82785:5;;;;;;;;;;82777:23;;:50;82801:25;82812:13;;82801:6;:10;;:25;;;;:::i;:::-;82777:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82459:380;82366:480;;:::o;72159:202::-;72230:6;72218:9;:18;72215:139;;;72253:14;72270:21;72284:6;72270:9;:13;;:21;;;;:::i;:::-;72253:38;;72314:10;72306:28;;:36;72335:6;72306:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72238:116;72215:139;72159:202;:::o;3970:98::-;4028:7;4059:1;4055;:5;;;;:::i;:::-;4048:12;;3970:98;;;;:::o;3214:::-;3272:7;3303:1;3299;:5;;;;:::i;:::-;3292:12;;3214:98;;;;:::o;24:722:1:-;120:5;145:81;161:64;218:6;161:64;:::i;:::-;145:81;:::i;:::-;136:90;;246:5;275:6;268:5;261:21;309:4;302:5;298:16;291:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:143;;;404:79;;:::i;:::-;350:143;517:1;502:238;527:6;524:1;521:13;502:238;;;595:3;624:37;657:3;645:10;624:37;:::i;:::-;619:3;612:50;691:4;686:3;682:14;675:21;;725:4;720:3;716:14;709:21;;562:178;549:1;546;542:9;537:14;;502:238;;;506:14;126:620;;24:722;;;;;:::o;769:::-;865:5;890:81;906:64;963:6;906:64;:::i;:::-;890:81;:::i;:::-;881:90;;991:5;1020:6;1013:5;1006:21;1054:4;1047:5;1043:16;1036:23;;1080:6;1130:3;1122:4;1114:6;1110:17;1105:3;1101:27;1098:36;1095:143;;;1149:79;;:::i;:::-;1095:143;1262:1;1247:238;1272:6;1269:1;1266:13;1247:238;;;1340:3;1369:37;1402:3;1390:10;1369:37;:::i;:::-;1364:3;1357:50;1436:4;1431:3;1427:14;1420:21;;1470:4;1465:3;1461:14;1454:21;;1307:178;1294:1;1291;1287:9;1282:14;;1247:238;;;1251:14;871:620;;769:722;;;;;:::o;1497:412::-;1575:5;1600:66;1616:49;1658:6;1616:49;:::i;:::-;1600:66;:::i;:::-;1591:75;;1689:6;1682:5;1675:21;1727:4;1720:5;1716:16;1765:3;1756:6;1751:3;1747:16;1744:25;1741:112;;;1772:79;;:::i;:::-;1741:112;1862:41;1896:6;1891:3;1886;1862:41;:::i;:::-;1581:328;1497:412;;;;;:::o;1915:139::-;1961:5;1999:6;1986:20;1977:29;;2015:33;2042:5;2015:33;:::i;:::-;1915:139;;;;:::o;2077:370::-;2148:5;2197:3;2190:4;2182:6;2178:17;2174:27;2164:122;;2205:79;;:::i;:::-;2164:122;2322:6;2309:20;2347:94;2437:3;2429:6;2422:4;2414:6;2410:17;2347:94;:::i;:::-;2338:103;;2154:293;2077:370;;;;:::o;2470:::-;2541:5;2590:3;2583:4;2575:6;2571:17;2567:27;2557:122;;2598:79;;:::i;:::-;2557:122;2715:6;2702:20;2740:94;2830:3;2822:6;2815:4;2807:6;2803:17;2740:94;:::i;:::-;2731:103;;2547:293;2470:370;;;;:::o;2846:137::-;2900:5;2931:6;2925:13;2916:22;;2947:30;2971:5;2947:30;:::i;:::-;2846:137;;;;:::o;3003:340::-;3059:5;3108:3;3101:4;3093:6;3089:17;3085:27;3075:122;;3116:79;;:::i;:::-;3075:122;3233:6;3220:20;3258:79;3333:3;3325:6;3318:4;3310:6;3306:17;3258:79;:::i;:::-;3249:88;;3065:278;3003:340;;;;:::o;3349:139::-;3395:5;3433:6;3420:20;3411:29;;3449:33;3476:5;3449:33;:::i;:::-;3349:139;;;;:::o;3494:143::-;3551:5;3582:6;3576:13;3567:22;;3598:33;3625:5;3598:33;:::i;:::-;3494:143;;;;:::o;3643:329::-;3702:6;3751:2;3739:9;3730:7;3726:23;3722:32;3719:119;;;3757:79;;:::i;:::-;3719:119;3877:1;3902:53;3947:7;3938:6;3927:9;3923:22;3902:53;:::i;:::-;3892:63;;3848:117;3643:329;;;;:::o;3978:474::-;4046:6;4054;4103:2;4091:9;4082:7;4078:23;4074:32;4071:119;;;4109:79;;:::i;:::-;4071:119;4229:1;4254:53;4299:7;4290:6;4279:9;4275:22;4254:53;:::i;:::-;4244:63;;4200:117;4356:2;4382:53;4427:7;4418:6;4407:9;4403:22;4382:53;:::i;:::-;4372:63;;4327:118;3978:474;;;;;:::o;4458:619::-;4535:6;4543;4551;4600:2;4588:9;4579:7;4575:23;4571:32;4568:119;;;4606:79;;:::i;:::-;4568:119;4726:1;4751:53;4796:7;4787:6;4776:9;4772:22;4751:53;:::i;:::-;4741:63;;4697:117;4853:2;4879:53;4924:7;4915:6;4904:9;4900:22;4879:53;:::i;:::-;4869:63;;4824:118;4981:2;5007:53;5052:7;5043:6;5032:9;5028:22;5007:53;:::i;:::-;4997:63;;4952:118;4458:619;;;;;:::o;5083:1185::-;5219:6;5227;5235;5243;5292:3;5280:9;5271:7;5267:23;5263:33;5260:120;;;5299:79;;:::i;:::-;5260:120;5419:1;5444:53;5489:7;5480:6;5469:9;5465:22;5444:53;:::i;:::-;5434:63;;5390:117;5574:2;5563:9;5559:18;5546:32;5605:18;5597:6;5594:30;5591:117;;;5627:79;;:::i;:::-;5591:117;5732:78;5802:7;5793:6;5782:9;5778:22;5732:78;:::i;:::-;5722:88;;5517:303;5887:2;5876:9;5872:18;5859:32;5918:18;5910:6;5907:30;5904:117;;;5940:79;;:::i;:::-;5904:117;6045:78;6115:7;6106:6;6095:9;6091:22;6045:78;:::i;:::-;6035:88;;5830:303;6172:2;6198:53;6243:7;6234:6;6223:9;6219:22;6198:53;:::i;:::-;6188:63;;6143:118;5083:1185;;;;;;;:::o;6274:975::-;6385:6;6393;6401;6409;6458:3;6446:9;6437:7;6433:23;6429:33;6426:120;;;6465:79;;:::i;:::-;6426:120;6585:1;6610:53;6655:7;6646:6;6635:9;6631:22;6610:53;:::i;:::-;6600:63;;6556:117;6740:2;6729:9;6725:18;6712:32;6771:18;6763:6;6760:30;6757:117;;;6793:79;;:::i;:::-;6757:117;6898:78;6968:7;6959:6;6948:9;6944:22;6898:78;:::i;:::-;6888:88;;6683:303;7025:2;7051:53;7096:7;7087:6;7076:9;7072:22;7051:53;:::i;:::-;7041:63;;6996:118;7153:2;7179:53;7224:7;7215:6;7204:9;7200:22;7179:53;:::i;:::-;7169:63;;7124:118;6274:975;;;;;;;:::o;7255:829::-;7357:6;7365;7373;7422:2;7410:9;7401:7;7397:23;7393:32;7390:119;;;7428:79;;:::i;:::-;7390:119;7576:1;7565:9;7561:17;7548:31;7606:18;7598:6;7595:30;7592:117;;;7628:79;;:::i;:::-;7592:117;7733:78;7803:7;7794:6;7783:9;7779:22;7733:78;:::i;:::-;7723:88;;7519:302;7860:2;7886:53;7931:7;7922:6;7911:9;7907:22;7886:53;:::i;:::-;7876:63;;7831:118;7988:2;8014:53;8059:7;8050:6;8039:9;8035:22;8014:53;:::i;:::-;8004:63;;7959:118;7255:829;;;;;:::o;8090:1185::-;8226:6;8234;8242;8250;8299:3;8287:9;8278:7;8274:23;8270:33;8267:120;;;8306:79;;:::i;:::-;8267:120;8454:1;8443:9;8439:17;8426:31;8484:18;8476:6;8473:30;8470:117;;;8506:79;;:::i;:::-;8470:117;8611:78;8681:7;8672:6;8661:9;8657:22;8611:78;:::i;:::-;8601:88;;8397:302;8738:2;8764:53;8809:7;8800:6;8789:9;8785:22;8764:53;:::i;:::-;8754:63;;8709:118;8894:2;8883:9;8879:18;8866:32;8925:18;8917:6;8914:30;8911:117;;;8947:79;;:::i;:::-;8911:117;9052:78;9122:7;9113:6;9102:9;9098:22;9052:78;:::i;:::-;9042:88;;8837:303;9179:2;9205:53;9250:7;9241:6;9230:9;9226:22;9205:53;:::i;:::-;9195:63;;9150:118;8090:1185;;;;;;;:::o;9281:1541::-;9451:6;9459;9467;9475;9483;9532:3;9520:9;9511:7;9507:23;9503:33;9500:120;;;9539:79;;:::i;:::-;9500:120;9687:1;9676:9;9672:17;9659:31;9717:18;9709:6;9706:30;9703:117;;;9739:79;;:::i;:::-;9703:117;9844:78;9914:7;9905:6;9894:9;9890:22;9844:78;:::i;:::-;9834:88;;9630:302;9971:2;9997:53;10042:7;10033:6;10022:9;10018:22;9997:53;:::i;:::-;9987:63;;9942:118;10127:2;10116:9;10112:18;10099:32;10158:18;10150:6;10147:30;10144:117;;;10180:79;;:::i;:::-;10144:117;10285:78;10355:7;10346:6;10335:9;10331:22;10285:78;:::i;:::-;10275:88;;10070:303;10440:2;10429:9;10425:18;10412:32;10471:18;10463:6;10460:30;10457:117;;;10493:79;;:::i;:::-;10457:117;10598:78;10668:7;10659:6;10648:9;10644:22;10598:78;:::i;:::-;10588:88;;10383:303;10725:3;10752:53;10797:7;10788:6;10777:9;10773:22;10752:53;:::i;:::-;10742:63;;10696:119;9281:1541;;;;;;;;:::o;10828:1155::-;10949:6;10957;10965;10973;11022:3;11010:9;11001:7;10997:23;10993:33;10990:120;;;11029:79;;:::i;:::-;10990:120;11177:1;11166:9;11162:17;11149:31;11207:18;11199:6;11196:30;11193:117;;;11229:79;;:::i;:::-;11193:117;11334:78;11404:7;11395:6;11384:9;11380:22;11334:78;:::i;:::-;11324:88;;11120:302;11461:2;11487:53;11532:7;11523:6;11512:9;11508:22;11487:53;:::i;:::-;11477:63;;11432:118;11617:2;11606:9;11602:18;11589:32;11648:18;11640:6;11637:30;11634:117;;;11670:79;;:::i;:::-;11634:117;11775:63;11830:7;11821:6;11810:9;11806:22;11775:63;:::i;:::-;11765:73;;11560:288;11887:2;11913:53;11958:7;11949:6;11938:9;11934:22;11913:53;:::i;:::-;11903:63;;11858:118;10828:1155;;;;;;;:::o;11989:1039::-;12116:6;12124;12132;12181:2;12169:9;12160:7;12156:23;12152:32;12149:119;;;12187:79;;:::i;:::-;12149:119;12335:1;12324:9;12320:17;12307:31;12365:18;12357:6;12354:30;12351:117;;;12387:79;;:::i;:::-;12351:117;12492:78;12562:7;12553:6;12542:9;12538:22;12492:78;:::i;:::-;12482:88;;12278:302;12647:2;12636:9;12632:18;12619:32;12678:18;12670:6;12667:30;12664:117;;;12700:79;;:::i;:::-;12664:117;12805:78;12875:7;12866:6;12855:9;12851:22;12805:78;:::i;:::-;12795:88;;12590:303;12932:2;12958:53;13003:7;12994:6;12983:9;12979:22;12958:53;:::i;:::-;12948:63;;12903:118;11989:1039;;;;;:::o;13034:829::-;13136:6;13144;13152;13201:2;13189:9;13180:7;13176:23;13172:32;13169:119;;;13207:79;;:::i;:::-;13169:119;13355:1;13344:9;13340:17;13327:31;13385:18;13377:6;13374:30;13371:117;;;13407:79;;:::i;:::-;13371:117;13512:78;13582:7;13573:6;13562:9;13558:22;13512:78;:::i;:::-;13502:88;;13298:302;13639:2;13665:53;13710:7;13701:6;13690:9;13686:22;13665:53;:::i;:::-;13655:63;;13610:118;13767:2;13793:53;13838:7;13829:6;13818:9;13814:22;13793:53;:::i;:::-;13783:63;;13738:118;13034:829;;;;;:::o;13869:345::-;13936:6;13985:2;13973:9;13964:7;13960:23;13956:32;13953:119;;;13991:79;;:::i;:::-;13953:119;14111:1;14136:61;14189:7;14180:6;14169:9;14165:22;14136:61;:::i;:::-;14126:71;;14082:125;13869:345;;;;:::o;14220:329::-;14279:6;14328:2;14316:9;14307:7;14303:23;14299:32;14296:119;;;14334:79;;:::i;:::-;14296:119;14454:1;14479:53;14524:7;14515:6;14504:9;14500:22;14479:53;:::i;:::-;14469:63;;14425:117;14220:329;;;;:::o;14555:351::-;14625:6;14674:2;14662:9;14653:7;14649:23;14645:32;14642:119;;;14680:79;;:::i;:::-;14642:119;14800:1;14825:64;14881:7;14872:6;14861:9;14857:22;14825:64;:::i;:::-;14815:74;;14771:128;14555:351;;;;:::o;14912:118::-;14999:24;15017:5;14999:24;:::i;:::-;14994:3;14987:37;14912:118;;:::o;15036:109::-;15117:21;15132:5;15117:21;:::i;:::-;15112:3;15105:34;15036:109;;:::o;15151:364::-;15239:3;15267:39;15300:5;15267:39;:::i;:::-;15322:71;15386:6;15381:3;15322:71;:::i;:::-;15315:78;;15402:52;15447:6;15442:3;15435:4;15428:5;15424:16;15402:52;:::i;:::-;15479:29;15501:6;15479:29;:::i;:::-;15474:3;15470:39;15463:46;;15243:272;15151:364;;;;:::o;15521:366::-;15663:3;15684:67;15748:2;15743:3;15684:67;:::i;:::-;15677:74;;15760:93;15849:3;15760:93;:::i;:::-;15878:2;15873:3;15869:12;15862:19;;15521:366;;;:::o;15893:::-;16035:3;16056:67;16120:2;16115:3;16056:67;:::i;:::-;16049:74;;16132:93;16221:3;16132:93;:::i;:::-;16250:2;16245:3;16241:12;16234:19;;15893:366;;;:::o;16265:362::-;16406:3;16427:65;16490:1;16485:3;16427:65;:::i;:::-;16420:72;;16501:93;16590:3;16501:93;:::i;:::-;16619:1;16614:3;16610:11;16603:18;;16265:362;;;:::o;16633:366::-;16775:3;16796:67;16860:2;16855:3;16796:67;:::i;:::-;16789:74;;16872:93;16961:3;16872:93;:::i;:::-;16990:2;16985:3;16981:12;16974:19;;16633:366;;;:::o;17005:118::-;17092:24;17110:5;17092:24;:::i;:::-;17087:3;17080:37;17005:118;;:::o;17129:222::-;17222:4;17260:2;17249:9;17245:18;17237:26;;17273:71;17341:1;17330:9;17326:17;17317:6;17273:71;:::i;:::-;17129:222;;;;:::o;17357:332::-;17478:4;17516:2;17505:9;17501:18;17493:26;;17529:71;17597:1;17586:9;17582:17;17573:6;17529:71;:::i;:::-;17610:72;17678:2;17667:9;17663:18;17654:6;17610:72;:::i;:::-;17357:332;;;;;:::o;17695:442::-;17844:4;17882:2;17871:9;17867:18;17859:26;;17895:71;17963:1;17952:9;17948:17;17939:6;17895:71;:::i;:::-;17976:72;18044:2;18033:9;18029:18;18020:6;17976:72;:::i;:::-;18058;18126:2;18115:9;18111:18;18102:6;18058:72;:::i;:::-;17695:442;;;;;;:::o;18143:859::-;18420:4;18458:3;18447:9;18443:19;18435:27;;18472:71;18540:1;18529:9;18525:17;18516:6;18472:71;:::i;:::-;18553:72;18621:2;18610:9;18606:18;18597:6;18553:72;:::i;:::-;18635;18703:2;18692:9;18688:18;18679:6;18635:72;:::i;:::-;18717;18785:2;18774:9;18770:18;18761:6;18717:72;:::i;:::-;18837:9;18831:4;18827:20;18821:3;18810:9;18806:19;18799:49;18865:130;18990:4;18865:130;:::i;:::-;18857:138;;18143:859;;;;;;;:::o;19008:423::-;19149:4;19187:2;19176:9;19172:18;19164:26;;19200:71;19268:1;19257:9;19253:17;19244:6;19200:71;:::i;:::-;19318:9;19312:4;19308:20;19303:2;19292:9;19288:18;19281:48;19346:78;19419:4;19410:6;19346:78;:::i;:::-;19338:86;;19008:423;;;;;:::o;19437:332::-;19558:4;19596:2;19585:9;19581:18;19573:26;;19609:71;19677:1;19666:9;19662:17;19653:6;19609:71;:::i;:::-;19690:72;19758:2;19747:9;19743:18;19734:6;19690:72;:::i;:::-;19437:332;;;;;:::o;19775:210::-;19862:4;19900:2;19889:9;19885:18;19877:26;;19913:65;19975:1;19964:9;19960:17;19951:6;19913:65;:::i;:::-;19775:210;;;;:::o;19991:419::-;20157:4;20195:2;20184:9;20180:18;20172:26;;20244:9;20238:4;20234:20;20230:1;20219:9;20215:17;20208:47;20272:131;20398:4;20272:131;:::i;:::-;20264:139;;19991:419;;;:::o;20416:::-;20582:4;20620:2;20609:9;20605:18;20597:26;;20669:9;20663:4;20659:20;20655:1;20644:9;20640:17;20633:47;20697:131;20823:4;20697:131;:::i;:::-;20689:139;;20416:419;;;:::o;20841:::-;21007:4;21045:2;21034:9;21030:18;21022:26;;21094:9;21088:4;21084:20;21080:1;21069:9;21065:17;21058:47;21122:131;21248:4;21122:131;:::i;:::-;21114:139;;20841:419;;;:::o;21266:222::-;21359:4;21397:2;21386:9;21382:18;21374:26;;21410:71;21478:1;21467:9;21463:17;21454:6;21410:71;:::i;:::-;21266:222;;;;:::o;21494:332::-;21615:4;21653:2;21642:9;21638:18;21630:26;;21666:71;21734:1;21723:9;21719:17;21710:6;21666:71;:::i;:::-;21747:72;21815:2;21804:9;21800:18;21791:6;21747:72;:::i;:::-;21494:332;;;;;:::o;21832:129::-;21866:6;21893:20;;:::i;:::-;21883:30;;21922:33;21950:4;21942:6;21922:33;:::i;:::-;21832:129;;;:::o;21967:75::-;22000:6;22033:2;22027:9;22017:19;;21967:75;:::o;22048:311::-;22125:4;22215:18;22207:6;22204:30;22201:56;;;22237:18;;:::i;:::-;22201:56;22287:4;22279:6;22275:17;22267:25;;22347:4;22341;22337:15;22329:23;;22048:311;;;:::o;22365:::-;22442:4;22532:18;22524:6;22521:30;22518:56;;;22554:18;;:::i;:::-;22518:56;22604:4;22596:6;22592:17;22584:25;;22664:4;22658;22654:15;22646:23;;22365:311;;;:::o;22682:308::-;22744:4;22834:18;22826:6;22823:30;22820:56;;;22856:18;;:::i;:::-;22820:56;22894:29;22916:6;22894:29;:::i;:::-;22886:37;;22978:4;22972;22968:15;22960:23;;22682:308;;;:::o;22996:99::-;23048:6;23082:5;23076:12;23066:22;;22996:99;;;:::o;23101:168::-;23184:11;23218:6;23213:3;23206:19;23258:4;23253:3;23249:14;23234:29;;23101:168;;;;:::o;23275:169::-;23359:11;23393:6;23388:3;23381:19;23433:4;23428:3;23424:14;23409:29;;23275:169;;;;:::o;23450:305::-;23490:3;23509:20;23527:1;23509:20;:::i;:::-;23504:25;;23543:20;23561:1;23543:20;:::i;:::-;23538:25;;23697:1;23629:66;23625:74;23622:1;23619:81;23616:107;;;23703:18;;:::i;:::-;23616:107;23747:1;23744;23740:9;23733:16;;23450:305;;;;:::o;23761:185::-;23801:1;23818:20;23836:1;23818:20;:::i;:::-;23813:25;;23852:20;23870:1;23852:20;:::i;:::-;23847:25;;23891:1;23881:35;;23896:18;;:::i;:::-;23881:35;23938:1;23935;23931:9;23926:14;;23761:185;;;;:::o;23952:348::-;23992:7;24015:20;24033:1;24015:20;:::i;:::-;24010:25;;24049:20;24067:1;24049:20;:::i;:::-;24044:25;;24237:1;24169:66;24165:74;24162:1;24159:81;24154:1;24147:9;24140:17;24136:105;24133:131;;;24244:18;;:::i;:::-;24133:131;24292:1;24289;24285:9;24274:20;;23952:348;;;;:::o;24306:191::-;24346:4;24366:20;24384:1;24366:20;:::i;:::-;24361:25;;24400:20;24418:1;24400:20;:::i;:::-;24395:25;;24439:1;24436;24433:8;24430:34;;;24444:18;;:::i;:::-;24430:34;24489:1;24486;24482:9;24474:17;;24306:191;;;;:::o;24503:96::-;24540:7;24569:24;24587:5;24569:24;:::i;:::-;24558:35;;24503:96;;;:::o;24605:90::-;24639:7;24682:5;24675:13;24668:21;24657:32;;24605:90;;;:::o;24701:126::-;24738:7;24778:42;24771:5;24767:54;24756:65;;24701:126;;;:::o;24833:77::-;24870:7;24899:5;24888:16;;24833:77;;;:::o;24916:154::-;25000:6;24995:3;24990;24977:30;25062:1;25053:6;25048:3;25044:16;25037:27;24916:154;;;:::o;25076:307::-;25144:1;25154:113;25168:6;25165:1;25162:13;25154:113;;;25253:1;25248:3;25244:11;25238:18;25234:1;25229:3;25225:11;25218:39;25190:2;25187:1;25183:10;25178:15;;25154:113;;;25285:6;25282:1;25279:13;25276:101;;;25365:1;25356:6;25351:3;25347:16;25340:27;25276:101;25125:258;25076:307;;;:::o;25389:281::-;25472:27;25494:4;25472:27;:::i;:::-;25464:6;25460:40;25602:6;25590:10;25587:22;25566:18;25554:10;25551:34;25548:62;25545:88;;;25613:18;;:::i;:::-;25545:88;25653:10;25649:2;25642:22;25432:238;25389:281;;:::o;25676:233::-;25715:3;25738:24;25756:5;25738:24;:::i;:::-;25729:33;;25784:66;25777:5;25774:77;25771:103;;;25854:18;;:::i;:::-;25771:103;25901:1;25894:5;25890:13;25883:20;;25676:233;;;:::o;25915:180::-;25963:77;25960:1;25953:88;26060:4;26057:1;26050:15;26084:4;26081:1;26074:15;26101:180;26149:77;26146:1;26139:88;26246:4;26243:1;26236:15;26270:4;26267:1;26260:15;26287:180;26335:77;26332:1;26325:88;26432:4;26429:1;26422:15;26456:4;26453:1;26446:15;26473:180;26521:77;26518:1;26511:88;26618:4;26615:1;26608:15;26642:4;26639:1;26632:15;26659:117;26768:1;26765;26758:12;26782:117;26891:1;26888;26881:12;26905:117;27014:1;27011;27004:12;27028:117;27137:1;27134;27127:12;27151:117;27260:1;27257;27250:12;27274:102;27315:6;27366:2;27362:7;27357:2;27350:5;27346:14;27342:28;27332:38;;27274:102;;;:::o;27382:224::-;27522:34;27518:1;27510:6;27506:14;27499:58;27591:7;27586:2;27578:6;27574:15;27567:32;27382:224;:::o;27612:238::-;27752:34;27748:1;27740:6;27736:14;27729:58;27821:21;27816:2;27808:6;27804:15;27797:46;27612:238;:::o;27856:114::-;;:::o;27976:227::-;28116:34;28112:1;28104:6;28100:14;28093:58;28185:10;28180:2;28172:6;28168:15;28161:35;27976:227;:::o;28209:122::-;28282:24;28300:5;28282:24;:::i;:::-;28275:5;28272:35;28262:63;;28321:1;28318;28311:12;28262:63;28209:122;:::o;28337:116::-;28407:21;28422:5;28407:21;:::i;:::-;28400:5;28397:32;28387:60;;28443:1;28440;28433:12;28387:60;28337:116;:::o;28459:122::-;28532:24;28550:5;28532:24;:::i;:::-;28525:5;28522:35;28512:63;;28571:1;28568;28561:12;28512:63;28459:122;:::o

ipfs://3530e4949056849f2c01a05e40b5c2502caa2c3e3699a23056b8804ea71c8f40