Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity 0.8.7;

import "./ERC721.sol";
import "./Ownable.sol";
import "./Address.sol";
import "./SafeMath.sol";
import "./Counters.sol";
import "./PaymentSplitter.sol";

contract MoonPass is ERC721, Ownable, PaymentSplitter {
    using SafeMath for uint256;
    using Counters for Counters.Counter;
    using Address for address;
    
    Counters.Counter private _tokenIdCounter;
    
    uint256 public constant maxMoonPassSupply = 4161;
    bool public saleStatus = false;
    uint256 public salePrice;
    uint256 public maxPurchaseAmount = 5;
    
    address payable thisContract;
    address[] public owners;
    
    mapping(address => uint256) userPurchaseTotal;
    
    
    address[] private _team = [
        0x700eec4D6Ed56ED0F97a0f43Fc9DF5B426Ba25Fc, //Swan 1 23%
        0xDFf1889Ec0F09d14dE9379938bDc3Df0c6D0B39C, //Swan 2 22%
        0x4c2a5a4ea0d3f7E9142535f260A05b975Ee1df02, //Fritz 1 23%
        0xDbe3BfBEc8332b0835bf0f466bA34c64655Ba94D, //Fritz 2 22%
        0x12B285072b1Ffc70F367f08066b0D9A7d3337309 //Izadi 10%
        ];
    
    uint256[] private _teamShares = [
        23,
        22,
        23,
        22,
        10
        ];
    
    constructor() ERC721("MoonPass", "MOONPASS") PaymentSplitter(_team, _teamShares) {
    }
    
    fallback() external payable {

  	}
    
    function setMaxPurchaseAmount(uint256 _maxAllowed) external onlyOwner {
        maxPurchaseAmount = _maxAllowed;
    }
    
    function setThisContract(address payable _thisContract) external onlyOwner {
        thisContract = _thisContract;
    }
    
    function purchaseMoonPass(address _purchaser, uint256 _numberOfPasses) public payable {
        require(msg.value >= calculateTotalPrice(_numberOfPasses), "Insuffcient amount sent");
        require(thisContract.send(msg.value), "Receiever must be the contract");
        require(userPurchaseTotal[_purchaser].add(_numberOfPasses) <= maxPurchaseAmount, "Transaction exceeds max alloted per user");
        require(_tokenIdCounter.current().add(_numberOfPasses) <= maxMoonPassSupply, "Purchase would exceed max supply");
        require(saleStatus == true, "Sale is not active");
        
        for(uint256 i = 0; i < _numberOfPasses; i++) {
            userPurchaseTotal[_purchaser] = userPurchaseTotal[_purchaser] + 1;
            _safeMint(_purchaser, _tokenIdCounter.current() + 1);
            _tokenIdCounter.increment();
        }
    }    
    
    function calculateTotalPrice(uint256 _numberOfPasses) public view returns(uint256) {
        return salePrice.mul(_numberOfPasses);
    }
    
    function totalSupply() external view returns (uint256) {
        return _tokenIdCounter.current();
    }
    
    function setSaleStatus(bool _trueOrFalse) external onlyOwner {
        saleStatus = _trueOrFalse;
    }
    
    function setSalePrice(uint256 _priceInWei) external onlyOwner {
        salePrice = _priceInWei;
    }
    
    function populateCurrentHolders() external onlyOwner {
        uint256 currentTotal = _tokenIdCounter.current();
        for(uint256 i = 1; i <= currentTotal; i++) {
            address toAdd = super.ownerOf(i);
            owners.push(toAdd);
        }
    }
    
    function returnCurrentHolders() external view returns(address[] memory) {
        return owners;
    }
    
    function withdrawAll() external onlyOwner {
        for (uint256 i = 0; i < _team.length; i++) {
            address payable wallet = payable(_team[i]);
            release(wallet);
        }
    }
    
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./EnumerableSet.sol";

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

// SPDX-License-Identifier: MIT

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;

            if (lastIndex != toDeleteIndex) {
                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] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // 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) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

// SPDX-License-Identifier: MIT

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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Address.sol";
import "./Context.sol";

/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() external view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() external view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) external view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) external view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) external view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + _totalReleased;
        uint256 payment = (totalReceived * _shares[account]) / _totalShares - _released[account];

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] = _released[account] + payment;
        _totalReleased = _totalReleased + payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberOfPasses","type":"uint256"}],"name":"calculateTotalPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMoonPassSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPurchaseAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"owners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"populateCurrentHolders","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_purchaser","type":"address"},{"internalType":"uint256","name":"_numberOfPasses","type":"uint256"}],"name":"purchaseMoonPass","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"returnCurrentHolders","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"salePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"saleStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxAllowed","type":"uint256"}],"name":"setMaxPurchaseAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_priceInWei","type":"uint256"}],"name":"setSalePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_trueOrFalse","type":"bool"}],"name":"setSaleStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_thisContract","type":"address"}],"name":"setThisContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

211:3332:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2610:40:14;2626:12;:10;:12::i;:::-;2640:9;2610:40;;;;;;;:::i;:::-;;;;;;;;211:3332:12;;;1431:300:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;632:23:12;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2349:98:4;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3950:217;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3488:401;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2619:104:12;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3784:600:14;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2846:102:12;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4814:330:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2735:91:14;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5210:179:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;431:48:12;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2052:235:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3227:102:12;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1790:205:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1598:92:13;;;;;;;;;;;;;:::i;:::-;;3339:197:12;;;;;;;;;;;;;:::i;:::-;;1614:844;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3490:100:14;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;966:85:13;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2511:102:4;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3295:109:14;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4234:290:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1356:118:12;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5455:320:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1484:120:12;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2472:137;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2679:329:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3096:105:14;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2733:103:12;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2915:95:14;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4590:162:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1839:189:13;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;521:24:12;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2958:259;;;;;;;;;;;;;:::i;:::-;;485:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;551:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;587:96:1;640:7;666:10;659:17;;587:96;:::o;1431:300:4:-;1533:4;1583:25;1568:40;;;:11;:40;;;;:104;;;;1639:33;1624:48;;;:11;:48;;;;1568:104;:156;;;;1688:36;1712:11;1688:23;:36::i;:::-;1568:156;1549:175;;1431:300;;;:::o;632:23:12:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2349:98:4:-;2403:13;2435:5;2428:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2349:98;:::o;3950:217::-;4026:7;4053:16;4061:7;4053;:16::i;:::-;4045:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;4136:15;:24;4152:7;4136:24;;;;;;;;;;;;;;;;;;;;;4129:31;;3950:217;;;:::o;3488:401::-;3568:13;3584:23;3599:7;3584:14;:23::i;:::-;3568:39;;3631:5;3625:11;;:2;:11;;;;3617:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;3722:5;3706:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;3731:37;3748:5;3755:12;:10;:12::i;:::-;3731:16;:37::i;:::-;3706:62;3685:165;;;;;;;;;;;;:::i;:::-;;;;;;;;;3861:21;3870:2;3874:7;3861:8;:21::i;:::-;3558:331;3488:401;;:::o;2619:104:12:-;2665:7;2691:25;:15;:23;:25::i;:::-;2684:32;;2619:104;:::o;3784:600:14:-;3878:1;3859:7;:16;3867:7;3859:16;;;;;;;;;;;;;;;;:20;3851:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;3933:21;3981:14;;3957:21;:38;;;;:::i;:::-;3933:62;;4005:15;4075:9;:18;4085:7;4075:18;;;;;;;;;;;;;;;;4060:12;;4040:7;:16;4048:7;4040:16;;;;;;;;;;;;;;;;4024:13;:32;;;;:::i;:::-;4023:49;;;;:::i;:::-;:70;;;;:::i;:::-;4005:88;;4123:1;4112:7;:12;;4104:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;4225:7;4204:9;:18;4214:7;4204:18;;;;;;;;;;;;;;;;:28;;;;:::i;:::-;4183:9;:18;4193:7;4183:18;;;;;;;;;;;;;;;:49;;;;4276:7;4259:14;;:24;;;;:::i;:::-;4242:14;:41;;;;4294:35;4312:7;4321;4294:17;:35::i;:::-;4344:33;4360:7;4369;4344:33;;;;;;;:::i;:::-;;;;;;;;3841:543;;3784:600;:::o;2846:102:12:-;1189:12:13;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2930:11:12::1;2918:9;:23;;;;2846:102:::0;:::o;4814:330:4:-;5003:41;5022:12;:10;:12::i;:::-;5036:7;5003:18;:41::i;:::-;4995:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;5109:28;5119:4;5125:2;5129:7;5109:9;:28::i;:::-;4814:330;;;:::o;2735:91:14:-;2781:7;2807:12;;2800:19;;2735:91;:::o;5210:179:4:-;5343:39;5360:4;5366:2;5370:7;5343:39;;;;;;;;;;;;:16;:39::i;:::-;5210:179;;;:::o;431:48:12:-;475:4;431:48;:::o;2052:235:4:-;2124:7;2143:13;2159:7;:16;2167:7;2159:16;;;;;;;;;;;;;;;;;;;;;2143:32;;2210:1;2193:19;;:5;:19;;;;2185:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2275:5;2268:12;;;2052:235;;;:::o;3227:102:12:-;3281:16;3316:6;3309:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3227:102;:::o;1790:205:4:-;1862:7;1906:1;1889:19;;:5;:19;;;;1881:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;1972:9;:16;1982:5;1972:16;;;;;;;;;;;;;;;;1965:23;;1790:205;;;:::o;1598:92:13:-;1189:12;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1662:21:::1;1680:1;1662:9;:21::i;:::-;1598:92::o:0;3339:197:12:-;1189:12:13;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;3396:9:12::1;3391:139;3415:5;:12;;;;3411:1;:16;3391:139;;;3448:22;3481:5;3487:1;3481:8;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3448:42;;3504:15;3512:6;3504:7;:15::i;:::-;3434:96;3429:3;;;;;:::i;:::-;;;;3391:139;;;;3339:197::o:0;1614:844::-;1731:36;1751:15;1731:19;:36::i;:::-;1718:9;:49;;1710:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;1813:12;;;;;;;;;;;:17;;:28;1831:9;1813:28;;;;;;;;;;;;;;;;;;;;;;;1805:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;1948:17;;1894:50;1928:15;1894:17;:29;1912:10;1894:29;;;;;;;;;;;;;;;;:33;;:50;;;;:::i;:::-;:71;;1886:124;;;;;;;;;;;;:::i;:::-;;;;;;;;;475:4;2028:46;2058:15;2028:25;:15;:23;:25::i;:::-;:29;;:46;;;;:::i;:::-;:67;;2020:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;2164:4;2150:18;;:10;;;;;;;;;;;:18;;;2142:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;2214:9;2210:242;2233:15;2229:1;:19;2210:242;;;2333:1;2301:17;:29;2319:10;2301:29;;;;;;;;;;;;;;;;:33;;;;:::i;:::-;2269:17;:29;2287:10;2269:29;;;;;;;;;;;;;;;:65;;;;2348:52;2358:10;2398:1;2370:25;:15;:23;:25::i;:::-;:29;;;;:::i;:::-;2348:9;:52::i;:::-;2414:27;:15;:25;:27::i;:::-;2250:3;;;;;:::i;:::-;;;;2210:242;;;;1614:844;;:::o;3490:100:14:-;3543:7;3569;3577:5;3569:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3562:21;;3490:100;;;:::o;966:85:13:-;1012:7;1038:6;;;;;;;;;;;1031:13;;966:85;:::o;2511:102:4:-;2567:13;2599:7;2592:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2511:102;:::o;3295:109:14:-;3353:7;3379:9;:18;3389:7;3379:18;;;;;;;;;;;;;;;;3372:25;;3295:109;;;:::o;4234:290:4:-;4348:12;:10;:12::i;:::-;4336:24;;:8;:24;;;;4328:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;4446:8;4401:18;:32;4420:12;:10;:12::i;:::-;4401:32;;;;;;;;;;;;;;;:42;4434:8;4401:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;4498:8;4469:48;;4484:12;:10;:12::i;:::-;4469:48;;;4508:8;4469:48;;;;;;:::i;:::-;;;;;;;;4234:290;;:::o;1356:118:12:-;1189:12:13;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1456:11:12::1;1436:17;:31;;;;1356:118:::0;:::o;5455:320:4:-;5624:41;5643:12;:10;:12::i;:::-;5657:7;5624:18;:41::i;:::-;5616:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;5729:39;5743:4;5749:2;5753:7;5762:5;5729:13;:39::i;:::-;5455:320;;;;:::o;1484:120:12:-;1189:12:13;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1584:13:12::1;1569:12;;:28;;;;;;;;;;;;;;;;;;1484:120:::0;:::o;2472:137::-;2546:7;2572:30;2586:15;2572:9;;:13;;:30;;;;:::i;:::-;2565:37;;2472:137;;;:::o;2679:329:4:-;2752:13;2785:16;2793:7;2785;:16::i;:::-;2777:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;2864:21;2888:10;:8;:10::i;:::-;2864:34;;2939:1;2921:7;2915:21;:25;:86;;;;;;;;;;;;;;;;;2967:7;2976:18;:7;:16;:18::i;:::-;2950:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2915:86;2908:93;;;2679:329;;;:::o;3096:105:14:-;3152:7;3178;:16;3186:7;3178:16;;;;;;;;;;;;;;;;3171:23;;3096:105;;;:::o;2733:103:12:-;1189:12:13;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2817:12:12::1;2804:10;;:25;;;;;;;;;;;;;;;;;;2733:103:::0;:::o;2915:95:14:-;2963:7;2989:14;;2982:21;;2915:95;:::o;4590:162:4:-;4687:4;4710:18;:25;4729:5;4710:25;;;;;;;;;;;;;;;:35;4736:8;4710:35;;;;;;;;;;;;;;;;;;;;;;;;;4703:42;;4590:162;;;;:::o;1839:189:13:-;1189:12;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1947:1:::1;1927:22;;:8;:22;;;;1919:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2002:19;2012:8;2002:9;:19::i;:::-;1839:189:::0;:::o;521:24:12:-;;;;:::o;2958:259::-;1189:12:13;:10;:12::i;:::-;1178:23;;:7;:5;:7::i;:::-;:23;;;1170:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;3021:20:12::1;3044:25;:15;:23;:25::i;:::-;3021:48;;3083:9;3095:1;3083:13;;3079:132;3103:12;3098:1;:17;3079:132;;3136:13;3152:16;3166:1;3152:13;:16::i;:::-;3136:32;;3182:6;3194:5;3182:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3122:89;3117:3;;;;;:::i;:::-;;;;3079:132;;;;3011:206;2958:259::o:0;485:30::-;;;;;;;;;;;;;:::o;551:36::-;;;;:::o;763:155:3:-;848:4;886:25;871:40;;;:11;:40;;;;864:47;;763:155;;;:::o;7247:125:4:-;7312:4;7363:1;7335:30;;:7;:16;7343:7;7335:16;;;;;;;;;;;;;;;;;;;;;:30;;;;7328:37;;7247:125;;;:::o;11098:171::-;11199:2;11172:15;:24;11188:7;11172:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;11254:7;11250:2;11216:46;;11225:23;11240:7;11225:14;:23::i;:::-;11216:46;;;;;;;;;;;;11098:171;;:::o;773:112:2:-;838:7;864;:14;;;857:21;;773:112;;;:::o;2012:312:0:-;2126:6;2101:21;:31;;2093:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2178:12;2196:9;:14;;2218:6;2196:33;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2177:52;;;2247:7;2239:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;2083:241;2012:312;;:::o;7530:344:4:-;7623:4;7647:16;7655:7;7647;:16::i;:::-;7639:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;7722:13;7738:23;7753:7;7738:14;:23::i;:::-;7722:39;;7790:5;7779:16;;:7;:16;;;:51;;;;7823:7;7799:31;;:20;7811:7;7799:11;:20::i;:::-;:31;;;7779:51;:87;;;;7834:32;7851:5;7858:7;7834:16;:32::i;:::-;7779:87;7771:96;;;7530:344;;;;:::o;10427:560::-;10581:4;10554:31;;:23;10569:7;10554:14;:23::i;:::-;:31;;;10546:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;10663:1;10649:16;;:2;:16;;;;10641:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;10717:39;10738:4;10744:2;10748:7;10717:20;:39::i;:::-;10818:29;10835:1;10839:7;10818:8;:29::i;:::-;10877:1;10858:9;:15;10868:4;10858:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;10905:1;10888:9;:13;10898:2;10888:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;10935:2;10916:7;:16;10924:7;10916:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;10972:7;10968:2;10953:27;;10962:4;10953:27;;;;;;;;;;;;10427:560;;;:::o;2034:169:13:-;2089:16;2108:6;;;;;;;;;;;2089:25;;2133:8;2124:6;;:17;;;;;;;;;;;;;;;;;;2187:8;2156:40;;2177:8;2156:40;;;;;;;;;;;;2079:124;2034:169;:::o;2672:96:15:-;2730:7;2760:1;2756;:5;;;;:::i;:::-;2749:12;;2672:96;;;;:::o;8204:108:4:-;8279:26;8289:2;8293:7;8279:26;;;;;;;;;;;;:9;:26::i;:::-;8204:108;;:::o;891:123:2:-;996:1;978:7;:14;;;:19;;;;;;;;;;;891:123;:::o;6637:307:4:-;6788:28;6798:4;6804:2;6808:7;6788:9;:28::i;:::-;6834:48;6857:4;6863:2;6867:7;6876:5;6834:22;:48::i;:::-;6826:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;6637:307;;;;:::o;3382:96:15:-;3440:7;3470:1;3466;:5;;;;:::i;:::-;3459:12;;3382:96;;;;:::o;3249:182:4:-;3300:13;3325:99;;;;;;;;;;;;;;;;;;;3249:182;:::o;275:703:16:-;331:13;557:1;548:5;:10;544:51;;;574:10;;;;;;;;;;;;;;;;;;;;;544:51;604:12;619:5;604:20;;634:14;658:75;673:1;665:4;:9;658:75;;690:8;;;;;:::i;:::-;;;;720:2;712:10;;;;;:::i;:::-;;;658:75;;;742:19;774:6;764:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;742:39;;791:150;807:1;798:5;:10;791:150;;834:1;824:11;;;;;:::i;:::-;;;900:2;892:5;:10;;;;:::i;:::-;879:2;:24;;;;:::i;:::-;866:39;;849:6;856;849:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;928:2;919:11;;;;;:::i;:::-;;;791:150;;;964:6;950:21;;;;;275:703;;;;:::o;13156:122:4:-;;;;:::o;8533:311::-;8658:18;8664:2;8668:7;8658:5;:18::i;:::-;8707:54;8738:1;8742:2;8746:7;8755:5;8707:22;:54::i;:::-;8686:151;;;;;;;;;;;;:::i;:::-;;;;;;;;;8533:311;;;:::o;11822:778::-;11972:4;11992:15;:2;:13;;;:15::i;:::-;11988:606;;;12043:2;12027:36;;;12064:12;:10;:12::i;:::-;12078:4;12084:7;12093:5;12027:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;12023:519;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12283:1;12266:6;:13;:18;12262:266;;;12308:60;;;;;;;;;;:::i;:::-;;;;;;;;12262:266;12480:6;12474:13;12465:6;12461:2;12457:15;12450:38;12023:519;12159:41;;;12149:51;;;:6;:51;;;;12142:58;;;;;11988:606;12579:4;12572:11;;11822:778;;;;;;;:::o;9166:372::-;9259:1;9245:16;;:2;:16;;;;9237:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;9317:16;9325:7;9317;:16::i;:::-;9316:17;9308:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;9377:45;9406:1;9410:2;9414:7;9377:20;:45::i;:::-;9450:1;9433:9;:13;9443:2;9433:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;9480:2;9461:7;:16;9469:7;9461:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;9523:7;9519:2;9498:33;;9515:1;9498:33;;;;;;;;;;;;9166:372;;:::o;718:377:0:-;778:4;981:12;1046:7;1034:20;1026:28;;1087:1;1080:4;:8;1073:15;;;718:377;;;:::o;7:410:17:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:139::-;469:5;507:6;494:20;485:29;;523:33;550:5;523:33;:::i;:::-;423:139;;;;:::o;568:155::-;622:5;660:6;647:20;638:29;;676:41;711:5;676:41;:::i;:::-;568:155;;;;:::o;729:133::-;772:5;810:6;797:20;788:29;;826:30;850:5;826:30;:::i;:::-;729:133;;;;:::o;868:137::-;913:5;951:6;938:20;929:29;;967:32;993:5;967:32;:::i;:::-;868:137;;;;:::o;1011:141::-;1067:5;1098:6;1092:13;1083:22;;1114:32;1140:5;1114:32;:::i;:::-;1011:141;;;;:::o;1171:338::-;1226:5;1275:3;1268:4;1260:6;1256:17;1252:27;1242:122;;1283:79;;:::i;:::-;1242:122;1400:6;1387:20;1425:78;1499:3;1491:6;1484:4;1476:6;1472:17;1425:78;:::i;:::-;1416:87;;1232:277;1171:338;;;;:::o;1515:139::-;1561:5;1599:6;1586:20;1577:29;;1615:33;1642:5;1615:33;:::i;:::-;1515:139;;;;:::o;1660:329::-;1719:6;1768:2;1756:9;1747:7;1743:23;1739:32;1736:119;;;1774:79;;:::i;:::-;1736:119;1894:1;1919:53;1964:7;1955:6;1944:9;1940:22;1919:53;:::i;:::-;1909:63;;1865:117;1660:329;;;;:::o;1995:345::-;2062:6;2111:2;2099:9;2090:7;2086:23;2082:32;2079:119;;;2117:79;;:::i;:::-;2079:119;2237:1;2262:61;2315:7;2306:6;2295:9;2291:22;2262:61;:::i;:::-;2252:71;;2208:125;1995:345;;;;:::o;2346:474::-;2414:6;2422;2471:2;2459:9;2450:7;2446:23;2442:32;2439:119;;;2477:79;;:::i;:::-;2439:119;2597:1;2622:53;2667:7;2658:6;2647:9;2643:22;2622:53;:::i;:::-;2612:63;;2568:117;2724:2;2750:53;2795:7;2786:6;2775:9;2771:22;2750:53;:::i;:::-;2740:63;;2695:118;2346:474;;;;;:::o;2826:619::-;2903:6;2911;2919;2968:2;2956:9;2947:7;2943:23;2939:32;2936:119;;;2974:79;;:::i;:::-;2936:119;3094:1;3119:53;3164:7;3155:6;3144:9;3140:22;3119:53;:::i;:::-;3109:63;;3065:117;3221:2;3247:53;3292:7;3283:6;3272:9;3268:22;3247:53;:::i;:::-;3237:63;;3192:118;3349:2;3375:53;3420:7;3411:6;3400:9;3396:22;3375:53;:::i;:::-;3365:63;;3320:118;2826:619;;;;;:::o;3451:943::-;3546:6;3554;3562;3570;3619:3;3607:9;3598:7;3594:23;3590:33;3587:120;;;3626:79;;:::i;:::-;3587:120;3746:1;3771:53;3816:7;3807:6;3796:9;3792:22;3771:53;:::i;:::-;3761:63;;3717:117;3873:2;3899:53;3944:7;3935:6;3924:9;3920:22;3899:53;:::i;:::-;3889:63;;3844:118;4001:2;4027:53;4072:7;4063:6;4052:9;4048:22;4027:53;:::i;:::-;4017:63;;3972:118;4157:2;4146:9;4142:18;4129:32;4188:18;4180:6;4177:30;4174:117;;;4210:79;;:::i;:::-;4174:117;4315:62;4369:7;4360:6;4349:9;4345:22;4315:62;:::i;:::-;4305:72;;4100:287;3451:943;;;;;;;:::o;4400:468::-;4465:6;4473;4522:2;4510:9;4501:7;4497:23;4493:32;4490:119;;;4528:79;;:::i;:::-;4490:119;4648:1;4673:53;4718:7;4709:6;4698:9;4694:22;4673:53;:::i;:::-;4663:63;;4619:117;4775:2;4801:50;4843:7;4834:6;4823:9;4819:22;4801:50;:::i;:::-;4791:60;;4746:115;4400:468;;;;;:::o;4874:474::-;4942:6;4950;4999:2;4987:9;4978:7;4974:23;4970:32;4967:119;;;5005:79;;:::i;:::-;4967:119;5125:1;5150:53;5195:7;5186:6;5175:9;5171:22;5150:53;:::i;:::-;5140:63;;5096:117;5252:2;5278:53;5323:7;5314:6;5303:9;5299:22;5278:53;:::i;:::-;5268:63;;5223:118;4874:474;;;;;:::o;5354:323::-;5410:6;5459:2;5447:9;5438:7;5434:23;5430:32;5427:119;;;5465:79;;:::i;:::-;5427:119;5585:1;5610:50;5652:7;5643:6;5632:9;5628:22;5610:50;:::i;:::-;5600:60;;5556:114;5354:323;;;;:::o;5683:327::-;5741:6;5790:2;5778:9;5769:7;5765:23;5761:32;5758:119;;;5796:79;;:::i;:::-;5758:119;5916:1;5941:52;5985:7;5976:6;5965:9;5961:22;5941:52;:::i;:::-;5931:62;;5887:116;5683:327;;;;:::o;6016:349::-;6085:6;6134:2;6122:9;6113:7;6109:23;6105:32;6102:119;;;6140:79;;:::i;:::-;6102:119;6260:1;6285:63;6340:7;6331:6;6320:9;6316:22;6285:63;:::i;:::-;6275:73;;6231:127;6016:349;;;;:::o;6371:329::-;6430:6;6479:2;6467:9;6458:7;6454:23;6450:32;6447:119;;;6485:79;;:::i;:::-;6447:119;6605:1;6630:53;6675:7;6666:6;6655:9;6651:22;6630:53;:::i;:::-;6620:63;;6576:117;6371:329;;;;:::o;6706:179::-;6775:10;6796:46;6838:3;6830:6;6796:46;:::i;:::-;6874:4;6869:3;6865:14;6851:28;;6706:179;;;;:::o;6891:147::-;6986:45;7025:5;6986:45;:::i;:::-;6981:3;6974:58;6891:147;;:::o;7044:108::-;7121:24;7139:5;7121:24;:::i;:::-;7116:3;7109:37;7044:108;;:::o;7158:118::-;7245:24;7263:5;7245:24;:::i;:::-;7240:3;7233:37;7158:118;;:::o;7312:732::-;7431:3;7460:54;7508:5;7460:54;:::i;:::-;7530:86;7609:6;7604:3;7530:86;:::i;:::-;7523:93;;7640:56;7690:5;7640:56;:::i;:::-;7719:7;7750:1;7735:284;7760:6;7757:1;7754:13;7735:284;;;7836:6;7830:13;7863:63;7922:3;7907:13;7863:63;:::i;:::-;7856:70;;7949:60;8002:6;7949:60;:::i;:::-;7939:70;;7795:224;7782:1;7779;7775:9;7770:14;;7735:284;;;7739:14;8035:3;8028:10;;7436:608;;;7312:732;;;;:::o;8050:109::-;8131:21;8146:5;8131:21;:::i;:::-;8126:3;8119:34;8050:109;;:::o;8165:360::-;8251:3;8279:38;8311:5;8279:38;:::i;:::-;8333:70;8396:6;8391:3;8333:70;:::i;:::-;8326:77;;8412:52;8457:6;8452:3;8445:4;8438:5;8434:16;8412:52;:::i;:::-;8489:29;8511:6;8489:29;:::i;:::-;8484:3;8480:39;8473:46;;8255:270;8165:360;;;;:::o;8531:364::-;8619:3;8647:39;8680:5;8647:39;:::i;:::-;8702:71;8766:6;8761:3;8702:71;:::i;:::-;8695:78;;8782:52;8827:6;8822:3;8815:4;8808:5;8804:16;8782:52;:::i;:::-;8859:29;8881:6;8859:29;:::i;:::-;8854:3;8850:39;8843:46;;8623:272;8531:364;;;;:::o;8901:377::-;9007:3;9035:39;9068:5;9035:39;:::i;:::-;9090:89;9172:6;9167:3;9090:89;:::i;:::-;9083:96;;9188:52;9233:6;9228:3;9221:4;9214:5;9210:16;9188:52;:::i;:::-;9265:6;9260:3;9256:16;9249:23;;9011:267;8901:377;;;;:::o;9284:366::-;9426:3;9447:67;9511:2;9506:3;9447:67;:::i;:::-;9440:74;;9523:93;9612:3;9523:93;:::i;:::-;9641:2;9636:3;9632:12;9625:19;;9284:366;;;:::o;9656:::-;9798:3;9819:67;9883:2;9878:3;9819:67;:::i;:::-;9812:74;;9895:93;9984:3;9895:93;:::i;:::-;10013:2;10008:3;10004:12;9997:19;;9656:366;;;:::o;10028:::-;10170:3;10191:67;10255:2;10250:3;10191:67;:::i;:::-;10184:74;;10267:93;10356:3;10267:93;:::i;:::-;10385:2;10380:3;10376:12;10369:19;;10028:366;;;:::o;10400:::-;10542:3;10563:67;10627:2;10622:3;10563:67;:::i;:::-;10556:74;;10639:93;10728:3;10639:93;:::i;:::-;10757:2;10752:3;10748:12;10741:19;;10400:366;;;:::o;10772:::-;10914:3;10935:67;10999:2;10994:3;10935:67;:::i;:::-;10928:74;;11011:93;11100:3;11011:93;:::i;:::-;11129:2;11124:3;11120:12;11113:19;;10772:366;;;:::o;11144:::-;11286:3;11307:67;11371:2;11366:3;11307:67;:::i;:::-;11300:74;;11383:93;11472:3;11383:93;:::i;:::-;11501:2;11496:3;11492:12;11485:19;;11144:366;;;:::o;11516:::-;11658:3;11679:67;11743:2;11738:3;11679:67;:::i;:::-;11672:74;;11755:93;11844:3;11755:93;:::i;:::-;11873:2;11868:3;11864:12;11857:19;;11516:366;;;:::o;11888:::-;12030:3;12051:67;12115:2;12110:3;12051:67;:::i;:::-;12044:74;;12127:93;12216:3;12127:93;:::i;:::-;12245:2;12240:3;12236:12;12229:19;;11888:366;;;:::o;12260:::-;12402:3;12423:67;12487:2;12482:3;12423:67;:::i;:::-;12416:74;;12499:93;12588:3;12499:93;:::i;:::-;12617:2;12612:3;12608:12;12601:19;;12260:366;;;:::o;12632:::-;12774:3;12795:67;12859:2;12854:3;12795:67;:::i;:::-;12788:74;;12871:93;12960:3;12871:93;:::i;:::-;12989:2;12984:3;12980:12;12973:19;;12632:366;;;:::o;13004:::-;13146:3;13167:67;13231:2;13226:3;13167:67;:::i;:::-;13160:74;;13243:93;13332:3;13243:93;:::i;:::-;13361:2;13356:3;13352:12;13345:19;;13004:366;;;:::o;13376:::-;13518:3;13539:67;13603:2;13598:3;13539:67;:::i;:::-;13532:74;;13615:93;13704:3;13615:93;:::i;:::-;13733:2;13728:3;13724:12;13717:19;;13376:366;;;:::o;13748:::-;13890:3;13911:67;13975:2;13970:3;13911:67;:::i;:::-;13904:74;;13987:93;14076:3;13987:93;:::i;:::-;14105:2;14100:3;14096:12;14089:19;;13748:366;;;:::o;14120:::-;14262:3;14283:67;14347:2;14342:3;14283:67;:::i;:::-;14276:74;;14359:93;14448:3;14359:93;:::i;:::-;14477:2;14472:3;14468:12;14461:19;;14120:366;;;:::o;14492:::-;14634:3;14655:67;14719:2;14714:3;14655:67;:::i;:::-;14648:74;;14731:93;14820:3;14731:93;:::i;:::-;14849:2;14844:3;14840:12;14833:19;;14492:366;;;:::o;14864:::-;15006:3;15027:67;15091:2;15086:3;15027:67;:::i;:::-;15020:74;;15103:93;15192:3;15103:93;:::i;:::-;15221:2;15216:3;15212:12;15205:19;;14864:366;;;:::o;15236:::-;15378:3;15399:67;15463:2;15458:3;15399:67;:::i;:::-;15392:74;;15475:93;15564:3;15475:93;:::i;:::-;15593:2;15588:3;15584:12;15577:19;;15236:366;;;:::o;15608:::-;15750:3;15771:67;15835:2;15830:3;15771:67;:::i;:::-;15764:74;;15847:93;15936:3;15847:93;:::i;:::-;15965:2;15960:3;15956:12;15949:19;;15608:366;;;:::o;15980:::-;16122:3;16143:67;16207:2;16202:3;16143:67;:::i;:::-;16136:74;;16219:93;16308:3;16219:93;:::i;:::-;16337:2;16332:3;16328:12;16321:19;;15980:366;;;:::o;16352:::-;16494:3;16515:67;16579:2;16574:3;16515:67;:::i;:::-;16508:74;;16591:93;16680:3;16591:93;:::i;:::-;16709:2;16704:3;16700:12;16693:19;;16352:366;;;:::o;16724:::-;16866:3;16887:67;16951:2;16946:3;16887:67;:::i;:::-;16880:74;;16963:93;17052:3;16963:93;:::i;:::-;17081:2;17076:3;17072:12;17065:19;;16724:366;;;:::o;17096:::-;17238:3;17259:67;17323:2;17318:3;17259:67;:::i;:::-;17252:74;;17335:93;17424:3;17335:93;:::i;:::-;17453:2;17448:3;17444:12;17437:19;;17096:366;;;:::o;17468:::-;17610:3;17631:67;17695:2;17690:3;17631:67;:::i;:::-;17624:74;;17707:93;17796:3;17707:93;:::i;:::-;17825:2;17820:3;17816:12;17809:19;;17468:366;;;:::o;17840:::-;17982:3;18003:67;18067:2;18062:3;18003:67;:::i;:::-;17996:74;;18079:93;18168:3;18079:93;:::i;:::-;18197:2;18192:3;18188:12;18181:19;;17840:366;;;:::o;18212:398::-;18371:3;18392:83;18473:1;18468:3;18392:83;:::i;:::-;18385:90;;18484:93;18573:3;18484:93;:::i;:::-;18602:1;18597:3;18593:11;18586:18;;18212:398;;;:::o;18616:366::-;18758:3;18779:67;18843:2;18838:3;18779:67;:::i;:::-;18772:74;;18855:93;18944:3;18855:93;:::i;:::-;18973:2;18968:3;18964:12;18957:19;;18616:366;;;:::o;18988:118::-;19075:24;19093:5;19075:24;:::i;:::-;19070:3;19063:37;18988:118;;:::o;19112:435::-;19292:3;19314:95;19405:3;19396:6;19314:95;:::i;:::-;19307:102;;19426:95;19517:3;19508:6;19426:95;:::i;:::-;19419:102;;19538:3;19531:10;;19112:435;;;;;:::o;19553:379::-;19737:3;19759:147;19902:3;19759:147;:::i;:::-;19752:154;;19923:3;19916:10;;19553:379;;;:::o;19938:222::-;20031:4;20069:2;20058:9;20054:18;20046:26;;20082:71;20150:1;20139:9;20135:17;20126:6;20082:71;:::i;:::-;19938:222;;;;:::o;20166:348::-;20295:4;20333:2;20322:9;20318:18;20310:26;;20346:79;20422:1;20411:9;20407:17;20398:6;20346:79;:::i;:::-;20435:72;20503:2;20492:9;20488:18;20479:6;20435:72;:::i;:::-;20166:348;;;;;:::o;20520:640::-;20715:4;20753:3;20742:9;20738:19;20730:27;;20767:71;20835:1;20824:9;20820:17;20811:6;20767:71;:::i;:::-;20848:72;20916:2;20905:9;20901:18;20892:6;20848:72;:::i;:::-;20930;20998:2;20987:9;20983:18;20974:6;20930:72;:::i;:::-;21049:9;21043:4;21039:20;21034:2;21023:9;21019:18;21012:48;21077:76;21148:4;21139:6;21077:76;:::i;:::-;21069:84;;20520:640;;;;;;;:::o;21166:332::-;21287:4;21325:2;21314:9;21310:18;21302:26;;21338:71;21406:1;21395:9;21391:17;21382:6;21338:71;:::i;:::-;21419:72;21487:2;21476:9;21472:18;21463:6;21419:72;:::i;:::-;21166:332;;;;;:::o;21504:373::-;21647:4;21685:2;21674:9;21670:18;21662:26;;21734:9;21728:4;21724:20;21720:1;21709:9;21705:17;21698:47;21762:108;21865:4;21856:6;21762:108;:::i;:::-;21754:116;;21504:373;;;;:::o;21883:210::-;21970:4;22008:2;21997:9;21993:18;21985:26;;22021:65;22083:1;22072:9;22068:17;22059:6;22021:65;:::i;:::-;21883:210;;;;:::o;22099:313::-;22212:4;22250:2;22239:9;22235:18;22227:26;;22299:9;22293:4;22289:20;22285:1;22274:9;22270:17;22263:47;22327:78;22400:4;22391:6;22327:78;:::i;:::-;22319:86;;22099:313;;;;:::o;22418:419::-;22584:4;22622:2;22611:9;22607:18;22599:26;;22671:9;22665:4;22661:20;22657:1;22646:9;22642:17;22635:47;22699:131;22825:4;22699:131;:::i;:::-;22691:139;;22418:419;;;:::o;22843:::-;23009:4;23047:2;23036:9;23032:18;23024:26;;23096:9;23090:4;23086:20;23082:1;23071:9;23067:17;23060:47;23124:131;23250:4;23124:131;:::i;:::-;23116:139;;22843:419;;;:::o;23268:::-;23434:4;23472:2;23461:9;23457:18;23449:26;;23521:9;23515:4;23511:20;23507:1;23496:9;23492:17;23485:47;23549:131;23675:4;23549:131;:::i;:::-;23541:139;;23268:419;;;:::o;23693:::-;23859:4;23897:2;23886:9;23882:18;23874:26;;23946:9;23940:4;23936:20;23932:1;23921:9;23917:17;23910:47;23974:131;24100:4;23974:131;:::i;:::-;23966:139;;23693:419;;;:::o;24118:::-;24284:4;24322:2;24311:9;24307:18;24299:26;;24371:9;24365:4;24361:20;24357:1;24346:9;24342:17;24335:47;24399:131;24525:4;24399:131;:::i;:::-;24391:139;;24118:419;;;:::o;24543:::-;24709:4;24747:2;24736:9;24732:18;24724:26;;24796:9;24790:4;24786:20;24782:1;24771:9;24767:17;24760:47;24824:131;24950:4;24824:131;:::i;:::-;24816:139;;24543:419;;;:::o;24968:::-;25134:4;25172:2;25161:9;25157:18;25149:26;;25221:9;25215:4;25211:20;25207:1;25196:9;25192:17;25185:47;25249:131;25375:4;25249:131;:::i;:::-;25241:139;;24968:419;;;:::o;25393:::-;25559:4;25597:2;25586:9;25582:18;25574:26;;25646:9;25640:4;25636:20;25632:1;25621:9;25617:17;25610:47;25674:131;25800:4;25674:131;:::i;:::-;25666:139;;25393:419;;;:::o;25818:::-;25984:4;26022:2;26011:9;26007:18;25999:26;;26071:9;26065:4;26061:20;26057:1;26046:9;26042:17;26035:47;26099:131;26225:4;26099:131;:::i;:::-;26091:139;;25818:419;;;:::o;26243:::-;26409:4;26447:2;26436:9;26432:18;26424:26;;26496:9;26490:4;26486:20;26482:1;26471:9;26467:17;26460:47;26524:131;26650:4;26524:131;:::i;:::-;26516:139;;26243:419;;;:::o;26668:::-;26834:4;26872:2;26861:9;26857:18;26849:26;;26921:9;26915:4;26911:20;26907:1;26896:9;26892:17;26885:47;26949:131;27075:4;26949:131;:::i;:::-;26941:139;;26668:419;;;:::o;27093:::-;27259:4;27297:2;27286:9;27282:18;27274:26;;27346:9;27340:4;27336:20;27332:1;27321:9;27317:17;27310:47;27374:131;27500:4;27374:131;:::i;:::-;27366:139;;27093:419;;;:::o;27518:::-;27684:4;27722:2;27711:9;27707:18;27699:26;;27771:9;27765:4;27761:20;27757:1;27746:9;27742:17;27735:47;27799:131;27925:4;27799:131;:::i;:::-;27791:139;;27518:419;;;:::o;27943:::-;28109:4;28147:2;28136:9;28132:18;28124:26;;28196:9;28190:4;28186:20;28182:1;28171:9;28167:17;28160:47;28224:131;28350:4;28224:131;:::i;:::-;28216:139;;27943:419;;;:::o;28368:::-;28534:4;28572:2;28561:9;28557:18;28549:26;;28621:9;28615:4;28611:20;28607:1;28596:9;28592:17;28585:47;28649:131;28775:4;28649:131;:::i;:::-;28641:139;;28368:419;;;:::o;28793:::-;28959:4;28997:2;28986:9;28982:18;28974:26;;29046:9;29040:4;29036:20;29032:1;29021:9;29017:17;29010:47;29074:131;29200:4;29074:131;:::i;:::-;29066:139;;28793:419;;;:::o;29218:::-;29384:4;29422:2;29411:9;29407:18;29399:26;;29471:9;29465:4;29461:20;29457:1;29446:9;29442:17;29435:47;29499:131;29625:4;29499:131;:::i;:::-;29491:139;;29218:419;;;:::o;29643:::-;29809:4;29847:2;29836:9;29832:18;29824:26;;29896:9;29890:4;29886:20;29882:1;29871:9;29867:17;29860:47;29924:131;30050:4;29924:131;:::i;:::-;29916:139;;29643:419;;;:::o;30068:::-;30234:4;30272:2;30261:9;30257:18;30249:26;;30321:9;30315:4;30311:20;30307:1;30296:9;30292:17;30285:47;30349:131;30475:4;30349:131;:::i;:::-;30341:139;;30068:419;;;:::o;30493:::-;30659:4;30697:2;30686:9;30682:18;30674:26;;30746:9;30740:4;30736:20;30732:1;30721:9;30717:17;30710:47;30774:131;30900:4;30774:131;:::i;:::-;30766:139;;30493:419;;;:::o;30918:::-;31084:4;31122:2;31111:9;31107:18;31099:26;;31171:9;31165:4;31161:20;31157:1;31146:9;31142:17;31135:47;31199:131;31325:4;31199:131;:::i;:::-;31191:139;;30918:419;;;:::o;31343:::-;31509:4;31547:2;31536:9;31532:18;31524:26;;31596:9;31590:4;31586:20;31582:1;31571:9;31567:17;31560:47;31624:131;31750:4;31624:131;:::i;:::-;31616:139;;31343:419;;;:::o;31768:::-;31934:4;31972:2;31961:9;31957:18;31949:26;;32021:9;32015:4;32011:20;32007:1;31996:9;31992:17;31985:47;32049:131;32175:4;32049:131;:::i;:::-;32041:139;;31768:419;;;:::o;32193:::-;32359:4;32397:2;32386:9;32382:18;32374:26;;32446:9;32440:4;32436:20;32432:1;32421:9;32417:17;32410:47;32474:131;32600:4;32474:131;:::i;:::-;32466:139;;32193:419;;;:::o;32618:::-;32784:4;32822:2;32811:9;32807:18;32799:26;;32871:9;32865:4;32861:20;32857:1;32846:9;32842:17;32835:47;32899:131;33025:4;32899:131;:::i;:::-;32891:139;;32618:419;;;:::o;33043:222::-;33136:4;33174:2;33163:9;33159:18;33151:26;;33187:71;33255:1;33244:9;33240:17;33231:6;33187:71;:::i;:::-;33043:222;;;;:::o;33271:129::-;33305:6;33332:20;;:::i;:::-;33322:30;;33361:33;33389:4;33381:6;33361:33;:::i;:::-;33271:129;;;:::o;33406:75::-;33439:6;33472:2;33466:9;33456:19;;33406:75;:::o;33487:307::-;33548:4;33638:18;33630:6;33627:30;33624:56;;;33660:18;;:::i;:::-;33624:56;33698:29;33720:6;33698:29;:::i;:::-;33690:37;;33782:4;33776;33772:15;33764:23;;33487:307;;;:::o;33800:132::-;33867:4;33890:3;33882:11;;33920:4;33915:3;33911:14;33903:22;;33800:132;;;:::o;33938:114::-;34005:6;34039:5;34033:12;34023:22;;33938:114;;;:::o;34058:98::-;34109:6;34143:5;34137:12;34127:22;;34058:98;;;:::o;34162:99::-;34214:6;34248:5;34242:12;34232:22;;34162:99;;;:::o;34267:113::-;34337:4;34369;34364:3;34360:14;34352:22;;34267:113;;;:::o;34386:184::-;34485:11;34519:6;34514:3;34507:19;34559:4;34554:3;34550:14;34535:29;;34386:184;;;;:::o;34576:168::-;34659:11;34693:6;34688:3;34681:19;34733:4;34728:3;34724:14;34709:29;;34576:168;;;;:::o;34750:147::-;34851:11;34888:3;34873:18;;34750:147;;;;:::o;34903:169::-;34987:11;35021:6;35016:3;35009:19;35061:4;35056:3;35052:14;35037:29;;34903:169;;;;:::o;35078:148::-;35180:11;35217:3;35202:18;;35078:148;;;;:::o;35232:305::-;35272:3;35291:20;35309:1;35291:20;:::i;:::-;35286:25;;35325:20;35343:1;35325:20;:::i;:::-;35320:25;;35479:1;35411:66;35407:74;35404:1;35401:81;35398:107;;;35485:18;;:::i;:::-;35398:107;35529:1;35526;35522:9;35515:16;;35232:305;;;;:::o;35543:185::-;35583:1;35600:20;35618:1;35600:20;:::i;:::-;35595:25;;35634:20;35652:1;35634:20;:::i;:::-;35629:25;;35673:1;35663:35;;35678:18;;:::i;:::-;35663:35;35720:1;35717;35713:9;35708:14;;35543:185;;;;:::o;35734:348::-;35774:7;35797:20;35815:1;35797:20;:::i;:::-;35792:25;;35831:20;35849:1;35831:20;:::i;:::-;35826:25;;36019:1;35951:66;35947:74;35944:1;35941:81;35936:1;35929:9;35922:17;35918:105;35915:131;;;36026:18;;:::i;:::-;35915:131;36074:1;36071;36067:9;36056:20;;35734:348;;;;:::o;36088:191::-;36128:4;36148:20;36166:1;36148:20;:::i;:::-;36143:25;;36182:20;36200:1;36182:20;:::i;:::-;36177:25;;36221:1;36218;36215:8;36212:34;;;36226:18;;:::i;:::-;36212:34;36271:1;36268;36264:9;36256:17;;36088:191;;;;:::o;36285:96::-;36322:7;36351:24;36369:5;36351:24;:::i;:::-;36340:35;;36285:96;;;:::o;36387:104::-;36432:7;36461:24;36479:5;36461:24;:::i;:::-;36450:35;;36387:104;;;:::o;36497:90::-;36531:7;36574:5;36567:13;36560:21;36549:32;;36497:90;;;:::o;36593:149::-;36629:7;36669:66;36662:5;36658:78;36647:89;;36593:149;;;:::o;36748:126::-;36785:7;36825:42;36818:5;36814:54;36803:65;;36748:126;;;:::o;36880:77::-;36917:7;36946:5;36935:16;;36880:77;;;:::o;36963:134::-;37021:9;37054:37;37085:5;37054:37;:::i;:::-;37041:50;;36963:134;;;:::o;37103:126::-;37153:9;37186:37;37217:5;37186:37;:::i;:::-;37173:50;;37103:126;;;:::o;37235:113::-;37285:9;37318:24;37336:5;37318:24;:::i;:::-;37305:37;;37235:113;;;:::o;37354:154::-;37438:6;37433:3;37428;37415:30;37500:1;37491:6;37486:3;37482:16;37475:27;37354:154;;;:::o;37514:307::-;37582:1;37592:113;37606:6;37603:1;37600:13;37592:113;;;37691:1;37686:3;37682:11;37676:18;37672:1;37667:3;37663:11;37656:39;37628:2;37625:1;37621:10;37616:15;;37592:113;;;37723:6;37720:1;37717:13;37714:101;;;37803:1;37794:6;37789:3;37785:16;37778:27;37714:101;37563:258;37514:307;;;:::o;37827:320::-;37871:6;37908:1;37902:4;37898:12;37888:22;;37955:1;37949:4;37945:12;37976:18;37966:81;;38032:4;38024:6;38020:17;38010:27;;37966:81;38094:2;38086:6;38083:14;38063:18;38060:38;38057:84;;;38113:18;;:::i;:::-;38057:84;37878:269;37827:320;;;:::o;38153:281::-;38236:27;38258:4;38236:27;:::i;:::-;38228:6;38224:40;38366:6;38354:10;38351:22;38330:18;38318:10;38315:34;38312:62;38309:88;;;38377:18;;:::i;:::-;38309:88;38417:10;38413:2;38406:22;38196:238;38153:281;;:::o;38440:233::-;38479:3;38502:24;38520:5;38502:24;:::i;:::-;38493:33;;38548:66;38541:5;38538:77;38535:103;;;38618:18;;:::i;:::-;38535:103;38665:1;38658:5;38654:13;38647:20;;38440:233;;;:::o;38679:176::-;38711:1;38728:20;38746:1;38728:20;:::i;:::-;38723:25;;38762:20;38780:1;38762:20;:::i;:::-;38757:25;;38801:1;38791:35;;38806:18;;:::i;:::-;38791:35;38847:1;38844;38840:9;38835:14;;38679:176;;;;:::o;38861:180::-;38909:77;38906:1;38899:88;39006:4;39003:1;38996:15;39030:4;39027:1;39020:15;39047:180;39095:77;39092:1;39085:88;39192:4;39189:1;39182:15;39216:4;39213:1;39206:15;39233:180;39281:77;39278:1;39271:88;39378:4;39375:1;39368:15;39402:4;39399:1;39392:15;39419:180;39467:77;39464:1;39457:88;39564:4;39561:1;39554:15;39588:4;39585:1;39578:15;39605:180;39653:77;39650:1;39643:88;39750:4;39747:1;39740:15;39774:4;39771:1;39764:15;39791:117;39900:1;39897;39890:12;39914:117;40023:1;40020;40013:12;40037:117;40146:1;40143;40136:12;40160:117;40269:1;40266;40259:12;40283:102;40324:6;40375:2;40371:7;40366:2;40359:5;40355:14;40351:28;40341:38;;40283:102;;;:::o;40391:237::-;40531:34;40527:1;40519:6;40515:14;40508:58;40600:20;40595:2;40587:6;40583:15;40576:45;40391:237;:::o;40634:173::-;40774:25;40770:1;40762:6;40758:14;40751:49;40634:173;:::o;40813:225::-;40953:34;40949:1;40941:6;40937:14;40930:58;41022:8;41017:2;41009:6;41005:15;40998:33;40813:225;:::o;41044:180::-;41184:32;41180:1;41172:6;41168:14;41161:56;41044:180;:::o;41230:178::-;41370:30;41366:1;41358:6;41354:14;41347:54;41230:178;:::o;41414:227::-;41554:34;41550:1;41542:6;41538:14;41531:58;41623:10;41618:2;41610:6;41606:15;41599:35;41414:227;:::o;41647:225::-;41787:34;41783:1;41775:6;41771:14;41764:58;41856:8;41851:2;41843:6;41839:15;41832:33;41647:225;:::o;41878:223::-;42018:34;42014:1;42006:6;42002:14;41995:58;42087:6;42082:2;42074:6;42070:15;42063:31;41878:223;:::o;42107:175::-;42247:27;42243:1;42235:6;42231:14;42224:51;42107:175;:::o;42288:168::-;42428:20;42424:1;42416:6;42412:14;42405:44;42288:168;:::o;42462:245::-;42602:34;42598:1;42590:6;42586:14;42579:58;42671:28;42666:2;42658:6;42654:15;42647:53;42462:245;:::o;42713:179::-;42853:31;42849:1;42841:6;42837:14;42830:55;42713:179;:::o;42898:231::-;43038:34;43034:1;43026:6;43022:14;43015:58;43107:14;43102:2;43094:6;43090:15;43083:39;42898:231;:::o;43135:230::-;43275:34;43271:1;43263:6;43259:14;43252:58;43344:13;43339:2;43331:6;43327:15;43320:38;43135:230;:::o;43371:243::-;43511:34;43507:1;43499:6;43495:14;43488:58;43580:26;43575:2;43567:6;43563:15;43556:51;43371:243;:::o;43620:229::-;43760:34;43756:1;43748:6;43744:14;43737:58;43829:12;43824:2;43816:6;43812:15;43805:37;43620:229;:::o;43855:228::-;43995:34;43991:1;43983:6;43979:14;43972:58;44064:11;44059:2;44051:6;44047:15;44040:36;43855:228;:::o;44089:182::-;44229:34;44225:1;44217:6;44213:14;44206:58;44089:182;:::o;44277:::-;44417:34;44413:1;44405:6;44401:14;44394:58;44277:182;:::o;44465:231::-;44605:34;44601:1;44593:6;44589:14;44582:58;44674:14;44669:2;44661:6;44657:15;44650:39;44465:231;:::o;44702:182::-;44842:34;44838:1;44830:6;44826:14;44819:58;44702:182;:::o;44890:228::-;45030:34;45026:1;45018:6;45014:14;45007:58;45099:11;45094:2;45086:6;45082:15;45075:36;44890:228;:::o;45124:234::-;45264:34;45260:1;45252:6;45248:14;45241:58;45333:17;45328:2;45320:6;45316:15;45309:42;45124:234;:::o;45364:220::-;45504:34;45500:1;45492:6;45488:14;45481:58;45573:3;45568:2;45560:6;45556:15;45549:28;45364:220;:::o;45590:114::-;;:::o;45710:236::-;45850:34;45846:1;45838:6;45834:14;45827:58;45919:19;45914:2;45906:6;45902:15;45895:44;45710:236;:::o;45952:122::-;46025:24;46043:5;46025:24;:::i;:::-;46018:5;46015:35;46005:63;;46064:1;46061;46054:12;46005:63;45952:122;:::o;46080:138::-;46161:32;46187:5;46161:32;:::i;:::-;46154:5;46151:43;46141:71;;46208:1;46205;46198:12;46141:71;46080:138;:::o;46224:116::-;46294:21;46309:5;46294:21;:::i;:::-;46287:5;46284:32;46274:60;;46330:1;46327;46320:12;46274:60;46224:116;:::o;46346:120::-;46418:23;46435:5;46418:23;:::i;:::-;46411:5;46408:34;46398:62;;46456:1;46453;46446:12;46398:62;46346:120;:::o;46472:122::-;46545:24;46563:5;46545:24;:::i;:::-;46538:5;46535:35;46525:63;;46584:1;46581;46574:12;46525:63;46472:122;:::o

ipfs://95a0a8968eaca25124abaeb7d33d3ce077629d1e863da58e9ef2fbcec2292999