Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• library EnumerableMap
•    - function set(Bytes32ToBytes32Map stor ...
•    - function remove(Bytes32ToBytes32Map s ...
•    - function contains(Bytes32ToBytes32Map ...
•    - function length(Bytes32ToBytes32Map s ...
•    - function at(Bytes32ToBytes32Map stora ...
•    - function tryGet(Bytes32ToBytes32Map s ...
•    - function get(Bytes32ToBytes32Map stor ...
•    - function get(
•    - function keys(Bytes32ToBytes32Map sto ...
•    - function set(UintToUintMap storage ma ...
•    - function remove(UintToUintMap storage ...
•    - function contains(UintToUintMap stora ...
•    - function length(UintToUintMap storage ...
•    - function at(UintToUintMap storage map ...
•    - function tryGet(UintToUintMap storage ...
•    - function get(UintToUintMap storage ma ...
•    - function get(UintToUintMap storage ma ...
•    - function keys(UintToUintMap storage m ...
•    - function set(UintToAddressMap storage ...
•    - function remove(UintToAddressMap stor ...
•    - function contains(UintToAddressMap st ...
•    - function length(UintToAddressMap stor ...
•    - function at(UintToAddressMap storage ...
•    - function tryGet(UintToAddressMap stor ...
•    - function get(UintToAddressMap storage ...
•    - function get(
•    - function keys(UintToAddressMap storag ...
•    - function set(AddressToUintMap storage ...
•    - function remove(AddressToUintMap stor ...
•    - function contains(AddressToUintMap st ...
•    - function length(AddressToUintMap stor ...
•    - function at(AddressToUintMap storage ...
•    - function tryGet(AddressToUintMap stor ...
•    - function get(AddressToUintMap storage ...
•    - function get(
•    - function keys(AddressToUintMap storag ...
•    - function set(Bytes32ToUintMap storage ...
•    - function remove(Bytes32ToUintMap stor ...
•    - function contains(Bytes32ToUintMap st ...
•    - function length(Bytes32ToUintMap stor ...
•    - function at(Bytes32ToUintMap storage ...
•    - function tryGet(Bytes32ToUintMap stor ...
•    - function get(Bytes32ToUintMap storage ...
•    - function get(
•    - function keys(Bytes32ToUintMap storag ...
•  contract Lottery *
•    - function pickWinner()
•    - function getParticipants(uint _roundI ...
•    - function getRound(uint _roundId)
•    - function getCurrentRound()
•    - function setFeeAddress(address _feeAd ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-07-19
*/

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol

/**
 * @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.
 *
 * ```solidity
 * 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.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
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) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

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

        /// @solidity memory-safe-assembly
        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 in 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;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: @openzeppelin/contracts/utils/structs/EnumerableMap.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableMap.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableMap.js.

/**
 * @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.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * The following map types are supported:
 *
 * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
 * - `address -> uint256` (`AddressToUintMap`) since v4.6.0
 * - `bytes32 -> bytes32` (`Bytes32ToBytes32Map`) since v4.6.0
 * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0
 * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableMap.
 * ====
 */
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 Bytes32ToBytes32Map {
        // 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(Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value) internal 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(Bytes32ToBytes32Map storage map, bytes32 key) internal 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(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
        return map._keys.contains(key);
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function length(Bytes32ToBytes32Map storage map) internal 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(Bytes32ToBytes32Map storage map, uint256 index) internal 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(Bytes32ToBytes32Map storage map, bytes32 key) internal 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(Bytes32ToBytes32Map storage map, bytes32 key) internal 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(
        Bytes32ToBytes32Map storage map,
        bytes32 key,
        string memory errorMessage
    ) internal view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || contains(map, key), errorMessage);
        return value;
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * 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 map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(Bytes32ToBytes32Map storage map) internal view returns (bytes32[] memory) {
        return map._keys.values();
    }

    // UintToUintMap

    struct UintToUintMap {
        Bytes32ToBytes32Map _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(UintToUintMap storage map, uint256 key, uint256 value) internal returns (bool) {
        return set(map._inner, bytes32(key), bytes32(value));
    }

    /**
     * @dev Removes a value from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToUintMap 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(UintToUintMap 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(UintToUintMap storage map) internal view returns (uint256) {
        return length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the map. 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(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (uint256(key), uint256(value));
    }

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

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
        return 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(UintToUintMap storage map, uint256 key, string memory errorMessage) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(key), errorMessage));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * 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 map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(UintToUintMap storage map) internal view returns (uint256[] memory) {
        bytes32[] memory store = keys(map._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Bytes32ToBytes32Map _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 map. 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 map. 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.
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

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

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

    /**
     * @dev Return the an array containing all the keys
     *
     * 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 map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(UintToAddressMap storage map) internal view returns (uint256[] memory) {
        bytes32[] memory store = keys(map._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressToUintMap

    struct AddressToUintMap {
        Bytes32ToBytes32Map _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(AddressToUintMap storage map, address key, uint256 value) internal returns (bool) {
        return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
    }

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

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

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

    /**
     * @dev Returns the element stored at position `index` in the map. 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(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (address(uint160(uint256(key))), uint256(value));
    }

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

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(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(
        AddressToUintMap storage map,
        address key,
        string memory errorMessage
    ) internal view returns (uint256) {
        return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * 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 map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(AddressToUintMap storage map) internal view returns (address[] memory) {
        bytes32[] memory store = keys(map._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // Bytes32ToUintMap

    struct Bytes32ToUintMap {
        Bytes32ToBytes32Map _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(Bytes32ToUintMap storage map, bytes32 key, uint256 value) internal returns (bool) {
        return set(map._inner, key, bytes32(value));
    }

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

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

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

    /**
     * @dev Returns the element stored at position `index` in the map. 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(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
        (bytes32 key, bytes32 value) = at(map._inner, index);
        return (key, uint256(value));
    }

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

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
        return uint256(get(map._inner, 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(
        Bytes32ToUintMap storage map,
        bytes32 key,
        string memory errorMessage
    ) internal view returns (uint256) {
        return uint256(get(map._inner, key, errorMessage));
    }

    /**
     * @dev Return the an array containing all the keys
     *
     * 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 map grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function keys(Bytes32ToUintMap storage map) internal view returns (bytes32[] memory) {
        bytes32[] memory store = keys(map._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: contracts/Lottery.sol

contract Lottery {
    using EnumerableMap for EnumerableMap.AddressToUintMap;
    // Declare state variables
    address public manager; // Address of the manager
    address public feeAddress; // Address to send fees to
    uint public roundId;
    
    struct LotteryRound {
        uint roundId; // ID of the round
        address winner; // Address of the winner
        uint winningAmount; // Amount of the prize
        EnumerableMap.AddressToUintMap participants; 
        uint totalEntries;
    }

    struct PublicLotteryRound {
        uint roundId; // ID of the round
        address winner; // Address of the winner
        uint winningAmount; // Amount of the prize
        address[] participants; // Map participant addresses to the number of entries
    }

    // Declare mapping to store lottery rounds
    mapping(uint => LotteryRound) private lotteryRounds; // Map round IDs to LotteryRound structs
    
    // Declare constants
    uint public constant ENTRY_FEE = 0.01 ether; // Entry fee for the lottery
    uint public constant FEE_PCNT = 11; // Percentage of the prize to take as a fee

    // Constructor function
    constructor() {
        manager = msg.sender; // Set the manager to the contract creator
        feeAddress = msg.sender; // Set the fee address to the contract creator
        roundId = 1;
    }

    // Function for entering the lottery
    receive() external payable {
        require(msg.value >= ENTRY_FEE, "Minimum entry fee is 0.01 ether"); // Require the entry fee to be at least 0.01 ether
        uint numberOfEntries = msg.value / ENTRY_FEE; // Calculate the number of entries based on the amount sent
        LotteryRound storage round = lotteryRounds[roundId];
        (bool exist, uint _entries) = round.participants.tryGet(msg.sender);
        if (exist) {
            round.participants.set(msg.sender, _entries + numberOfEntries);
        } else {
            round.participants.set(msg.sender, numberOfEntries);
        }
        round.totalEntries += numberOfEntries;
    }


    // Function for picking a winner
    function pickWinner() public restricted {
        require(lotteryRounds[roundId].totalEntries > 0, "There are no players in the lottery"); // Require there to be at least one player in the lottery
        
        address[] memory _addresses = getParticipants(roundId);
        
        uint index = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), _addresses))) % _addresses.length;
        address winner = _addresses[index]; // Select the winner based on the random index
        uint winningAmount = address(this).balance; // Get the current balance of the contract as the winning amount
        uint fee = winningAmount / 100 * FEE_PCNT; // Calculate the fee as a percentage of the winning amount
        uint prize = winningAmount - fee; // Calculate the prize after the fee is taken

        lotteryRounds[roundId].winner = winner; // Set the winner address
        lotteryRounds[roundId].winningAmount = winningAmount; // Set the winner address

        roundId++;
        payable(feeAddress).transfer(fee); // Send the fee to the predefined fee address
        payable(winner).transfer(prize); // Send the prize to the winner
    }
    
    function getParticipants(uint _roundId) public view returns (address[] memory) {
        uint total = lotteryRounds[_roundId].totalEntries;
        address[] memory _addresses = new address[](total);
        
        for (uint i = 0; i < lotteryRounds[_roundId].participants.length(); i++) { // Loop through the participants array
            (address participant, uint entries) = lotteryRounds[_roundId].participants.at(i);
            for (uint j = 0; j < entries; j++) { // Loop through the number of entries for each player
                _addresses[total - 1] = participant;
                total--;
            }
        }
        return _addresses;
    }

    // Function for getting a specific round
    function getRound(uint _roundId) public view returns (PublicLotteryRound memory) {
        return PublicLotteryRound(_roundId, lotteryRounds[_roundId].winner, lotteryRounds[_roundId].winningAmount, getParticipants(_roundId));
    }

   // Function for getting a current round
    function getCurrentRound() public view returns (PublicLotteryRound memory) {
        return PublicLotteryRound(roundId, lotteryRounds[roundId].winner, address(this).balance, getParticipants(roundId));
    }

    // // Function for setting the fee address
    function setFeeAddress(address _feeAddress) public restricted {
        feeAddress = _feeAddress;
    }

    // Modifier for restricting access to certain functions
    modifier restricted() {
        require(msg.sender == manager, "Only the manager can call this function"); // Require the caller to be the manager
        _; // Continue executing the function
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ENTRY_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEE_PCNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentRound","outputs":[{"components":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"address","name":"winner","type":"address"},{"internalType":"uint256","name":"winningAmount","type":"uint256"},{"internalType":"address[]","name":"participants","type":"address[]"}],"internalType":"struct Lottery.PublicLotteryRound","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_roundId","type":"uint256"}],"name":"getParticipants","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_roundId","type":"uint256"}],"name":"getRound","outputs":[{"components":[{"internalType":"uint256","name":"roundId","type":"uint256"},{"internalType":"address","name":"winner","type":"address"},{"internalType":"uint256","name":"winningAmount","type":"uint256"},{"internalType":"address[]","name":"participants","type":"address[]"}],"internalType":"struct Lottery.PublicLotteryRound","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pickWinner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"roundId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106100955760003560e01c80638cd221c9116100595780638cd221c91461025c5780638f1327c014610287578063a32bf597146102c4578063c1e3bd3e146102ef578063f6d361cc1461032c57610196565b8063261c15a31461019b57806341275358146101c6578063481c6a75146101f15780635d495aea1461021c5780638705fcd41461023357610196565b3661019657662386f26fc100003410156100e4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100db90610d64565b60405180910390fd5b6000662386f26fc10000346100f99190610dec565b90506000600360006002548152602001908152602001600020905060008061012d338460030161035790919063ffffffff16565b9150915081156101605761015a3385836101479190610e1d565b856003016103999092919063ffffffff16565b5061017a565b6101783385856003016103999092919063ffffffff16565b505b8383600601600082825461018e9190610e1d565b925050819055005b600080fd5b3480156101a757600080fd5b506101b06103ce565b6040516101bd9190610e60565b60405180910390f35b3480156101d257600080fd5b506101db6103d3565b6040516101e89190610ebc565b60405180910390f35b3480156101fd57600080fd5b506102066103f9565b6040516102139190610ebc565b60405180910390f35b34801561022857600080fd5b5061023161041d565b005b34801561023f57600080fd5b5061025a60048036038101906102559190610f08565b6106f3565b005b34801561026857600080fd5b506102716107c5565b60405161027e9190610e60565b60405180910390f35b34801561029357600080fd5b506102ae60048036038101906102a99190610f61565b6107cb565b6040516102bb91906110be565b60405180910390f35b3480156102d057600080fd5b506102d9610865565b6040516102e691906110be565b60405180910390f35b3480156102fb57600080fd5b5061031660048036038101906103119190610f61565b6108ed565b604051610323919061114f565b60405180910390f35b34801561033857600080fd5b50610341610a55565b60405161034e9190610e60565b60405180910390f35b600080600080610383866000018673ffffffffffffffffffffffffffffffffffffffff1660001b610a60565b91509150818160001c9350935050509250929050565b60006103c5846000018473ffffffffffffffffffffffffffffffffffffffff1660001b8460001b610aaf565b90509392505050565b600b81565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146104ab576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104a2906111e3565b60405180910390fd5b60006003600060025481526020019081526020016000206006015411610506576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104fd90611275565b60405180910390fd5b60006105136002546108ed565b9050600081516001436105269190611295565b4083604051602001610539929190611384565b6040516020818303038152906040528051906020012060001c61055c91906113ac565b90506000828281518110610573576105726113dd565b5b6020026020010151905060004790506000600b6064836105939190610dec565b61059d919061140c565b9050600081836105ad9190611295565b90508360036000600254815260200190815260200160002060010160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508260036000600254815260200190815260200160002060020181905550600260008154809291906106369061144e565b9190505550600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166108fc839081150290604051600060405180830381858888f193505050501580156106a3573d6000803e3d6000fd5b508373ffffffffffffffffffffffffffffffffffffffff166108fc829081150290604051600060405180830381858888f193505050501580156106ea573d6000803e3d6000fd5b50505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610781576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610778906111e3565b60405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60025481565b6107d3610cc9565b60405180608001604052808381526020016003600085815260200190815260200160002060010160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020016003600085815260200190815260200160002060020154815260200161085b846108ed565b8152509050919050565b61086d610cc9565b6040518060800160405280600254815260200160036000600254815260200190815260200160002060010160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020014781526020016108e56002546108ed565b815250905090565b606060006003600084815260200190815260200160002060060154905060008167ffffffffffffffff81111561092657610925611496565b5b6040519080825280602002602001820160405280156109545781602001602082028036833780820191505090505b50905060005b61097860036000878152602001908152602001600020600301610aea565b811015610a4a576000806109aa83600360008a8152602001908152602001600020600301610aff90919063ffffffff16565b9150915060005b81811015610a345782856001886109c89190611295565b815181106109d9576109d86113dd565b5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff16815250508580610a1e906114c5565b9650508080610a2c9061144e565b9150506109b1565b5050508080610a429061144e565b91505061095a565b508092505050919050565b662386f26fc1000081565b60008060008460020160008581526020019081526020016000205490506000801b8103610a9f57610a918585610b2b565b6000801b9250925050610aa8565b60018192509250505b9250929050565b60008184600201600085815260200190815260200160002081905550610ae18385600001610b4b90919063ffffffff16565b90509392505050565b6000610af882600001610b62565b9050919050565b600080600080610b128660000186610b77565b915091508160001c8160001c9350935050509250929050565b6000610b438284600001610bb790919063ffffffff16565b905092915050565b6000610b5a8360000183610bce565b905092915050565b6000610b7082600001610c3e565b9050919050565b6000806000610b928486600001610c5390919063ffffffff16565b9050808560020160008381526020019081526020016000205492509250509250929050565b6000610bc68360000183610c6a565b905092915050565b6000610bda8383610c6a565b610c33578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050610c38565b600090505b92915050565b6000610c4c82600001610c8d565b9050919050565b6000610c628360000183610c9e565b905092915050565b600080836001016000848152602001908152602001600020541415905092915050565b600081600001805490509050919050565b6000826000018281548110610cb657610cb56113dd565b5b9060005260206000200154905092915050565b604051806080016040528060008152602001600073ffffffffffffffffffffffffffffffffffffffff16815260200160008152602001606081525090565b600082825260208201905092915050565b7f4d696e696d756d20656e7472792066656520697320302e303120657468657200600082015250565b6000610d4e601f83610d07565b9150610d5982610d18565b602082019050919050565b60006020820190508181036000830152610d7d81610d41565b9050919050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000610df782610d84565b9150610e0283610d84565b925082610e1257610e11610d8e565b5b828204905092915050565b6000610e2882610d84565b9150610e3383610d84565b9250828201905080821115610e4b57610e4a610dbd565b5b92915050565b610e5a81610d84565b82525050565b6000602082019050610e756000830184610e51565b92915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000610ea682610e7b565b9050919050565b610eb681610e9b565b82525050565b6000602082019050610ed16000830184610ead565b92915050565b600080fd5b610ee581610e9b565b8114610ef057600080fd5b50565b600081359050610f0281610edc565b92915050565b600060208284031215610f1e57610f1d610ed7565b5b6000610f2c84828501610ef3565b91505092915050565b610f3e81610d84565b8114610f4957600080fd5b50565b600081359050610f5b81610f35565b92915050565b600060208284031215610f7757610f76610ed7565b5b6000610f8584828501610f4c565b91505092915050565b610f9781610d84565b82525050565b610fa681610e9b565b82525050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b6000610fe48383610f9d565b60208301905092915050565b6000602082019050919050565b600061100882610fac565b6110128185610fb7565b935061101d83610fc8565b8060005b8381101561104e5781516110358882610fd8565b975061104083610ff0565b925050600181019050611021565b5085935050505092915050565b60006080830160008301516110736000860182610f8e565b5060208301516110866020860182610f9d565b5060408301516110996040860182610f8e565b50606083015184820360608601526110b18282610ffd565b9150508091505092915050565b600060208201905081810360008301526110d8818461105b565b905092915050565b600082825260208201905092915050565b60006110fc82610fac565b61110681856110e0565b935061111183610fc8565b8060005b838110156111425781516111298882610fd8565b975061113483610ff0565b925050600181019050611115565b5085935050505092915050565b6000602082019050818103600083015261116981846110f1565b905092915050565b7f4f6e6c7920746865206d616e616765722063616e2063616c6c2074686973206660008201527f756e6374696f6e00000000000000000000000000000000000000000000000000602082015250565b60006111cd602783610d07565b91506111d882611171565b604082019050919050565b600060208201905081810360008301526111fc816111c0565b9050919050565b7f546865726520617265206e6f20706c617965727320696e20746865206c6f747460008201527f6572790000000000000000000000000000000000000000000000000000000000602082015250565b600061125f602383610d07565b915061126a82611203565b604082019050919050565b6000602082019050818103600083015261128e81611252565b9050919050565b60006112a082610d84565b91506112ab83610d84565b92508282039050818111156112c3576112c2610dbd565b5b92915050565b6000819050919050565b6000819050919050565b6112ee6112e9826112c9565b6112d3565b82525050565b600081905092915050565b61130881610e9b565b82525050565b600061131a83836112ff565b60208301905092915050565b600061133182610fac565b61133b81856112f4565b935061134683610fc8565b8060005b8381101561137757815161135e888261130e565b975061136983610ff0565b92505060018101905061134a565b5085935050505092915050565b600061139082856112dd565b6020820191506113a08284611326565b91508190509392505050565b60006113b782610d84565b91506113c283610d84565b9250826113d2576113d1610d8e565b5b828206905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600061141782610d84565b915061142283610d84565b925082820261143081610d84565b9150828204841483151761144757611446610dbd565b5b5092915050565b600061145982610d84565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361148b5761148a610dbd565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60006114d082610d84565b9150600082036114e3576114e2610dbd565b5b60018203905091905056fea264697066735822122060ff13ad08d173f11db2e2917a4ffb7985ea0f33c781e1336070be7d6aa2eb0164736f6c63430008120033

35355:4966:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36366:10;36823:9;:22;;36815:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;36943:20;36366:10;36966:9;:21;;;;:::i;:::-;36943:44;;37058:26;37087:13;:22;37101:7;;37087:22;;;;;;;;;;;37058:51;;37121:10;37133:13;37150:37;37176:10;37150:5;:18;;:25;;:37;;;;:::i;:::-;37120:67;;;;37202:5;37198:184;;;37224:62;37247:10;37270:15;37259:8;:26;;;;:::i;:::-;37224:5;:18;;:22;;:62;;;;;:::i;:::-;;37198:184;;;37319:51;37342:10;37354:15;37319:5;:18;;:22;;:51;;;;;:::i;:::-;;37198:184;37414:15;37392:5;:18;;;:37;;;;;;;:::i;:::-;;;;;;;;35355:4966;;;;36412:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35527:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35472:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37485:1169;;;;;;;;;;;;;:::i;:::-;;39943:105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35586:19;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39394:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39679:208;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38666:674;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36333:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29510:241;29592:4;29598:7;29619:12;29633:13;29650:50;29657:3;:10;;29693:3;29677:21;;29669:30;;29650:6;:50::i;:::-;29618:82;;;;29719:7;29736:5;29728:14;;29711:32;;;;;;29510:241;;;;;:::o;27809:184::-;27898:4;27922:63;27926:3;:10;;27962:3;27946:21;;27938:30;;27978:5;27970:14;;27922:3;:63::i;:::-;27915:70;;27809:184;;;;;:::o;36412:34::-;36444:2;36412:34;:::o;35527:25::-;;;;;;;;;;;;;:::o;35472:22::-;;;;;;;;;;;;:::o;37485:1169::-;40172:7;;;;;;;;;;40158:21;;:10;:21;;;40150:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;37582:1:::1;37544:13;:22;37558:7;;37544:22;;;;;;;;;;;:35;;;:39;37536:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;37702:27;37732:24;37748:7;;37732:15;:24::i;:::-;37702:54;;37777:10;37867;:17;37847:1;37832:12;:16;;;;:::i;:::-;37822:27;37851:10;37805:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;37795:68;;;;;;37790:74;;:94;;;;:::i;:::-;37777:107;;37895:14;37912:10;37923:5;37912:17;;;;;;;;:::i;:::-;;;;;;;;37895:34;;37987:18;38008:21;37987:42;;38105:8;36444:2;38132:3;38116:13;:19;;;;:::i;:::-;:30;;;;:::i;:::-;38105:41;;38216:10;38245:3;38229:13;:19;;;;:::i;:::-;38216:32;;38339:6;38307:13;:22;38321:7;;38307:22;;;;;;;;;;;:29;;;:38;;;;;;;;;;;;;;;;;;38421:13;38382;:22;38396:7;;38382:22;;;;;;;;;;;:36;;:52;;;;38473:7;;:9;;;;;;;;;:::i;:::-;;;;;;38501:10;;;;;;;;;;;38493:28;;:33;38522:3;38493:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;38591:6;38583:24;;:31;38608:5;38583:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;37525:1129;;;;;;37485:1169::o:0;39943:105::-;40172:7;;;;;;;;;;40158:21;;:10;:21;;;40150:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;40029:11:::1;40016:10;;:24;;;;;;;;;;;;;;;;;;39943:105:::0;:::o;35586:19::-;;;;:::o;39394:233::-;39448:25;;:::i;:::-;39493:126;;;;;;;;39512:8;39493:126;;;;39522:13;:23;39536:8;39522:23;;;;;;;;;;;:30;;;;;;;;;;;;39493:126;;;;;;39554:13;:23;39568:8;39554:23;;;;;;;;;;;:37;;;39493:126;;;;39593:25;39609:8;39593:15;:25::i;:::-;39493:126;;;39486:133;;39394:233;;;:::o;39679:208::-;39727:25;;:::i;:::-;39772:107;;;;;;;;39791:7;;39772:107;;;;39800:13;:22;39814:7;;39800:22;;;;;;;;;;;:29;;;;;;;;;;;;39772:107;;;;;;39831:21;39772:107;;;;39854:24;39870:7;;39854:15;:24::i;:::-;39772:107;;;39765:114;;39679:208;:::o;38666:674::-;38727:16;38756:10;38769:13;:23;38783:8;38769:23;;;;;;;;;;;:36;;;38756:49;;38816:27;38860:5;38846:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38816:50;;38892:6;38887:418;38908:45;:13;:23;38922:8;38908:23;;;;;;;;;;;:36;;:43;:45::i;:::-;38904:1;:49;38887:418;;;39015:19;39036:12;39052:42;39092:1;39052:13;:23;39066:8;39052:23;;;;;;;;;;;:36;;:39;;:42;;;;:::i;:::-;39014:80;;;;39114:6;39109:185;39130:7;39126:1;:11;39109:185;;;39241:11;39217:10;39236:1;39228:5;:9;;;;:::i;:::-;39217:21;;;;;;;;:::i;:::-;;;;;;;:35;;;;;;;;;;;39271:7;;;;;:::i;:::-;;;;39139:3;;;;;:::i;:::-;;;;39109:185;;;;38960:345;;38955:3;;;;;:::i;:::-;;;;38887:418;;;;39322:10;39315:17;;;;38666:674;;;:::o;36333:43::-;36366:10;36333:43;:::o;17675:305::-;17760:4;17766:7;17786:13;17802:3;:11;;:16;17814:3;17802:16;;;;;;;;;;;;17786:32;;17850:1;17842:10;;17833:5;:19;17829:144;;17877:18;17886:3;17891;17877:8;:18::i;:::-;17905:1;17897:10;;17869:39;;;;;;;17829:144;17949:4;17955:5;17941:20;;;;;17675:305;;;;;;:::o;16004:177::-;16096:4;16132:5;16113:3;:11;;:16;16125:3;16113:16;;;;;;;;;;;:24;;;;16155:18;16169:3;16155;:9;;:13;;:18;;;;:::i;:::-;16148:25;;16004:177;;;;;:::o;28658:122::-;28727:7;28754:18;28761:3;:10;;28754:6;:18::i;:::-;28747:25;;28658:122;;;:::o;29128:235::-;29208:7;29217;29238:11;29251:13;29268:21;29271:3;:10;;29283:5;29268:2;:21::i;:::-;29237:52;;;;29332:3;29324:12;;29348:5;29340:14;;29300:55;;;;;;29128:235;;;;;:::o;16607:142::-;16694:4;16718:23;16737:3;16718;:9;;:18;;:23;;;;:::i;:::-;16711:30;;16607:142;;;;:::o;6159:125::-;6229:4;6253:23;6258:3;:10;;6270:5;6253:4;:23::i;:::-;6246:30;;6159:125;;;;:::o;16844:::-;16916:7;16943:18;:3;:9;;:16;:18::i;:::-;16936:25;;16844:125;;;:::o;17334:194::-;17417:7;17426;17446:11;17460:19;17473:5;17460:3;:9;;:12;;:19;;;;:::i;:::-;17446:33;;17498:3;17503;:11;;:16;17515:3;17503:16;;;;;;;;;;;;17490:30;;;;;17334:194;;;;;:::o;6677:140::-;6757:4;6781:28;6791:3;:10;;6803:5;6781:9;:28::i;:::-;6774:35;;6677:140;;;;:::o;2350:414::-;2413:4;2435:21;2445:3;2450:5;2435:9;:21::i;:::-;2430:327;;2473:3;:11;;2490:5;2473:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2656:3;:11;;:18;;;;2634:3;:12;;:19;2647:5;2634:19;;;;;;;;;;;:40;;;;2696:4;2689:11;;;;2430:327;2740:5;2733:12;;2350:414;;;;;:::o;6903:117::-;6966:7;6993:19;7001:3;:10;;6993:7;:19::i;:::-;6986:26;;6903:117;;;:::o;7374:131::-;7448:7;7475:22;7479:3;:10;;7491:5;7475:3;:22::i;:::-;7468:29;;7374:131;;;;:::o;4446:129::-;4519:4;4566:1;4543:3;:12;;:19;4556:5;4543:19;;;;;;;;;;;;:24;;4536:31;;4446:129;;;;:::o;4661:109::-;4717:7;4744:3;:11;;:18;;;;4737:25;;4661:109;;;:::o;5124:120::-;5191:7;5218:3;:11;;5230:5;5218:18;;;;;;;;:::i;:::-;;;;;;;;;;5211:25;;5124:120;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7:169:1:-;91:11;125:6;120:3;113:19;165:4;160:3;156:14;141:29;;7:169;;;;:::o;182:181::-;322:33;318:1;310:6;306:14;299:57;182:181;:::o;369:366::-;511:3;532:67;596:2;591:3;532:67;:::i;:::-;525:74;;608:93;697:3;608:93;:::i;:::-;726:2;721:3;717:12;710:19;;369:366;;;:::o;741:419::-;907:4;945:2;934:9;930:18;922:26;;994:9;988:4;984:20;980:1;969:9;965:17;958:47;1022:131;1148:4;1022:131;:::i;:::-;1014:139;;741:419;;;:::o;1166:77::-;1203:7;1232:5;1221:16;;1166:77;;;:::o;1249:180::-;1297:77;1294:1;1287:88;1394:4;1391:1;1384:15;1418:4;1415:1;1408:15;1435:180;1483:77;1480:1;1473:88;1580:4;1577:1;1570:15;1604:4;1601:1;1594:15;1621:185;1661:1;1678:20;1696:1;1678:20;:::i;:::-;1673:25;;1712:20;1730:1;1712:20;:::i;:::-;1707:25;;1751:1;1741:35;;1756:18;;:::i;:::-;1741:35;1798:1;1795;1791:9;1786:14;;1621:185;;;;:::o;1812:191::-;1852:3;1871:20;1889:1;1871:20;:::i;:::-;1866:25;;1905:20;1923:1;1905:20;:::i;:::-;1900:25;;1948:1;1945;1941:9;1934:16;;1969:3;1966:1;1963:10;1960:36;;;1976:18;;:::i;:::-;1960:36;1812:191;;;;:::o;2009:118::-;2096:24;2114:5;2096:24;:::i;:::-;2091:3;2084:37;2009:118;;:::o;2133:222::-;2226:4;2264:2;2253:9;2249:18;2241:26;;2277:71;2345:1;2334:9;2330:17;2321:6;2277:71;:::i;:::-;2133:222;;;;:::o;2361:126::-;2398:7;2438:42;2431:5;2427:54;2416:65;;2361:126;;;:::o;2493:96::-;2530:7;2559:24;2577:5;2559:24;:::i;:::-;2548:35;;2493:96;;;:::o;2595:118::-;2682:24;2700:5;2682:24;:::i;:::-;2677:3;2670:37;2595:118;;:::o;2719:222::-;2812:4;2850:2;2839:9;2835:18;2827:26;;2863:71;2931:1;2920:9;2916:17;2907:6;2863:71;:::i;:::-;2719:222;;;;:::o;3028:117::-;3137:1;3134;3127:12;3274:122;3347:24;3365:5;3347:24;:::i;:::-;3340:5;3337:35;3327:63;;3386:1;3383;3376:12;3327:63;3274:122;:::o;3402:139::-;3448:5;3486:6;3473:20;3464:29;;3502:33;3529:5;3502:33;:::i;:::-;3402:139;;;;:::o;3547:329::-;3606:6;3655:2;3643:9;3634:7;3630:23;3626:32;3623:119;;;3661:79;;:::i;:::-;3623:119;3781:1;3806:53;3851:7;3842:6;3831:9;3827:22;3806:53;:::i;:::-;3796:63;;3752:117;3547:329;;;;:::o;3882:122::-;3955:24;3973:5;3955:24;:::i;:::-;3948:5;3945:35;3935:63;;3994:1;3991;3984:12;3935:63;3882:122;:::o;4010:139::-;4056:5;4094:6;4081:20;4072:29;;4110:33;4137:5;4110:33;:::i;:::-;4010:139;;;;:::o;4155:329::-;4214:6;4263:2;4251:9;4242:7;4238:23;4234:32;4231:119;;;4269:79;;:::i;:::-;4231:119;4389:1;4414:53;4459:7;4450:6;4439:9;4435:22;4414:53;:::i;:::-;4404:63;;4360:117;4155:329;;;;:::o;4490:108::-;4567:24;4585:5;4567:24;:::i;:::-;4562:3;4555:37;4490:108;;:::o;4604:::-;4681:24;4699:5;4681:24;:::i;:::-;4676:3;4669:37;4604:108;;:::o;4718:114::-;4785:6;4819:5;4813:12;4803:22;;4718:114;;;:::o;4838:174::-;4927:11;4961:6;4956:3;4949:19;5001:4;4996:3;4992:14;4977:29;;4838:174;;;;:::o;5018:132::-;5085:4;5108:3;5100:11;;5138:4;5133:3;5129:14;5121:22;;5018:132;;;:::o;5156:179::-;5225:10;5246:46;5288:3;5280:6;5246:46;:::i;:::-;5324:4;5319:3;5315:14;5301:28;;5156:179;;;;:::o;5341:113::-;5411:4;5443;5438:3;5434:14;5426:22;;5341:113;;;:::o;5490:712::-;5599:3;5628:54;5676:5;5628:54;:::i;:::-;5698:76;5767:6;5762:3;5698:76;:::i;:::-;5691:83;;5798:56;5848:5;5798:56;:::i;:::-;5877:7;5908:1;5893:284;5918:6;5915:1;5912:13;5893:284;;;5994:6;5988:13;6021:63;6080:3;6065:13;6021:63;:::i;:::-;6014:70;;6107:60;6160:6;6107:60;:::i;:::-;6097:70;;5953:224;5940:1;5937;5933:9;5928:14;;5893:284;;;5897:14;6193:3;6186:10;;5604:598;;;5490:712;;;;:::o;6286:1028::-;6427:3;6463:4;6458:3;6454:14;6553:4;6546:5;6542:16;6536:23;6572:63;6629:4;6624:3;6620:14;6606:12;6572:63;:::i;:::-;6478:167;6729:4;6722:5;6718:16;6712:23;6748:63;6805:4;6800:3;6796:14;6782:12;6748:63;:::i;:::-;6655:166;6912:4;6905:5;6901:16;6895:23;6931:63;6988:4;6983:3;6979:14;6965:12;6931:63;:::i;:::-;6831:173;7094:4;7087:5;7083:16;7077:23;7147:3;7141:4;7137:14;7130:4;7125:3;7121:14;7114:38;7173:103;7271:4;7257:12;7173:103;:::i;:::-;7165:111;;7014:273;7304:4;7297:11;;6432:882;6286:1028;;;;:::o;7320:417::-;7485:4;7523:2;7512:9;7508:18;7500:26;;7572:9;7566:4;7562:20;7558:1;7547:9;7543:17;7536:47;7600:130;7725:4;7716:6;7600:130;:::i;:::-;7592:138;;7320:417;;;;:::o;7743:184::-;7842:11;7876:6;7871:3;7864:19;7916:4;7911:3;7907:14;7892:29;;7743:184;;;;:::o;7963:732::-;8082:3;8111:54;8159:5;8111:54;:::i;:::-;8181:86;8260:6;8255:3;8181:86;:::i;:::-;8174:93;;8291:56;8341:5;8291:56;:::i;:::-;8370:7;8401:1;8386:284;8411:6;8408:1;8405:13;8386:284;;;8487:6;8481:13;8514:63;8573:3;8558:13;8514:63;:::i;:::-;8507:70;;8600:60;8653:6;8600:60;:::i;:::-;8590:70;;8446:224;8433:1;8430;8426:9;8421:14;;8386:284;;;8390:14;8686:3;8679:10;;8087:608;;;7963:732;;;;:::o;8701:373::-;8844:4;8882:2;8871:9;8867:18;8859:26;;8931:9;8925:4;8921:20;8917:1;8906:9;8902:17;8895:47;8959:108;9062:4;9053:6;8959:108;:::i;:::-;8951:116;;8701:373;;;;:::o;9080:226::-;9220:34;9216:1;9208:6;9204:14;9197:58;9289:9;9284:2;9276:6;9272:15;9265:34;9080:226;:::o;9312:366::-;9454:3;9475:67;9539:2;9534:3;9475:67;:::i;:::-;9468:74;;9551:93;9640:3;9551:93;:::i;:::-;9669:2;9664:3;9660:12;9653:19;;9312:366;;;:::o;9684:419::-;9850:4;9888:2;9877:9;9873:18;9865:26;;9937:9;9931:4;9927:20;9923:1;9912:9;9908:17;9901:47;9965:131;10091:4;9965:131;:::i;:::-;9957:139;;9684:419;;;:::o;10109:222::-;10249:34;10245:1;10237:6;10233:14;10226:58;10318:5;10313:2;10305:6;10301:15;10294:30;10109:222;:::o;10337:366::-;10479:3;10500:67;10564:2;10559:3;10500:67;:::i;:::-;10493:74;;10576:93;10665:3;10576:93;:::i;:::-;10694:2;10689:3;10685:12;10678:19;;10337:366;;;:::o;10709:419::-;10875:4;10913:2;10902:9;10898:18;10890:26;;10962:9;10956:4;10952:20;10948:1;10937:9;10933:17;10926:47;10990:131;11116:4;10990:131;:::i;:::-;10982:139;;10709:419;;;:::o;11134:194::-;11174:4;11194:20;11212:1;11194:20;:::i;:::-;11189:25;;11228:20;11246:1;11228:20;:::i;:::-;11223:25;;11272:1;11269;11265:9;11257:17;;11296:1;11290:4;11287:11;11284:37;;;11301:18;;:::i;:::-;11284:37;11134:194;;;;:::o;11334:77::-;11371:7;11400:5;11389:16;;11334:77;;;:::o;11417:79::-;11456:7;11485:5;11474:16;;11417:79;;;:::o;11502:157::-;11607:45;11627:24;11645:5;11627:24;:::i;:::-;11607:45;:::i;:::-;11602:3;11595:58;11502:157;;:::o;11665:163::-;11782:11;11819:3;11804:18;;11665:163;;;;:::o;11834:116::-;11919:24;11937:5;11919:24;:::i;:::-;11914:3;11907:37;11834:116;;:::o;11956:195::-;12033:10;12054:54;12104:3;12096:6;12054:54;:::i;:::-;12140:4;12135:3;12131:14;12117:28;;11956:195;;;;:::o;12187:776::-;12324:3;12353:54;12401:5;12353:54;:::i;:::-;12423:104;12520:6;12515:3;12423:104;:::i;:::-;12416:111;;12551:56;12601:5;12551:56;:::i;:::-;12630:7;12661:1;12646:292;12671:6;12668:1;12665:13;12646:292;;;12747:6;12741:13;12774:71;12841:3;12826:13;12774:71;:::i;:::-;12767:78;;12868:60;12921:6;12868:60;:::i;:::-;12858:70;;12706:232;12693:1;12690;12686:9;12681:14;;12646:292;;;12650:14;12954:3;12947:10;;12329:634;;;12187:776;;;;:::o;12969:476::-;13159:3;13174:75;13245:3;13236:6;13174:75;:::i;:::-;13274:2;13269:3;13265:12;13258:19;;13294:125;13415:3;13406:6;13294:125;:::i;:::-;13287:132;;13436:3;13429:10;;12969:476;;;;;:::o;13451:176::-;13483:1;13500:20;13518:1;13500:20;:::i;:::-;13495:25;;13534:20;13552:1;13534:20;:::i;:::-;13529:25;;13573:1;13563:35;;13578:18;;:::i;:::-;13563:35;13619:1;13616;13612:9;13607:14;;13451:176;;;;:::o;13633:180::-;13681:77;13678:1;13671:88;13778:4;13775:1;13768:15;13802:4;13799:1;13792:15;13819:410;13859:7;13882:20;13900:1;13882:20;:::i;:::-;13877:25;;13916:20;13934:1;13916:20;:::i;:::-;13911:25;;13971:1;13968;13964:9;13993:30;14011:11;13993:30;:::i;:::-;13982:41;;14172:1;14163:7;14159:15;14156:1;14153:22;14133:1;14126:9;14106:83;14083:139;;14202:18;;:::i;:::-;14083:139;13867:362;13819:410;;;;:::o;14235:233::-;14274:3;14297:24;14315:5;14297:24;:::i;:::-;14288:33;;14343:66;14336:5;14333:77;14330:103;;14413:18;;:::i;:::-;14330:103;14460:1;14453:5;14449:13;14442:20;;14235:233;;;:::o;14474:180::-;14522:77;14519:1;14512:88;14619:4;14616:1;14609:15;14643:4;14640:1;14633:15;14660:171;14699:3;14722:24;14740:5;14722:24;:::i;:::-;14713:33;;14768:4;14761:5;14758:15;14755:41;;14776:18;;:::i;:::-;14755:41;14823:1;14816:5;14812:13;14805:20;;14660:171;;;:::o

ipfs://60ff13ad08d173f11db2e2917a4ffb7985ea0f33c781e1336070be7d6aa2eb01