Contract 0xeddace2b84d15b92f3c4829b54cef11c5efb68d7

// SPDX-License-Identifier: MIT

// Source: https://github.com/boringcrypto/BoringSolidity/blob/master/contracts/BoringOwnable.sol

pragma solidity ^0.8.4;

abstract contract OwnableData {
    address public owner;
    address public pendingOwner;
}

abstract contract Ownable is OwnableData {
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(address _owner) {
        require(_owner != address(0), "Ownable: zero address");
        owner = _owner;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
    /// Can only be invoked by the current `owner`.
    /// @param newOwner Address of the new owner.
    /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
    function transferOwnership(address newOwner, bool direct) public onlyOwner {
        if (direct) {
            // Checks
            require(newOwner != address(0), "Ownable: zero address");

            // Effects
            emit OwnershipTransferred(owner, newOwner);
            owner = newOwner;
            pendingOwner = address(0);
        } else {
            // Effects
            pendingOwner = newOwner;
        }
    }

    /// @notice Needs to be called by `pendingOwner` to claim ownership.
    function claimOwnership() public {
        address _pendingOwner = pendingOwner;

        // Checks
        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");

        // Effects
        emit OwnershipTransferred(owner, _pendingOwner);
        owner = _pendingOwner;
        pendingOwner = address(0);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./LinkTokenInterface.sol";

import "./VRFRequestIDBase.sol";

/** ****************************************************************************
 * @notice Interface for contracts using VRF randomness
 * *****************************************************************************
 * @dev PURPOSE
 *
 * @dev Reggie the Random Oracle (not his real job) wants to provide randomness
 * @dev to Vera the verifier in such a way that Vera can be sure he's not
 * @dev making his output up to suit himself. Reggie provides Vera a public key
 * @dev to which he knows the secret key. Each time Vera provides a seed to
 * @dev Reggie, he gives back a value which is computed completely
 * @dev deterministically from the seed and the secret key.
 *
 * @dev Reggie provides a proof by which Vera can verify that the output was
 * @dev correctly computed once Reggie tells it to her, but without that proof,
 * @dev the output is indistinguishable to her from a uniform random sample
 * @dev from the output space.
 *
 * @dev The purpose of this contract is to make it easy for unrelated contracts
 * @dev to talk to Vera the verifier about the work Reggie is doing, to provide
 * @dev simple access to a verifiable source of randomness.
 * *****************************************************************************
 * @dev USAGE
 *
 * @dev Calling contracts must inherit from VRFConsumerBase, and can
 * @dev initialize VRFConsumerBase's attributes in their constructor as
 * @dev shown:
 *
 * @dev   contract VRFConsumer {
 * @dev     constuctor(<other arguments>, address _vrfCoordinator, address _link)
 * @dev       VRFConsumerBase(_vrfCoordinator, _link) public {
 * @dev         <initialization with other arguments goes here>
 * @dev       }
 * @dev   }
 *
 * @dev The oracle will have given you an ID for the VRF keypair they have
 * @dev committed to (let's call it keyHash), and have told you the minimum LINK
 * @dev price for VRF service. Make sure your contract has sufficient LINK, and
 * @dev call requestRandomness(keyHash, fee, seed), where seed is the input you
 * @dev want to generate randomness from.
 *
 * @dev Once the VRFCoordinator has received and validated the oracle's response
 * @dev to your request, it will call your contract's fulfillRandomness method.
 *
 * @dev The randomness argument to fulfillRandomness is the actual random value
 * @dev generated from your seed.
 *
 * @dev The requestId argument is generated from the keyHash and the seed by
 * @dev makeRequestId(keyHash, seed). If your contract could have concurrent
 * @dev requests open, you can use the requestId to track which seed is
 * @dev associated with which randomness. See VRFRequestIDBase.sol for more
 * @dev details. (See "SECURITY CONSIDERATIONS" for principles to keep in mind,
 * @dev if your contract could have multiple requests in flight simultaneously.)
 *
 * @dev Colliding `requestId`s are cryptographically impossible as long as seeds
 * @dev differ. (Which is critical to making unpredictable randomness! See the
 * @dev next section.)
 *
 * *****************************************************************************
 * @dev SECURITY CONSIDERATIONS
 *
 * @dev A method with the ability to call your fulfillRandomness method directly
 * @dev could spoof a VRF response with any random value, so it's critical that
 * @dev it cannot be directly called by anything other than this base contract
 * @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
 *
 * @dev For your users to trust that your contract's random behavior is free
 * @dev from malicious interference, it's best if you can write it so that all
 * @dev behaviors implied by a VRF response are executed *during* your
 * @dev fulfillRandomness method. If your contract must store the response (or
 * @dev anything derived from it) and use it later, you must ensure that any
 * @dev user-significant behavior which depends on that stored value cannot be
 * @dev manipulated by a subsequent VRF request.
 *
 * @dev Similarly, both miners and the VRF oracle itself have some influence
 * @dev over the order in which VRF responses appear on the blockchain, so if
 * @dev your contract could have multiple VRF requests in flight simultaneously,
 * @dev you must ensure that the order in which the VRF responses arrive cannot
 * @dev be used to manipulate your contract's user-significant behavior.
 *
 * @dev Since the ultimate input to the VRF is mixed with the block hash of the
 * @dev block in which the request is made, user-provided seeds have no impact
 * @dev on its economic security properties. They are only included for API
 * @dev compatability with previous versions of this contract.
 *
 * @dev Since the block hash of the block which contains the requestRandomness
 * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
 * @dev miner could, in principle, fork the blockchain to evict the block
 * @dev containing the request, forcing the request to be included in a
 * @dev different block with a different hash, and therefore a different input
 * @dev to the VRF. However, such an attack would incur a substantial economic
 * @dev cost. This cost scales with the number of blocks the VRF oracle waits
 * @dev until it calls responds to a request.
 */
abstract contract VRFConsumerBase is VRFRequestIDBase {
    /**
     * @notice fulfillRandomness handles the VRF response. Your contract must
     * @notice implement it. See "SECURITY CONSIDERATIONS" above for important
     * @notice principles to keep in mind when implementing your fulfillRandomness
     * @notice method.
     *
     * @dev VRFConsumerBase expects its subcontracts to have a method with this
     * @dev signature, and will call it once it has verified the proof
     * @dev associated with the randomness. (It is triggered via a call to
     * @dev rawFulfillRandomness, below.)
     *
     * @param requestId The Id initially returned by requestRandomness
     * @param randomness the VRF output
     */
    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal virtual;

    /**
     * @dev In order to keep backwards compatibility we have kept the user
     * seed field around. We remove the use of it because given that the blockhash
     * enters later, it overrides whatever randomness the used seed provides.
     * Given that it adds no security, and can easily lead to misunderstandings,
     * we have removed it from usage and can now provide a simpler API.
     */
    uint256 private constant USER_SEED_PLACEHOLDER = 0;

    /**
     * @notice requestRandomness initiates a request for VRF output given _seed
     *
     * @dev The fulfillRandomness method receives the output, once it's provided
     * @dev by the Oracle, and verified by the vrfCoordinator.
     *
     * @dev The _keyHash must already be registered with the VRFCoordinator, and
     * @dev the _fee must exceed the fee specified during registration of the
     * @dev _keyHash.
     *
     * @dev The _seed parameter is vestigial, and is kept only for API
     * @dev compatibility with older versions. It can't *hurt* to mix in some of
     * @dev your own randomness, here, but it's not necessary because the VRF
     * @dev oracle will mix the hash of the block containing your request into the
     * @dev VRF seed it ultimately uses.
     *
     * @param _keyHash ID of public key against which randomness is generated
     * @param _fee The amount of LINK to send with the request
     *
     * @return requestId unique ID for this request
     *
     * @dev The returned requestId can be used to distinguish responses to
     * @dev concurrent requests. It is passed as the first argument to
     * @dev fulfillRandomness.
     */
    function requestRandomness(bytes32 _keyHash, uint256 _fee) internal returns (bytes32 requestId) {
        LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, USER_SEED_PLACEHOLDER));
        // This is the seed passed to VRFCoordinator. The oracle will mix this with
        // the hash of the block containing this request to obtain the seed/input
        // which is finally passed to the VRF cryptographic machinery.
        uint256 vRFSeed = makeVRFInputSeed(_keyHash, USER_SEED_PLACEHOLDER, address(this), nonces[_keyHash]);
        // nonces[_keyHash] must stay in sync with
        // VRFCoordinator.nonces[_keyHash][this], which was incremented by the above
        // successful LINK.transferAndCall (in VRFCoordinator.randomnessRequest).
        // This provides protection against the user repeating their input seed,
        // which would result in a predictable/duplicate output, if multiple such
        // requests appeared in the same block.
        nonces[_keyHash] = nonces[_keyHash] + 1;
        return makeRequestId(_keyHash, vRFSeed);
    }

    LinkTokenInterface internal immutable LINK;
    address private immutable vrfCoordinator;

    // Nonces for each VRF key from which randomness has been requested.
    //
    // Must stay in sync with VRFCoordinator[_keyHash][this]
    mapping(bytes32 => uint256) /* keyHash */ /* nonce */
        private nonces;

    /**
     * @param _vrfCoordinator address of VRFCoordinator contract
     * @param _link address of LINK token contract
     *
     * @dev https://docs.chain.link/docs/link-token-contracts
     */
    constructor(address _vrfCoordinator, address _link) {
        vrfCoordinator = _vrfCoordinator;
        LINK = LinkTokenInterface(_link);
    }

    // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
    // proof. rawFulfillRandomness then calls fulfillRandomness, after validating
    // the origin of the call
    function rawFulfillRandomness(bytes32 requestId, uint256 randomness) external {
        require(msg.sender == vrfCoordinator, "Only VRFCoordinator can fulfill");
        fulfillRandomness(requestId, randomness);
    }
}

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

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

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = 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) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "../interfaces/IERC20.sol";

library SafeERC20 {
    function safeSymbol(IERC20 token) internal view returns (string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(0x95d89b41));
        return success && data.length > 0 ? abi.decode(data, (string)) : "???";
    }

    function safeName(IERC20 token) internal view returns (string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(0x06fdde03));
        return success && data.length > 0 ? abi.decode(data, (string)) : "???";
    }

    function safeDecimals(IERC20 token) internal view returns (uint8) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(0x313ce567));
        return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
    }

    function safeTransfer(IERC20 token, address to, uint256 amount) internal {
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(0xa9059cbb, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "SafeERC20: Transfer failed");
    }

    function safeTransferFrom(IERC20 token, address from, uint256 amount) internal {
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(0x23b872dd, from, address(this), amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "SafeERC20: TransferFrom failed");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface LinkTokenInterface {

  function allowance(
    address owner,
    address spender
  )
    external
    view
    returns (
      uint256 remaining
    );

  function approve(
    address spender,
    uint256 value
  )
    external
    returns (
      bool success
    );

  function balanceOf(
    address owner
  )
    external
    view
    returns (
      uint256 balance
    );

  function decimals()
    external
    view
    returns (
      uint8 decimalPlaces
    );

  function decreaseApproval(
    address spender,
    uint256 addedValue
  )
    external
    returns (
      bool success
    );

  function increaseApproval(
    address spender,
    uint256 subtractedValue
  ) external;

  function name()
    external
    view
    returns (
      string memory tokenName
    );

  function symbol()
    external
    view
    returns (
      string memory tokenSymbol
    );

  function totalSupply()
    external
    view
    returns (
      uint256 totalTokensIssued
    );

  function transfer(
    address to,
    uint256 value
  )
    external
    returns (
      bool success
    );

  function transferAndCall(
    address to,
    uint256 value,
    bytes calldata data
  )
    external
    returns (
      bool success
    );

  function transferFrom(
    address from,
    address to,
    uint256 value
  )
    external
    returns (
      bool success
    );

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VRFRequestIDBase {

  /**
   * @notice returns the seed which is actually input to the VRF coordinator
   *
   * @dev To prevent repetition of VRF output due to repetition of the
   * @dev user-supplied seed, that seed is combined in a hash with the
   * @dev user-specific nonce, and the address of the consuming contract. The
   * @dev risk of repetition is mostly mitigated by inclusion of a blockhash in
   * @dev the final seed, but the nonce does protect against repetition in
   * @dev requests which are included in a single block.
   *
   * @param _userSeed VRF seed input provided by user
   * @param _requester Address of the requesting contract
   * @param _nonce User-specific nonce at the time of the request
   */
  function makeVRFInputSeed(
    bytes32 _keyHash,
    uint256 _userSeed,
    address _requester,
    uint256 _nonce
  )
    internal
    pure
    returns (
      uint256
    )
  {
    return uint256(keccak256(abi.encode(_keyHash, _userSeed, _requester, _nonce)));
  }

  /**
   * @notice Returns the id for this request
   * @param _keyHash The serviceAgreement ID to be used for this request
   * @param _vRFInputSeed The seed to be passed directly to the VRF
   * @return The id for this request
   *
   * @dev Note that _vRFInputSeed is not the seed passed by the consuming
   * @dev contract, but the one generated by makeVRFInputSeed
   */
  function makeRequestId(
    bytes32 _keyHash,
    uint256 _vRFInputSeed
  )
    internal
    pure
    returns (
      bytes32
    )
  {
    return keccak256(abi.encodePacked(_keyHash, _vRFInputSeed));
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);

    // EIP 2612
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function nonces(address owner) external view returns (uint256);
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.6;

import "./external/chainlink/VRFConsumerBase.sol";
import "./external/openzeppelin/EnumerableSet.sol";
import "./abstract/Ownable.sol";
import "./libraries/SafeERC20.sol";

contract PublicSelector is Ownable, VRFConsumerBase {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.UintSet;

    event WinnerSelected(uint256 timestamp, uint256 winner);

    uint256 public ticketsCount;
    string public participantsListLink;
    string public participantsListSha256;

    EnumerableSet.UintSet private winners;

    bool public winnersSelected = false;
    EnumerableSet.UintSet internal stepsBeforeSelection;

    // Chainlink + Randomness

    bytes32 internal keyHash;
    uint256 internal fee;

    uint256 public randomResult;
    uint256 public previousWinnerSeed;

    /**
     * Constructor inherits VRFConsumerBase
     */
    constructor(
        address _vrfCoordinator,
        address _link,
        bytes32 _keyHash,
        uint256 _fee
    )
        Ownable(msg.sender)
        VRFConsumerBase(
            _vrfCoordinator, // VRF Coordinator
            _link // LINK Token
        )
    {
        keyHash = _keyHash;
        fee = _fee; // LINK fee
    }

    /// @notice Allows owner to set the VRF keyHash
    /// @param _keyHash The keyHash to be used by the VRF
    function setKeyHash(bytes32 _keyHash) external onlyOwner {
        keyHash = _keyHash;
    }

    /// @notice Allows owner to set the fee per request required by the VRF
    /// @param _fee The fee to be charged for a request
    function setFee(uint256 _fee) external onlyOwner {
        fee = _fee;
    }

    /**
     * Requests randomness
     */
    function getRandomNumber() public returns (bytes32 requestId) {
        require(LINK.balanceOf(address(this)) >= fee, "Not enough LINK - provide LINK to the contract");
        return requestRandomness(keyHash, fee);
    }

    /**
     * Callback function used by VRF Coordinator
     */
    function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
        randomResult = randomness;
        if (!stepsBeforeSelection.contains(1)) {
            stepsBeforeSelection.add(1);
        }
    }

    function setTicketsNumber(uint256 number) public onlyOwner {
        require(!winnersSelected, "Selection performed");
        ticketsCount = number;
        if (!stepsBeforeSelection.contains(4)) {
            stepsBeforeSelection.add(4);
        }
    }

    function setParticipantsListLink(string memory link) public onlyOwner {
        require(!winnersSelected, "Selection performed");
        participantsListLink = link;
        if (!stepsBeforeSelection.contains(2)) {
            stepsBeforeSelection.add(2);
        }
    }

    function setParticipantsListSha256(string memory sha256Hash) public onlyOwner {
        require(!winnersSelected, "Selection performed");
        participantsListSha256 = sha256Hash;
        if (!stepsBeforeSelection.contains(3)) {
            stepsBeforeSelection.add(3);
        }
    }

    function selectWinners(uint256 count) public onlyOwner {
        require(stepsBeforeSelection.length() == 4, "Not all steps performed");
        require(randomResult != 0, "Chainlink data recheck");
        require((count + winners.length()) <= ticketsCount, "Outside of ticket range");

        if (previousWinnerSeed == 0) {
            previousWinnerSeed = randomResult;
        }

        for (uint256 i = 0; i < count; i++) {
            uint256 winnerSeed;
            uint256 winnerIndex;

            bool winnerSelected = false;
            uint256 nonce = 0;
            do {
                winnerSeed = uint256(keccak256(abi.encodePacked(previousWinnerSeed, i, nonce)));
                winnerIndex = (winnerSeed % ticketsCount) + 1;
                nonce++;

                winnerSelected = !winners.contains(winnerIndex);
            } while (!winnerSelected);

            winners.add(winnerIndex);
            previousWinnerSeed = winnerSeed;

            emit WinnerSelected(block.timestamp, winnerIndex);
        }

        winnersSelected = true;
    }

    function getWinners() external view returns (uint256[] memory) {
        uint256[] memory win = new uint256[](winners.length());

        for (uint256 i = 0; i < winners.length(); i++) {
            win[i] = winners.at(i);
        }

        return win;
    }

    function getWinnersInRange(uint256 from, uint256 to) external view returns (uint256[] memory) {
        require(from < to, "Incorrect range");
        require(to < winners.length(), "Incorrect range");

        uint256[] memory win = new uint256[](to - from + 1);

        for (uint256 i = 0; i <= to - from; i++) {
            win[i] = winners.at(i + from);
        }

        return win;
    }

    function recoverErc20(address token) external onlyOwner {
        uint256 amount = IERC20(token).balanceOf(address(this));
        if (amount > 0) {
            IERC20(token).safeTransfer(owner, amount);
        }
    }

    function recover() external onlyOwner {
        payable(owner).transfer(address(this).balance);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_vrfCoordinator","type":"address"},{"internalType":"address","name":"_link","type":"address"},{"internalType":"bytes32","name":"_keyHash","type":"bytes32"},{"internalType":"uint256","name":"_fee","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"uint256","name":"timestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"winner","type":"uint256"}],"name":"WinnerSelected","type":"event"},{"inputs":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRandomNumber","outputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getWinners","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"}],"name":"getWinnersInRange","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"participantsListLink","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"participantsListSha256","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"previousWinnerSeed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"randomResult","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"},{"internalType":"uint256","name":"randomness","type":"uint256"}],"name":"rawFulfillRandomness","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"recover","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"recoverErc20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"selectWinners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_keyHash","type":"bytes32"}],"name":"setKeyHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"link","type":"string"}],"name":"setParticipantsListLink","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"sha256Hash","type":"string"}],"name":"setParticipantsListSha256","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"number","type":"uint256"}],"name":"setTicketsNumber","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ticketsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"},{"internalType":"bool","name":"direct","type":"bool"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"winnersSelected","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000003d2341adb2d31f1c5530cdc622016af293177ae0000000000000000000000000b0897686c545045afc77cf20ec7a532e3120e0f1f86195cf7690c55907b2b611ebb7343a6f649bff128701cc542f0569e2c549da00000000000000000000000000000000000000000000000000005af3107a4000

-----Decoded View---------------
Arg [0] : _vrfCoordinator (address): 0x3d2341adb2d31f1c5530cdc622016af293177ae0
Arg [1] : _link (address): 0xb0897686c545045afc77cf20ec7a532e3120e0f1
Arg [2] : _keyHash (bytes32): 0xf86195cf7690c55907b2b611ebb7343a6f649bff128701cc542f0569e2c549da
Arg [3] : _fee (uint256): 100000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000003d2341adb2d31f1c5530cdc622016af293177ae0
Arg [1] : 000000000000000000000000b0897686c545045afc77cf20ec7a532e3120e0f1
Arg [2] : f86195cf7690c55907b2b611ebb7343a6f649bff128701cc542f0569e2c549da
Arg [3] : 00000000000000000000000000000000000000000000000000005af3107a4000

230:4921:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;434:27;;;;;;;;;6117:25:8;;;6105:2;6090:18;434:27:0;;;;;;;;3079:1072;;;;;;:::i;:::-;;:::i;:::-;;781:27;;;;;;814:33;;;;;;1414:330:1;;;:::i;2507:272:0:-;;;;;;:::i;:::-;;:::i;1596:76::-;;;;;;:::i;:::-;;:::i;467:34::-;;;:::i;:::-;;;;;;;:::i;594:35::-;;;;;;;;;;;;5944:14:8;;5937:22;5919:41;;5907:2;5892:18;594:35:0;5874:92:8;193:20:1;;;;;;;;;;;;4372:42:8;4360:55;;;4342:74;;4330:2;4315:18;193:20:1;4297:125:8;9764:217:3;;;;;;:::i;:::-;;:::i;1366:92:0:-;;;;;;:::i;:::-;;:::i;2246:255::-;;;;;;:::i;:::-;;:::i;903:432:1:-;;;;;;:::i;:::-;;:::i;4823:219:0:-;;;;;;:::i;:::-;;:::i;2785:288::-;;;;;;:::i;:::-;;:::i;507:36::-;;;:::i;5048:101::-;;;:::i;4422:395::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1721:222::-;;;:::i;4157:259::-;;;:::i;219:27:1:-;;;;;;;;;3079:1072:0;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;;;;;;;;;3152:29:0::1;:20;:27;:29::i;:::-;3185:1;3152:34;3144:70;;;::::0;::::1;::::0;;11277:2:8;3144:70:0::1;::::0;::::1;11259:21:8::0;11316:2;11296:18;;;11289:30;11355:25;11335:18;;;11328:53;11398:18;;3144:70:0::1;11249:173:8::0;3144:70:0::1;3232:12;::::0;3224:52:::1;;;::::0;::::1;::::0;;10574:2:8;3224:52:0::1;::::0;::::1;10556:21:8::0;10613:2;10593:18;;;10586:30;10652:24;10632:18;;;10625:52;10694:18;;3224:52:0::1;10546:172:8::0;3224:52:0::1;3324:12;;3303:16;:7;:14;:16::i;:::-;3295:24;::::0;:5;:24:::1;:::i;:::-;3294:42;;3286:78;;;::::0;::::1;::::0;;10925:2:8;3286:78:0::1;::::0;::::1;10907:21:8::0;10964:2;10944:18;;;10937:30;11003:25;10983:18;;;10976:53;11046:18;;3286:78:0::1;10897:173:8::0;3286:78:0::1;3379:18;::::0;3375:87:::1;;3439:12;::::0;3418:18:::1;:33:::0;3375:87:::1;3477:9;3472:640;3496:5;3492:1;:9;3472:640;;;3522:18;3554:19:::0;3588::::1;3629:13:::0;3660:294:::1;3729:18;::::0;3712:46:::1;::::0;;::::1;::::0;::::1;4064:19:8::0;;;;4099:12;;4092:28;;;4136:12;;;4129:28;;;4173:12;;3712:46:0::1;;;;;;;;;;;;3702:57;;;;;;3694:66;;3681:79;;3806:12;;3793:10;:25;;;;:::i;:::-;3792:31;::::0;3822:1:::1;3792:31;:::i;:::-;3778:45:::0;-1:-1:-1;3841:7:0;::::1;::::0;::::1;:::i;:::-;::::0;-1:-1:-1;3885:29:0::1;::::0;-1:-1:-1;3885:7:0::1;3902:11:::0;3885:16:::1;:29::i;:::-;3884:30;3867:47;;3938:14;3937:15;3660:294;;3968:24;:7;3980:11:::0;3968::::1;:24::i;:::-;-1:-1:-1::0;4006:18:0::1;:31:::0;;;4057:44:::1;::::0;;4072:15:::1;6327:25:8::0;;6383:2;6368:18;;6361:34;;;4057:44:0::1;::::0;6300:18:8;4057:44:0::1;;;;;;;3508:604;;;;3503:3;;;;;:::i;:::-;;;;3472:640;;;-1:-1:-1::0;;4122:15:0::1;:22:::0;;;::::1;4140:4;4122:22;::::0;;3079:1072::o;1414:330:1:-;1481:12;;;;1530:10;:27;;1522:72;;;;;;;9083:2:8;1522:72:1;;;9065:21:8;;;9102:18;;;9095:30;9161:34;9141:18;;;9134:62;9213:18;;1522:72:1;9055:182:8;1522:72:1;1650:5;;;1629:42;;;;;;;1650:5;;;1629:42;;;1681:5;:21;;;;;;;;;;;;;;1712:25;;;;;;;1414:330::o;2507:272:0:-;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;2596:15:0::1;::::0;::::1;;2595:16;2587:48;;;::::0;::::1;::::0;;8030:2:8;2587:48:0::1;::::0;::::1;8012:21:8::0;8069:2;8049:18;;;8042:30;8108:21;8088:18;;;8081:49;8147:18;;2587:48:0::1;8002:169:8::0;2587:48:0::1;2645:27:::0;;::::1;::::0;:20:::1;::::0;:27:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;2687:32:0::1;:20;2717:1;2687:29;:32::i;:::-;2682:91;;2735:27;:20;2760:1;2735:24;:27::i;:::-;;2682:91;2507:272:::0;:::o;1596:76::-;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;1655:3:0::1;:10:::0;1596:76::o;467:34::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;9764:217:3:-;9860:10;:28;9874:14;9860:28;;9852:72;;;;;;;9444:2:8;9852:72:3;;;9426:21:8;9483:2;9463:18;;;9456:30;9522:33;9502:18;;;9495:61;9573:18;;9852:72:3;9416:181:8;9852:72:3;9934:40;9952:9;9963:10;9934:17;:40::i;1366:92:0:-;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;1433:7:0::1;:18:::0;1366:92::o;2246:255::-;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;2324:15:0::1;::::0;::::1;;2323:16;2315:48;;;::::0;::::1;::::0;;8030:2:8;2315:48:0::1;::::0;::::1;8012:21:8::0;8069:2;8049:18;;;8042:30;8108:21;8088:18;;;8081:49;8147:18;;2315:48:0::1;8002:169:8::0;2315:48:0::1;2373:12;:21:::0;;;2409:32:::1;:20;2439:1;2409:29;:32::i;:::-;2404:91;;2457:27;:20;2482:1;2457:24;:27::i;903:432:1:-:0;1803:5;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;992:6:::1;988:341;;;1044:22;::::0;::::1;1036:56;;;::::0;::::1;::::0;;7680:2:8;1036:56:1::1;::::0;::::1;7662:21:8::0;7719:2;7699:18;;;7692:30;7758:23;7738:18;;;7731:51;7799:18;;1036:56:1::1;7652:171:8::0;1036:56:1::1;1156:5;::::0;;1135:37:::1;::::0;::::1;::::0;;::::1;::::0;1156:5;::::1;::::0;1135:37:::1;::::0;::::1;1186:5;:16:::0;;::::1;::::0;::::1;::::0;;;::::1;;::::0;;;;1216:25;;;;::::1;::::0;;988:341:::1;;;1295:12;:23:::0;;::::1;::::0;::::1;::::0;;;::::1;;::::0;;903:432;;:::o;4823:219:0:-;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;4906:38:0::1;::::0;;;;4938:4:::1;4906:38;::::0;::::1;4342:74:8::0;4889:14:0::1;::::0;4906:23:::1;::::0;::::1;::::0;::::1;::::0;4315:18:8;;4906:38:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4889:55:::0;-1:-1:-1;4958:10:0;;4954:82:::1;;5011:5;::::0;4984:41:::1;::::0;5011:5:::1;4984:26:::0;;::::1;::::0;5011:5:::1;5018:6:::0;4984:26:::1;:41::i;2785:288::-:0;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;2882:15:0::1;::::0;::::1;;2881:16;2873:48;;;::::0;::::1;::::0;;8030:2:8;2873:48:0::1;::::0;::::1;8012:21:8::0;8069:2;8049:18;;;8042:30;8108:21;8088:18;;;8081:49;8147:18;;2873:48:0::1;8002:169:8::0;2873:48:0::1;2931:35:::0;;::::1;::::0;:22:::1;::::0;:35:::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;2981:32:0::1;:20;3011:1;2981:29;:32::i;:::-;2976:91;;3029:27;:20;3054:1;3029:24;:27::i;507:36::-:0;;;;;;;:::i;5048:101::-;1803:5:1;;;;1789:10;:19;1781:64;;;;;;;8722:2:8;1781:64:1;;;8704:21:8;;;8741:18;;;8734:30;8800:34;8780:18;;;8773:62;8852:18;;1781:64:1;8694:182:8;1781:64:1;5104:5:0::1;::::0;;5096:46:::1;::::0;5104:5:::1;::::0;;::::1;::::0;5120:21:::1;5096:46:::0;::::1;;;::::0;5120:21;;5096:46;5104:5;5096:46;5120:21;5104:5;5096:46;::::1;;;;;;;;;;;;;::::0;::::1;;;;4422:395:::0;4498:16;4541:2;4534:4;:9;4526:37;;;;;;;8378:2:8;4526:37:0;;;8360:21:8;8417:2;8397:18;;;8390:30;8456:17;8436:18;;;8429:45;8491:18;;4526:37:0;8350:165:8;4526:37:0;4586:16;:7;:14;:16::i;:::-;4581:2;:21;4573:49;;;;;;;8378:2:8;4573:49:0;;;8360:21:8;8417:2;8397:18;;;8390:30;8456:17;8436:18;;;8429:45;8491:18;;4573:49:0;8350:165:8;4573:49:0;4633:20;4670:9;4675:4;4670:2;:9;:::i;:::-;:13;;4682:1;4670:13;:::i;:::-;4656:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4656:28:0;;4633:51;;4700:9;4695:95;4720:9;4725:4;4720:2;:9;:::i;:::-;4715:1;:14;4695:95;;4759:20;4770:8;4774:4;4770:1;:8;:::i;:::-;4759:7;;:10;:20::i;:::-;4750:3;4754:1;4750:6;;;;;;;;:::i;:::-;;;;;;;;;;:29;4731:3;;;;:::i;:::-;;;;4695:95;;;-1:-1:-1;4807:3:0;-1:-1:-1;4422:395:0;;;;;:::o;1721:222::-;1834:3;;1801:29;;;;;1824:4;1801:29;;;4342:74:8;1764:17:0;;1834:3;1801:14;:4;:14;;;;4315:18:8;;1801:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;;1793:95;;;;;;;10159:2:8;1793:95:0;;;10141:21:8;10198:2;10178:18;;;10171:30;10237:34;10217:18;;;10210:62;10308:16;10288:18;;;10281:44;10342:19;;1793:95:0;10131:236:8;1793:95:0;1905:31;1923:7;;1932:3;;1905:17;:31::i;:::-;1898:38;;1721:222;:::o;4157:259::-;4202:16;4230:20;4267:16;:7;:14;:16::i;:::-;4253:31;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4253:31:0;;4230:54;;4300:9;4295:94;4319:16;:7;:14;:16::i;:::-;4315:1;:20;4295:94;;;4365:13;:7;4376:1;4365:10;:13::i;:::-;4356:3;4360:1;4356:6;;;;;;;;:::i;:::-;;;;;;;;;;:22;4337:3;;;;:::i;:::-;;;;4295:94;;;-1:-1:-1;4406:3:0;4157:259;-1:-1:-1;4157:259:0:o;8807:112:5:-;8867:7;8893:19;8901:3;4096:18;;4014:107;8582:144;8659:4;3902:19;;;:12;;;:19;;;;;;:24;;8682:37;8675:44;8582:144;-1:-1:-1;;;8582:144:5:o;8069:129::-;8136:4;8159:32;8164:3;8184:5;8159:4;:32::i;2014:226:0:-;2108:12;:25;;;2148:32;:20;2178:1;2148:29;:32::i;:::-;2143:91;;2196:27;:20;2221:1;2196:24;:27::i;:::-;;2014:226;;:::o;923:358:7:-;1121:46;;;1101:19;4619:55:8;;;1121:46:7;;;4601:74:8;4691:18;;;;4684:34;;;1121:46:7;;;;;;;;;;4574:18:8;;;;1121:46:7;;;;;;;;;;;;;1101:67;;-1:-1:-1;;;;1101:19:7;;;;:67;;1121:46;1101:67;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1065:103;;;;1186:7;:57;;;;-1:-1:-1;1198:11:7;;:16;;:44;;;1229:4;1218:24;;;;;;;;;;;;:::i;:::-;1178:96;;;;;;;9804:2:8;1178:96:7;;;9786:21:8;9843:2;9823:18;;;9816:30;9882:28;9862:18;;;9855:56;9928:18;;1178:96:7;9776:176:8;1178:96:7;996:285;;923:358;;;:::o;9251:135:5:-;9322:7;9356:22;9360:3;9372:5;9356:3;:22::i;7818:1074:3:-;7895:17;7924:4;:20;;;7945:14;7961:4;7978:8;6623:1;7967:43;;;;;;;;6327:25:8;;;6383:2;6368:18;;6361:34;6315:2;6300:18;;6282:119;7967:43:3;;;;;;;;;;;;;7924:87;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;8258:15:3;8341:16;;;:6;:16;;;;;;;;;1005:51:4;;;;;6637:25:8;;;6678:18;;;6671:34;;;8334:4:3;6721:18:8;;;6714:83;6813:18;;;;6806:34;;;1005:51:4;;;;;;;;;;6609:19:8;;;;1005:51:4;;;995:62;;;;;;;;;8816:16:3;;;;;;;:20;;8835:1;8816:20;:::i;:::-;8797:16;;;;:6;:16;;;;;:39;8853:32;8804:8;8877:7;1600:41:4;;;;;;;3505:19:8;;;;3540:12;;;3533:28;;;;1600:41:4;;;;;;;;;3577:12:8;;;;1600:41:4;;1590:52;;;;;;1443:204;8853:32:3;8846:39;7818:1074;-1:-1:-1;;;;7818:1074:3:o;1632:404:5:-;1695:4;3902:19;;;:12;;;:19;;;;;;1711:319;;-1:-1:-1;1753:23:5;;;;;;;;:11;:23;;;;;;;;;;;;;1933:18;;1911:19;;;:12;;;:19;;;;;;:40;;;;1965:11;;1711:319;-1:-1:-1;2014:5:5;2007:12;;4453:201;4547:18;;4520:7;;4547:26;-1:-1:-1;4539:73:5;;;;;;;7277:2:8;4539:73:5;;;7259:21:8;7316:2;7296:18;;;7289:30;7355:34;7335:18;;;7328:62;7426:4;7406:18;;;7399:32;7448:19;;4539:73:5;7249:224:8;4539:73:5;4629:3;:11;;4641:5;4629:18;;;;;;;;:::i;:::-;;;;;;;;;4622:25;;4453:201;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:196:8;82:20;;142:42;131:54;;121:65;;111:2;;200:1;197;190:12;111:2;63:147;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:2;;;343:1;340;333:12;295:2;366:29;385:9;366:29;:::i;406:315::-;471:6;479;532:2;520:9;511:7;507:23;503:32;500:2;;;548:1;545;538:12;500:2;571:29;590:9;571:29;:::i;:::-;561:39;;650:2;639:9;635:18;622:32;663:28;685:5;663:28;:::i;:::-;710:5;700:15;;;490:231;;;;;:::o;726:245::-;793:6;846:2;834:9;825:7;821:23;817:32;814:2;;;862:1;859;852:12;814:2;894:9;888:16;913:28;935:5;913:28;:::i;976:180::-;1035:6;1088:2;1076:9;1067:7;1063:23;1059:32;1056:2;;;1104:1;1101;1094:12;1056:2;-1:-1:-1;1127:23:8;;1046:110;-1:-1:-1;1046:110:8:o;1161:248::-;1229:6;1237;1290:2;1278:9;1269:7;1265:23;1261:32;1258:2;;;1306:1;1303;1296:12;1258:2;-1:-1:-1;;1329:23:8;;;1399:2;1384:18;;;1371:32;;-1:-1:-1;1248:161:8:o;1414:981::-;1483:6;1536:2;1524:9;1515:7;1511:23;1507:32;1504:2;;;1552:1;1549;1542:12;1504:2;1592:9;1579:23;1621:18;1662:2;1654:6;1651:14;1648:2;;;1678:1;1675;1668:12;1648:2;1716:6;1705:9;1701:22;1691:32;;1761:7;1754:4;1750:2;1746:13;1742:27;1732:2;;1783:1;1780;1773:12;1732:2;1819;1806:16;1841:2;1837;1834:10;1831:2;;;1847:18;;:::i;:::-;1981:2;1975:9;2043:4;2035:13;;1886:66;2031:22;;;2055:2;2027:31;2023:40;2011:53;;;2079:18;;;2099:22;;;2076:46;2073:2;;;2125:18;;:::i;:::-;2165:10;2161:2;2154:22;2200:2;2192:6;2185:18;2240:7;2235:2;2230;2226;2222:11;2218:20;2215:33;2212:2;;;2261:1;2258;2251:12;2212:2;2317;2312;2308;2304:11;2299:2;2291:6;2287:15;2274:46;2362:1;2340:15;;;2357:2;2336:24;2329:35;;;;-1:-1:-1;2344:6:8;1494:901;-1:-1:-1;;;;;1494:901:8:o;2585:184::-;2655:6;2708:2;2696:9;2687:7;2683:23;2679:32;2676:2;;;2724:1;2721;2714:12;2676:2;-1:-1:-1;2747:16:8;;2666:103;-1:-1:-1;2666:103:8:o;3027:316::-;3068:3;3106:5;3100:12;3133:6;3128:3;3121:19;3149:63;3205:6;3198:4;3193:3;3189:14;3182:4;3175:5;3171:16;3149:63;:::i;:::-;3257:2;3245:15;3262:66;3241:88;3232:98;;;;3332:4;3228:109;;3076:267;-1:-1:-1;;3076:267:8:o;3600:274::-;3729:3;3767:6;3761:13;3783:53;3829:6;3824:3;3817:4;3809:6;3805:17;3783:53;:::i;:::-;3852:16;;;;;3737:137;-1:-1:-1;;3737:137:8:o;4729:408::-;4944:42;4936:6;4932:55;4921:9;4914:74;5024:6;5019:2;5008:9;5004:18;4997:34;5067:2;5062;5051:9;5047:18;5040:30;4895:4;5087:44;5127:2;5116:9;5112:18;5104:6;5087:44;:::i;:::-;5079:52;4904:233;-1:-1:-1;;;;;4904:233:8:o;5142:632::-;5313:2;5365:21;;;5435:13;;5338:18;;;5457:22;;;5284:4;;5313:2;5536:15;;;;5510:2;5495:18;;;5284:4;5579:169;5593:6;5590:1;5587:13;5579:169;;;5654:13;;5642:26;;5723:15;;;;5688:12;;;;5615:1;5608:9;5579:169;;;-1:-1:-1;5765:3:8;;5293:481;-1:-1:-1;;;;;;5293:481:8:o;6851:219::-;7000:2;6989:9;6982:21;6963:4;7020:44;7060:2;7049:9;7045:18;7037:6;7020:44;:::i;11862:128::-;11902:3;11933:1;11929:6;11926:1;11923:13;11920:2;;;11939:18;;:::i;:::-;-1:-1:-1;11975:9:8;;11910:80::o;11995:125::-;12035:4;12063:1;12060;12057:8;12054:2;;;12068:18;;:::i;:::-;-1:-1:-1;12105:9:8;;12044:76::o;12125:258::-;12197:1;12207:113;12221:6;12218:1;12215:13;12207:113;;;12297:11;;;12291:18;12278:11;;;12271:39;12243:2;12236:10;12207:113;;;12338:6;12335:1;12332:13;12329:2;;;12373:1;12364:6;12359:3;12355:16;12348:27;12329:2;;12178:205;;;:::o;12388:437::-;12467:1;12463:12;;;;12510;;;12531:2;;12585:4;12577:6;12573:17;12563:27;;12531:2;12638;12630:6;12627:14;12607:18;12604:38;12601:2;;;12675:77;12672:1;12665:88;12776:4;12773:1;12766:15;12804:4;12801:1;12794:15;12830:195;12869:3;12900:66;12893:5;12890:77;12887:2;;;12970:18;;:::i;:::-;-1:-1:-1;13017:1:8;13006:13;;12877:148::o;13030:266::-;13062:1;13088;13078:2;;13123:77;13120:1;13113:88;13224:4;13221:1;13214:15;13252:4;13249:1;13242:15;13078:2;-1:-1:-1;13281:9:8;;13068:228::o;13301:184::-;13353:77;13350:1;13343:88;13450:4;13447:1;13440:15;13474:4;13471:1;13464:15;13490:184;13542:77;13539:1;13532:88;13639:4;13636:1;13629:15;13663:4;13660:1;13653:15;13679:184;13731:77;13728:1;13721:88;13828:4;13825:1;13818:15;13852:4;13849:1;13842:15;13868:118;13954:5;13947:13;13940:21;13933:5;13930:32;13920:2;;13976:1;13973;13966:12

ipfs://17203e53c269a0046df1fb9ff71788af8c326eeb8186922206fec81ddc9715d0