Contract 0x9fad71370ae14ef15dbd1a1767633c8e53d01a44 2

/**
 *Submitted for verification at polygonscan.com on 2021-08-17
*/

// SPDX-License-Identifier: MIT
// File: contracts/libs/IMiner.sol



pragma solidity 0.6.12;

interface IMiner {
    function recordReferrer(address _user, address _referrer) external;
    function addReward(address _user, uint _amount) external;
}
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/utils/Address.sol



pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

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

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

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

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

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

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/math/SafeMath.sol



pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

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

        return c;
    }

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/IERC20.sol



pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/SafeERC20.sol



pragma solidity ^0.6.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/utils/ReentrancyGuard.sol



pragma solidity ^0.6.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/GSN/Context.sol



pragma solidity ^0.6.0;

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/access/Ownable.sol



pragma solidity ^0.6.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

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

// File: https://github.com/smartcontractkit/chainlink/blob/0964ca290565587963cc4ad8f770274f5e0d9e9d/evm-contracts/src/v0.6/VRFRequestIDBase.sol


pragma solidity ^0.6.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));
  }
}

// File: https://github.com/smartcontractkit/chainlink/blob/0964ca290565587963cc4ad8f770274f5e0d9e9d/evm-contracts/src/v0.6/interfaces/LinkTokenInterface.sol


pragma solidity ^0.6.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);
}

// File: https://github.com/smartcontractkit/chainlink/blob/0964ca290565587963cc4ad8f770274f5e0d9e9d/evm-contracts/src/v0.6/vendor/SafeMathChainlink.sol


pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMathChainlink {
  /**
    * @dev Returns the addition of two unsigned integers, reverting on
    * overflow.
    *
    * Counterpart to Solidity's `+` operator.
    *
    * Requirements:
    * - Addition cannot overflow.
    */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, "SafeMath: addition overflow");

    return c;
  }

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

    return c;
  }

  /**
    * @dev Returns the multiplication of two unsigned integers, reverting on
    * overflow.
    *
    * Counterpart to Solidity's `*` operator.
    *
    * Requirements:
    * - Multiplication cannot overflow.
    */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, "SafeMath: multiplication overflow");

    return c;
  }

  /**
    * @dev Returns the integer division of two unsigned integers. Reverts on
    * division by zero. The result is rounded towards zero.
    *
    * Counterpart to Solidity's `/` operator. Note: this function uses a
    * `revert` opcode (which leaves remaining gas untouched) while Solidity
    * uses an invalid opcode to revert (consuming all remaining gas).
    *
    * Requirements:
    * - The divisor cannot be zero.
    */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // Solidity only automatically asserts when dividing by 0
    require(b > 0, "SafeMath: division by zero");
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

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

// File: https://github.com/smartcontractkit/chainlink/blob/0964ca290565587963cc4ad8f770274f5e0d9e9d/evm-contracts/src/v0.6/VRFConsumerBase.sol


pragma solidity ^0.6.0;




/** ****************************************************************************
 * @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 {

  using SafeMathChainlink for uint256;

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

  /**
   * @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
   * @param _seed seed mixed into the input of the VRF.
   *
   * @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, uint256 _seed)
    internal returns (bytes32 requestId)
  {
    LINK.transferAndCall(vrfCoordinator, _fee, abi.encode(_keyHash, _seed));
    // 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, _seed, 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].add(1);
    return makeRequestId(_keyHash, vRFSeed);
  }

  LinkTokenInterface immutable internal LINK;
  address immutable private vrfCoordinator;

  // Nonces for each VRF key from which randomness has been requested.
  //
  // Must stay in sync with VRFCoordinator[_keyHash][this]
  mapping(bytes32 /* keyHash */ => uint256 /* 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) public {
    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);
  }
}

// File: contracts/Polyroll.sol



pragma solidity 0.6.12;






// Polyroll is the dealer of random number games at Polyroll.org: Coin Flip, Dice Roll, Polyroll, Roulette.
/*
v2 has the same logic as v1, with the following updates:
- Transaction Mining: Contract is linked to TransactionMiner contract to award ROLL tokens to gamblers who lost bets.
- Referral system: Contract is linked to TransactionMiner contract to record a gambler's referrer and distribute referral fees.
- Automated risk management: Dynamically computes maxProfit based on contract balance and balance-to-maxProfit ratio.
- Reward Computation: Calculates txn mining reward based on rewardPct, ROLL/MATIC price, bet amount, and probability of loss.
- House edge and wealth tax are in basis points instead of percentage for fine adjustments.
- betPlaced event log is more detailed to allow users to see their pending bets while waiting for settlement.
- betSettled event log is less detailed to save gas fee paid by Chainlink VRF and speed up confirmation time by Polygon nodes.
*/
contract Polyroll is VRFConsumerBase, Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    // Import contract that governs transaction mining and referral fees
    IMiner public miner;

    // Chainlink VRF related parameters
    address public constant LINK_TOKEN = 0xb0897686c545045aFc77CF20eC7A532E3120E0F1;
    address public constant VRF_COORDINATOR = 0x3d2341ADb2D31f1c5530cDC622016af293177AE0;
    bytes32 public keyHash = 0xf86195cf7690c55907b2b611ebb7343a6f649bff128701cc542f0569e2c549da;
    uint public chainlinkFee = 100000000000000; // 0.0001 LINK

    // Each bet is deducted 100 basis points (1%) in favor of the house
    uint public houseEdgeBP = 100;

    // Modulo is the number of equiprobable outcomes in a game:
    //  2 for coin flip
    //  6 for dice roll
    //  36 for double dice roll
    //  37 for roulette
    //  100 for polyroll
    uint constant MAX_MODULO = 100;

    // Modulos below MAX_MASK_MODULO are checked against a bit mask, allowing betting on specific outcomes. 
    // For example in a dice roll (modolo = 6), 
    // 000001 mask means betting on 1. 000001 converted from binary to decimal becomes 1.
    // 101000 mask means betting on 4 and 6. 101000 converted from binary to decimal becomes 40.
    // The specific value is dictated by the fact that 256-bit intermediate
    // multiplication result allows implementing population count efficiently
    // for numbers that are up to 42 bits, and 40 is the highest multiple of eight below 42.
    uint constant MAX_MASK_MODULO = 40;

     // This is a check on bet mask overflow. Maximum mask is equivalent to number of possible binary outcomes for maximum modulo.
    uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;

    // These are constants that make O(1) population count in placeBet possible.
    uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
    uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
    uint constant POPCNT_MODULO = 0x3F;

    // In addition to house edge, wealth tax is added for bet amount that exceeds a multiple of wealthTaxThreshold.
    // For example, if wealthTaxThreshold = 200 ether and wealthTaxBP = 100,
    // A bet amount of 200 ether will have a wealth tax of 1% in addition to house edge.
    // A bet amount of 400 ether will have a wealth tax of 2% in addition to house edge.
    uint public wealthTaxThreshold = 200 ether;
    uint public wealthTaxBP = 100;

    // Minimum and maximum bet amounts.
    uint public minBetAmount = 2 ether;
    uint public maxBetAmount = 800 ether;

    // Balance-to-maxProfit ratio. Used to dynamically adjusts maxProfit based on balance.
    uint public balanceMaxProfitRatio = 24;

    // Funds that are locked in potentially winning bets. Prevents contract from committing to new bets that it cannot pay out.
    uint public lockedInBets;

    // Info of each bet.
    struct Bet {
        // Wager amount in wei.
        uint amount;
        // Modulo of a game.
        uint8 modulo;
        // Number of winning outcomes, used to compute winning payment (* modulo/rollUnder),
        // and used instead of mask for games with modulo > MAX_MASK_MODULO.
        uint8 rollUnder;
        // Bit mask representing winning bet outcomes (see MAX_MASK_MODULO comment).
        uint40 mask;
        // Block number of placeBet tx.
        uint placeBlockNumber;
        // Address of a gambler, used to pay out winning bets.
        address payable gambler;
        // Status of bet settlement.
        bool isSettled;
        // Outcome of bet.
        uint outcome;
        // Win amount.
        uint winAmount;
    }

    // Array of bets
    Bet[] public bets;

    // Mapping requestId returned by Chainlink VRF to bet Id.
    mapping(bytes32 => uint) public betMap;

    // Percentage of house edge fees to be rewarded to losing gambler.
    uint public rewardPct = 20;

    // Variables for computing price of ROLL in MATIC. Used for computing ROLL reward for transaction mining.
    uint constant SAFETY_FACTOR = 1e7; // Prevent truncation of price in integer datatype by multiplying with SAFETY_FACTOR.
    address constant ROLL_TOKEN = 0xC68e83a305b0FaD69E264A1769a0A070F190D2d6;
    address constant MATIC_TOKEN = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
    address public rollMaticLP = 0x905DCc700fcce9a49b7D907E371230995a45ebCE;
    uint public rollMaticRatio; // Price of ROLL/MATIC
    uint public rollMaticBlockTimestampLast;
    uint maxReward = 20000 ether;

    // Signed integer used for tracking house profit since inception.
    int public houseProfit;

    // Events
    event BetPlaced(uint indexed betId, address indexed gambler, uint amount, uint8 indexed modulo, uint8 rollUnder, uint40 mask);
    event BetSettled(uint indexed betId, address indexed gambler, uint amount, uint8 indexed modulo, uint8 rollUnder, uint40 mask, uint outcome, uint winAmount, uint rollReward);
    event BetRefunded(uint indexed betId, address indexed gambler, uint amount);

    // Constructor. Using Chainlink VRFConsumerBase constructor.
    constructor() VRFConsumerBase(VRF_COORDINATOR, LINK_TOKEN) public {}

    // Fallback & receive payable function used to top up the bank roll.
    fallback() external payable {}
    receive() external payable {}

    // Returns game token balance.
    function balance() external view returns (uint) {
        return address(this).balance;
    }

    // Returns number of bets.
    function betsLength() external view returns (uint) {
        return bets.length;
    }

    // Returns maximum profit allowed per bet. Prevents contract from accepting any bets with potential profit exceeding maxProfit.
    function maxProfit() public view returns (uint) {
        return address(this).balance / balanceMaxProfitRatio;
    }

    // Set balance-to-maxProfit ratio. 
    function setBalanceMaxProfitRatio(uint _balanceMaxProfitRatio) external onlyOwner {
        balanceMaxProfitRatio = _balanceMaxProfitRatio;
    }

    // Update Chainlink fee.
    function setChainlinkFee(uint _chainlinkFee) external onlyOwner {
        chainlinkFee = _chainlinkFee;
    }

    // Update Chainlink keyHash. Currently using keyHash with 10 block waiting time config. May configure to 64 block waiting time for more security.
    function setKeyHash(bytes32 _keyHash) external onlyOwner {
        keyHash = _keyHash;
    }

    // Set minimum bet amount. minBetAmount should be large enough such that its house edge fee can cover the Chainlink oracle fee.
    function setMinBetAmount(uint _minBetAmount) external onlyOwner {
        minBetAmount = _minBetAmount;
    }

    // Set maximum bet amount. Setting this to zero effectively disables betting.
    function setMaxBetAmount(uint _maxBetAmount) external onlyOwner {
        maxBetAmount = _maxBetAmount;
    }

    // Set house edge.
    function setHouseEdgeBP(uint _houseEdgeBP) external onlyOwner {
        houseEdgeBP = _houseEdgeBP;
    }

    // Set wealth tax. Setting this to zero effectively disables wealth tax.
    function setWealthTaxBP(uint _wealthTaxBP) external onlyOwner {
        wealthTaxBP = _wealthTaxBP;
    }

    // Set threshold to trigger wealth tax.
    function setWealthTaxThreshold(uint _wealthTaxThreshold) external onlyOwner {
        wealthTaxThreshold = _wealthTaxThreshold;
    }

    // Set transaction mining contract address
    function setMiner(IMiner _miner) external onlyOwner {
        miner = _miner;
    }

    // Set transaction mining reward as a percentage of house edge fees.
    // Setting rewardPct to 100% effectively leads to an expectation value of 0.
    function setRewardPct(uint _rewardPct) external onlyOwner {
        require(_rewardPct <= 100, "rewardPct exceeds 100%");
        rewardPct = _rewardPct;
    }

    // Set rollMaticLP if we change our main trading LP for price reference.
    function setRollMaticLP(address _rollMaticLP) external onlyOwner {
        rollMaticLP = _rollMaticLP;
    }

    // Set maximum ROLL reward that a user can receive per bet.
    function setMaxReward(uint _maxReward) external onlyOwner {
        maxReward = _maxReward;
    }

    // Get ROLL/MATIC price with safeguards against oracle attacks.
    function updateRollMaticRatio() internal {
        // Run function if 30 minutes elapsed.
        if (block.timestamp - rollMaticBlockTimestampLast >= 1800) {

            // Get ratio of ROLL to MATIC multiplied by SAFETY_FACTOR to avoid losing precision.
            uint newRollMaticRatio = IERC20(ROLL_TOKEN).balanceOf(rollMaticLP) * SAFETY_FACTOR / IERC20(MATIC_TOKEN).balanceOf(rollMaticLP);

            if (rollMaticRatio == 0) {
                // Update rollMaticRatio if first time updating.
                rollMaticRatio = newRollMaticRatio;
            } else if (newRollMaticRatio * SAFETY_FACTOR / rollMaticRatio > SAFETY_FACTOR * 110 / 100) {
                // Cap any increase to +10% per update.
                rollMaticRatio = rollMaticRatio * 110 / 100;
            } else if (newRollMaticRatio * SAFETY_FACTOR / rollMaticRatio < SAFETY_FACTOR * 80 / 100) {
                // Cap any decrease to -10% per update.
                rollMaticRatio = rollMaticRatio * 90 / 100;
            } else {
                rollMaticRatio = newRollMaticRatio;
            }
            rollMaticBlockTimestampLast = block.timestamp;
        }
    }

    // Place bet
    function placeBet(uint betMask, uint modulo, address referrer) external payable nonReentrant {

        // Validate input data.
        uint amount = msg.value;
        require(LINK.balanceOf(address(this)) >= chainlinkFee, "Insufficient LINK token");
        require(modulo > 1 && modulo <= MAX_MODULO, "Modulo not within range");
        require(amount >= minBetAmount && amount <= maxBetAmount, "Bet amount not within range");
        require(betMask > 0 && betMask < MAX_BET_MASK, "Mask not within range");

        // Update ROLL/MATIC price if data is outdated.
        updateRollMaticRatio();

        // Record referrer in Miner contract
        if (referrer != msg.sender) {
            miner.recordReferrer(msg.sender, referrer);
        }

        uint rollUnder;
        uint mask;

        if (modulo <= MAX_MASK_MODULO) {
            // Small modulo games can specify exact bet outcomes via bit mask.
            // rollUnder is a number of 1 bits in this mask (population count).
            // This magic looking formula is an efficient way to compute population
            // count on EVM for numbers below 2**40. 
            rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
            mask = betMask;
        } else {
            // Larger modulos games specify the right edge of half-open interval of winning bet outcomes.
            require(betMask > 0 && betMask <= modulo, "betMask larger than modulo");
            rollUnder = betMask;
        }

        // Winning amount.
        uint possibleWinAmount = getWinAmount(amount, modulo, rollUnder);

        // Enforce max profit limit. Bet will not be placed if condition is not met.
        require(possibleWinAmount <= amount + maxProfit(), "maxProfit violation");

        // Check whether contract has enough funds to accept this bet.
        require(lockedInBets + possibleWinAmount <= address(this).balance, "Insufficient funds");

        // Update lock funds.
        lockedInBets += possibleWinAmount;

        // Request random number from Chainlink VRF. Store requestId for validation checks later.
        bytes32 requestId = requestRandomness(keyHash, chainlinkFee, bets.length);

        // Map requestId to bet ID.
        betMap[requestId] = bets.length;

        // Record bet in event logs. Placed before pushing bet to array in order to get the correct bets.length.
        emit BetPlaced(bets.length, msg.sender, amount, uint8(modulo), uint8(rollUnder), uint40(mask));

        // Store bet in bet list.
        bets.push(Bet(
            {
                amount: amount,
                modulo: uint8(modulo),
                rollUnder: uint8(rollUnder),
                mask: uint40(mask),
                placeBlockNumber: block.number,
                gambler: msg.sender,
                isSettled: false,
                outcome: 0,
                winAmount: 0
            }
        ));
    }

    // Returns the expected win amount.
    function getWinAmount(uint amount, uint modulo, uint rollUnder) private view returns (uint winAmount) {
        require(0 < rollUnder && rollUnder <= modulo, "Win probability out of range");
        uint houseEdgeFee = amount * (houseEdgeBP + getEffectiveWealthTaxBP(amount)) / 10000;
        winAmount = (amount - houseEdgeFee) * modulo / rollUnder;
    }

    // Get effective wealth tax for a given bet size.
    function getEffectiveWealthTaxBP(uint amount) private view returns (uint effectiveWealthTaxBP) {
        effectiveWealthTaxBP = amount / wealthTaxThreshold * wealthTaxBP;
    }

    // Expected ROLL tokens to be rewarded if lose bet.
    function getRollReward(uint amount, uint modulo, uint rollUnder) private view returns (uint) {
        // ROLL reward equals token price multiplied by house edge fees, divided by win probability, multiplied by rewardPct.
        uint rollReward = rollMaticRatio * amount * (houseEdgeBP + getEffectiveWealthTaxBP(amount)) / 10000 * modulo / (modulo - rollUnder) * rewardPct / 100 / SAFETY_FACTOR;
        if (rollReward > maxReward) {
            rollReward = maxReward;
        }
        return rollReward;
    }

    // Callback function called by Chainlink VRF coordinator.
    function fulfillRandomness(bytes32 requestId, uint randomness) internal override {
        settleBet(requestId, randomness);
    }

    // Settle bet. Function can only be called by fulfillRandomness function, which in turn can only be called by Chainlink VRF.
    function settleBet(bytes32 requestId, uint randomNumber) internal nonReentrant {
        
        uint betId = betMap[requestId];
        Bet storage bet = bets[betId];
        uint amount = bet.amount;
        
        // Validation checks.
        require(amount > 0, "Bet does not exist");
        require(bet.isSettled == false, "Bet is settled already");

        // Fetch bet parameters into local variables (to save gas).
        uint modulo = bet.modulo;
        uint rollUnder = bet.rollUnder;
        address payable gambler = bet.gambler;

        // Do a roll by taking a modulo of random number.
        uint outcome = randomNumber % modulo;

        // Win amount if gambler wins this bet
        uint possibleWinAmount = getWinAmount(amount, modulo, rollUnder);

        // Roll reward if gambler loses this bet
        uint rollReward = getRollReward(amount, modulo, rollUnder);

        // Actual win amount by gambler.
        uint winAmount = 0;

        // Determine dice outcome.
        if (modulo <= MAX_MASK_MODULO) {
            // For small modulo games, check the outcome against a bit mask.
            if ((2 ** outcome) & bet.mask != 0) {
                winAmount = possibleWinAmount;
                rollReward = 0;
            }
        } else {
            // For larger modulos, check inclusion into half-open interval.
            if (outcome < rollUnder) {
                winAmount = possibleWinAmount;
                rollReward = 0;
            }
        }

        // Unlock possibleWinAmount from lockedInBets, regardless of the outcome.
        lockedInBets -= possibleWinAmount;

        // Update bet records
        bet.isSettled = true;
        bet.winAmount = winAmount;
        bet.outcome = outcome;

        // Send prize to winner, add ROLL reward to loser, and update house profit.
        if (winAmount > 0) {
            houseProfit -= int(winAmount - amount);
            gambler.transfer(winAmount);
        } else {
            houseProfit += int(amount);
            miner.addReward(gambler, rollReward);
        }
        
        // Record bet settlement in event log.
        emit BetSettled(betId, gambler, amount, uint8(modulo), uint8(rollUnder), bet.mask, outcome, winAmount, rollReward);
    }

    // Owner can withdraw funds not exceeding balance minus potential win amounts by open bets.
    function withdrawFunds(address payable beneficiary, uint withdrawAmount) external onlyOwner {
        require(withdrawAmount <= address(this).balance - lockedInBets, "Withdrawal exceeds limit");
        beneficiary.transfer(withdrawAmount);
    }

    // Owner can withdraw non-MATIC tokens.
    function withdrawToken(address tokenAddress) external onlyOwner {
        IERC20(tokenAddress).safeTransfer(owner(), IERC20(tokenAddress).balanceOf(address(this)));
    }

    // Return the bet in the very unlikely scenario it was not settled by Chainlink VRF. 
    // In case you find yourself in a situation like this, just contact Polyroll support.
    // However, nothing precludes you from calling this method yourself.
    function refundBet(uint betId) external nonReentrant {
        
        Bet storage bet = bets[betId];
        uint amount = bet.amount;

        // Validation checks
        require(amount > 0, "Bet does not exist");
        require(bet.isSettled == false, "Bet is settled already");
        require(block.number > bet.placeBlockNumber + 21600, "Wait before requesting refund");

        uint possibleWinAmount = getWinAmount(amount, bet.modulo, bet.rollUnder);

        // Unlock possibleWinAmount from lockedInBets, regardless of the outcome.
        lockedInBets -= possibleWinAmount;

        // Update bet records
        bet.isSettled = true;
        bet.winAmount = amount;

        // Send the refund.
        bet.gambler.transfer(amount);

        // Record refund in event logs
        emit BetRefunded(betId, bet.gambler, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"betId","type":"uint256"},{"indexed":true,"internalType":"address","name":"gambler","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint8","name":"modulo","type":"uint8"},{"indexed":false,"internalType":"uint8","name":"rollUnder","type":"uint8"},{"indexed":false,"internalType":"uint40","name":"mask","type":"uint40"}],"name":"BetPlaced","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"betId","type":"uint256"},{"indexed":true,"internalType":"address","name":"gambler","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BetRefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"betId","type":"uint256"},{"indexed":true,"internalType":"address","name":"gambler","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint8","name":"modulo","type":"uint8"},{"indexed":false,"internalType":"uint8","name":"rollUnder","type":"uint8"},{"indexed":false,"internalType":"uint40","name":"mask","type":"uint40"},{"indexed":false,"internalType":"uint256","name":"outcome","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"winAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rollReward","type":"uint256"}],"name":"BetSettled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"LINK_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VRF_COORDINATOR","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceMaxProfitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"betMap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bets","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"modulo","type":"uint8"},{"internalType":"uint8","name":"rollUnder","type":"uint8"},{"internalType":"uint40","name":"mask","type":"uint40"},{"internalType":"uint256","name":"placeBlockNumber","type":"uint256"},{"internalType":"address payable","name":"gambler","type":"address"},{"internalType":"bool","name":"isSettled","type":"bool"},{"internalType":"uint256","name":"outcome","type":"uint256"},{"internalType":"uint256","name":"winAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"betsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chainlinkFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"houseEdgeBP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"houseProfit","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keyHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedInBets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBetAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxProfit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBetAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"miner","outputs":[{"internalType":"contract IMiner","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"betMask","type":"uint256"},{"internalType":"uint256","name":"modulo","type":"uint256"},{"internalType":"address","name":"referrer","type":"address"}],"name":"placeBet","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"requestId","type":"bytes32"},{"internalType":"uint256","name":"randomness","type":"uint256"}],"name":"rawFulfillRandomness","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"betId","type":"uint256"}],"name":"refundBet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPct","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rollMaticBlockTimestampLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rollMaticLP","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rollMaticRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_balanceMaxProfitRatio","type":"uint256"}],"name":"setBalanceMaxProfitRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_chainlinkFee","type":"uint256"}],"name":"setChainlinkFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_houseEdgeBP","type":"uint256"}],"name":"setHouseEdgeBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_keyHash","type":"bytes32"}],"name":"setKeyHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxBetAmount","type":"uint256"}],"name":"setMaxBetAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxReward","type":"uint256"}],"name":"setMaxReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minBetAmount","type":"uint256"}],"name":"setMinBetAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IMiner","name":"_miner","type":"address"}],"name":"setMiner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPct","type":"uint256"}],"name":"setRewardPct","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rollMaticLP","type":"address"}],"name":"setRollMaticLP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_wealthTaxBP","type":"uint256"}],"name":"setWealthTaxBP","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_wealthTaxThreshold","type":"uint256"}],"name":"setWealthTaxThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wealthTaxBP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wealthTaxThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"withdrawAmount","type":"uint256"}],"name":"withdrawFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

42177:18274:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51853:2985;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42511:84;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;45987:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50472:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;44955:38;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46626:71;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;42356:19;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;49601:135;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48213:147;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42602:91;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;44698:29;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50289:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48903:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24257:148;;;;;;;;;;;;;:::i;:::-;;42700:42;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49105:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42839:29;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46914:22;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59140:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23615:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;40883:210;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50041:162;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;49792:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48668:94;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46195:26;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49441:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48398:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48045:119;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49248:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47681:95;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46704:26;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47816:88;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46760:39;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;58838:249;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;44649:42;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;44818:36;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45131:24;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59576:872;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46076:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;42425:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;24560:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;44777:34;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;51853:2985;20464:1;21070:7;;:19;;21062:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20464:1;21203:7;:18;;;;51992:11:::1;52006:9;51992:23;;52067:12;;52034:4;:14;;;52057:4;52034:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;:45;;52026:81;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;52135:1;52126:6;:10;:34;;;;;43103:3;52140:6;:20;;52126:34;52118:70;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;52217:12;;52207:6;:22;;:48;;;;;52243:12;;52233:6;:22;;52207:48;52199:88;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;52316:1;52306:7;:11;:37;;;;;43746:2;43918:1;:20;52321:7;:22;52306:37;52298:71;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;52439:22;:20;:22::i;:::-;52536:10;52524:22;;:8;:22;;;52520:97;;52563:5;;;;;;;;;;;:20;;;52584:10;52596:8;52563:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;52520:97;52629:14;52654:9:::0;43746:2:::1;52680:6;:25;52676:700;;44261:4;44158:66;44057;53037:7;:21;53036:37;53035:55;;;;;;53023:67;;53112:7;53105:14;;52676:700;;;53277:1;53267:7;:11;:32;;;;;53293:6;53282:7;:17;;53267:32;53259:71;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;53357:7;53345:19;;52676:700;53416:22;53441:39;53454:6;53462;53470:9;53441:12;:39::i;:::-;53416:64;;53617:11;:9;:11::i;:::-;53608:6;:20;53587:17;:41;;53579:73;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;53781:21;53760:17;53745:12;;:32;:57;;53737:88;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;53885:17;53869:12;;:33;;;;;;;;;;;54014:17;54034:53;54052:7;;54061:12;;54075:4;:11;;;;54034:17;:53::i;:::-;54014:73;;54157:4;:11;;;;54137:6;:17;54144:9;54137:17;;;;;;;;;;;:31;;;;54349:6;54300:89;;54323:10;54300:89;;54310:4;:11;;;;54300:89;54335:6;54364:9;54383:4;54300:89;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54437:4;54447:382;;;;;;;;54492:6;54447:382;;;;54531:6;54447:382;;;;;;54574:9;54447:382;;;;;;54616:4;54447:382;;;;;;54658:12;54447:382;;;;54698:10;54447:382;;;;;;54738:5;54447:382;;;;;;54771:1;54447:382;;;;54802:1;54447:382;;::::0;54437:393:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21234:1;;;;;20420::::0;21382:7;:22;;;;51853:2985;;;:::o;42511:84::-;42553:42;42511:84;:::o;45987:17::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50472:99::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50553:10:::1;50541:9;:22;;;;50472:99:::0;:::o;44955:38::-;;;;:::o;46626:71::-;;;;;;;;;;;;;:::o;42356:19::-;;;;;;;;;;;;;:::o;49601:135::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49709:19:::1;49688:18;:40;;;;49601:135:::0;:::o;48213:147::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48330:22:::1;48306:21;:46;;;;48213:147:::0;:::o;42602:91::-;;;;:::o;44698:29::-;;;;:::o;50289:110::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50379:12:::1;50365:11;;:26;;;;;;;;;;;;;;;;;;50289:110:::0;:::o;48903:111::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48993:13:::1;48978:12;:28;;;;48903:111:::0;:::o;24257:148::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24364:1:::1;24327:40;;24348:6;;;;;;;;;;;24327:40;;;;;;;;;;;;24395:1;24378:6;;:19;;;;;;;;;;;;;;;;;;24257:148::o:0;42700:42::-;;;;:::o;49105:111::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49195:13:::1;49180:12;:28;;;;49105:111:::0;:::o;42839:29::-;;;;:::o;46914:22::-;;;;:::o;59140:172::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59215:89:::1;59249:7;:5;:7::i;:::-;59265:12;59258:30;;;59297:4;59258:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;59222:12;59215:33;;;;:89;;;;;:::i;:::-;59140:172:::0;:::o;23615:79::-;23653:7;23680:6;;;;;;;;;;;23673:13;;23615:79;:::o;40883:210::-;40990:14;40976:28;;:10;:28;;;40968:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41047:40;41065:9;41076:10;41047:17;:40::i;:::-;40883:210;;:::o;50041:162::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50132:3:::1;50118:10;:17;;50110:52;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;50185:10;50173:9;:22;;;;50041:162:::0;:::o;49792:85::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49863:6:::1;49855:5;;:14;;;;;;;;;;;;;;;;;;49792:85:::0;:::o;48668:94::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48746:8:::1;48736:7;:18;;;;48668:94:::0;:::o;46195:26::-;;;;:::o;49441:107::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49528:12:::1;49514:11;:26;;;;49441:107:::0;:::o;48398:111::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48488:13:::1;48473:12;:28;;;;48398:111:::0;:::o;48045:119::-;48087:4;48135:21;;48111;:45;;;;;;48104:52;;48045:119;:::o;49248:107::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49335:12:::1;49321:11;:26;;;;49248:107:::0;:::o;47681:95::-;47723:4;47747:21;47740:28;;47681:95;:::o;46704:26::-;;;;:::o;47816:88::-;47861:4;47885;:11;;;;47878:18;;47816:88;:::o;46760:39::-;;;;:::o;58838:249::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58991:12:::1;;58967:21;:36;58949:14;:54;;58941:91;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;59043:11;:20;;:36;59064:14;59043:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;58838:249:::0;;:::o;44649:42::-;;;;:::o;44818:36::-;;;;:::o;45131:24::-;;;;:::o;59576:872::-;20464:1;21070:7;;:19;;21062:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20464:1;21203:7;:18;;;;59650:15:::1;59668:4;59673:5;59668:11;;;;;;;;;;;;;;;;;;59650:29;;59690:11;59704:3;:10;;;59690:24;;59774:1;59765:6;:10;59757:41;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;59834:5;59817:22;;:3;:13;;;;;;;;;;;;:22;;;59809:57;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;59923:5;59900:3;:20;;;:28;59885:12;:43;59877:85;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;59975:22;60000:47;60013:6;60021:3;:10;;;;;;;;;;;;60000:47;;60033:3;:13;;;;;;;;;;;;60000:47;;:12;:47::i;:::-;59975:72;;60159:17;60143:12;;:33;;;;;;;;;;;60236:4;60220:3;:13;;;:20;;;;;;;;;;;;;;;;;;60267:6;60251:3;:13;;:22;;;;60315:3;:11;;;;;;;;;;;;:20;;:28;60336:6;60315:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;60420:3;:11;;;;;;;;;;;;60401:39;;60413:5;60401:39;60433:6;60401:39;;;;;;;;;;;;;;;;;;21234:1;;;20420::::0;21382:7;:22;;;;59576:872;:::o;46076:38::-;;;;;;;;;;;;;;;;;:::o;42425:79::-;42462:42;42425:79;:::o;24560:244::-;23837:12;:10;:12::i;:::-;23827:22;;:6;;;;;;;;;;;:22;;;23819:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24669:1:::1;24649:22;;:8;:22;;;;24641:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24759:8;24730:38;;24751:6;;;;;;;;;;;24730:38;;;;;;;;;;;;24788:8;24779:6;;:17;;;;;;;;;;;;;;;;;;24560:244:::0;:::o;44777:34::-;;;;:::o;50648:1179::-;50801:4;50770:27;;50752:15;:45;:53;50748:1072;;50922:22;46577:42;51007:29;;;51037:11;;;;;;;;;;;51007:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46371:3;46497:42;50947:28;;;50976:11;;;;;;;;;;;50947:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:57;:102;;;;;;50922:127;;51088:1;51070:14;;:19;51066:683;;;51193:17;51176:14;:34;;;;51066:683;;;51311:3;51305;46371;51289:19;:25;;;;;;51272:14;;46371:3;51236:17;:33;:50;;;;;;:78;51232:517;;;51432:3;51426;51409:14;;:20;:26;;;;;;51392:14;:43;;;;51232:517;;;51535:3;51530:2;46371:3;51514:18;:24;;;;;;51497:14;;46371:3;51461:17;:33;:50;;;;;;:77;51457:292;;;51655:3;51650:2;51633:14;;:19;:25;;;;;;51616:14;:42;;;;51457:292;;;51716:17;51699:14;:34;;;;51457:292;51232:517;51066:683;51793:15;51763:27;:45;;;;50748:1072;;50648:1179::o;54887:360::-;54973:14;55012:9;55008:1;:13;:36;;;;;55038:6;55025:9;:19;;55008:36;55000:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55088:17;55167:5;55132:31;55156:6;55132:23;:31::i;:::-;55118:11;;:45;55108:6;:56;:64;;;;;;55088:84;;55230:9;55221:6;55205:12;55196:6;:21;55195:32;:44;;;;;;55183:56;;54887:360;;;;;;:::o;39003:1029::-;39100:17;39129:4;:20;;;39150:14;39166:4;39183:8;39193:5;39172:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39129:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39435:15;39454:66;39471:8;39481:5;39496:4;39503:6;:16;39510:8;39503:16;;;;;;;;;;;;39454;:66::i;:::-;39435:85;;39957:23;39978:1;39957:6;:16;39964:8;39957:16;;;;;;;;;;;;:20;;:23;;;;:::i;:::-;39938:6;:16;39945:8;39938:16;;;;;;;;;;;:42;;;;39994:32;40008:8;40018:7;39994:13;:32::i;:::-;39987:39;;;39003:1029;;;;;:::o;22106:106::-;22159:15;22194:10;22187:17;;22106:106;:::o;15595:177::-;15678:86;15698:5;15728:23;;;15753:2;15757:5;15705:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15678:19;:86::i;:::-;15595:177;;;:::o;56143:132::-;56235:32;56245:9;56256:10;56235:9;:32::i;:::-;56143:132;;:::o;55310:178::-;55378:25;55469:11;;55448:18;;55439:6;:27;;;;;;:41;55416:64;;55310:178;;;:::o;25744:236::-;25876:7;25932:8;25942:9;25953:10;25965:6;25921:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25911:62;;;;;;25903:71;;25895:79;;25744:236;;;;;;:::o;28807:167::-;28865:7;28881:9;28897:1;28893;:5;28881:17;;28918:1;28913;:6;;28905:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28967:1;28960:8;;;28807:167;;;;:::o;26371:174::-;26464:7;26514:8;26524:13;26497:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26487:52;;;;;;26480:59;;26371:174;;;;:::o;17900:761::-;18324:23;18350:69;18378:4;18350:69;;;;;;;;;;;;;;;;;18358:5;18350:27;;;;:69;;;;;:::i;:::-;18324:95;;18454:1;18434:10;:17;:21;18430:224;;;18576:10;18565:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18557:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18430:224;17900:761;;;:::o;56413:2320::-;20464:1;21070:7;;:19;;21062:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20464:1;21203:7;:18;;;;56513:10:::1;56526:6;:17;56533:9;56526:17;;;;;;;;;;;;56513:30;;56554:15;56572:4;56577:5;56572:11;;;;;;;;;;;;;;;;;;56554:29;;56594:11;56608:3;:10;;;56594:24;;56687:1;56678:6;:10;56670:41;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;56747:5;56730:22;;:3;:13;;;;;;;;;;;;:22;;;56722:57;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;56861:11;56875:3;:10;;;;;;;;;;;;56861:24;;;;56896:14;56913:3;:13;;;;;;;;;;;;56896:30;;;;56937:23;56963:3;:11;;;;;;;;;;;;56937:37;;57046:12;57076:6;57061:12;:21;;;;;;57046:36;;57143:22;57168:39;57181:6;57189;57197:9;57168:12;:39::i;:::-;57143:64;;57270:15;57288:40;57302:6;57310;57318:9;57288:13;:40::i;:::-;57270:58;;57383:14;43746:2;57454:6;:25;57450:499;;57607:1;57595:3;:8;;;;;;;;;;;;57578:25;;57584:7;57579:1;:12;57578:25;:30;57574:133;;57641:17;57629:29;;57690:1;57677:14;;57574:133;57450:499;;;57830:9;57820:7;:19;57816:122;;;57872:17;57860:29;;57921:1;57908:14;;57816:122;57450:499;58060:17;58044:12;;:33;;;;;;;;;;;58137:4;58121:3;:13;;;:20;;;;;;;;;;;;;;;;;;58168:9;58152:3;:13;;:25;;;;58202:7;58188:3;:11;;:21;;;;58323:1;58311:9;:13;58307:236;;;58372:6;58360:9;:18;58341:11;;:38;;;;;;;;;;;58394:7;:16;;:27;58411:9;58394:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;58307:236;;;58473:6;58454:11;;:26;;;;;;;;;;;58495:5;;;;;;;;;;;:15;;;58511:7;58520:10;58495:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;58307:236;58657:6;58616:109;;58634:7;58616:109;;58627:5;58616:109;58643:6;58672:9;58684:3;:8;;;;;;;;;;;;58694:7;58703:9;58714:10;58616:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21234:1;;;;;;;;;;20420::::0;21382:7;:22;;;;56413:2320;;:::o;4203:196::-;4306:12;4338:53;4361:6;4369:4;4375:1;4378:12;4338:22;:53::i;:::-;4331:60;;4203:196;;;;;:::o;55553:519::-;55640:4;55784:15;46371:3;55930;55918:9;;55905;55896:6;:18;55886:6;55878:5;55843:31;55867:6;55843:23;:31::i;:::-;55829:11;;:45;55819:6;55802:14;;:23;:73;:81;;;;;;:90;:113;;;;;;:125;:131;;;;;;:147;;;;;;55784:165;;55977:9;;55964:10;:22;55960:77;;;56016:9;;56003:22;;55960:77;56054:10;56047:17;;;55553:519;;;;;:::o;5580:979::-;5710:12;5743:18;5754:6;5743:10;:18::i;:::-;5735:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5869:12;5883:23;5910:6;:11;;5930:8;5941:4;5910:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5868:78;;;;5961:7;5957:595;;;5992:10;5985:17;;;;;;5957:595;6126:1;6106:10;:17;:21;6102:439;;;6369:10;6363:17;6430:15;6417:10;6413:2;6409:19;6402:44;6317:148;6512:12;6505:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5580:979;;;;;;;:::o;1088:619::-;1148:4;1410:16;1437:19;1459:66;1437:88;;;;1628:7;1616:20;1604:32;;1668:11;1656:8;:23;;:42;;;;;1695:3;1683:15;;:8;:15;;1656:42;1648:51;;;;1088:619;;;:::o

ipfs://e9673c247d586a4033408d857f7a4fa19b23888694c27629e68f8dcdf0ac55cb