Contract 0xe79bfc312328ab75272785dbf5bd871b253709a5 6

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.7.6;
pragma abicoder v2;

import {IERC20Ext} from './IERC20Ext.sol';
import {SafeMath} from './SafeMath.sol';
import {SafeCast} from './SafeCast.sol';
import {SafeERC20} from './SafeERC20.sol';
import {EnumerableSet} from './EnumerableSet.sol';
import {PermissionAdmin} from './PermissionAdmin.sol';

import {IKyberRewardLockerV2} from './IKyberRewardLockerV2.sol';

contract KyberRewardLockerV2 is IKyberRewardLockerV2, PermissionAdmin {
  using SafeMath for uint256;
  using SafeCast for uint256;

  using SafeERC20 for IERC20Ext;
  using EnumerableSet for EnumerableSet.AddressSet;

  struct VestingSchedules {
    uint256 length;
    mapping(uint256 => VestingSchedule) data;
  }

  uint256 private constant MAX_REWARD_CONTRACTS_SIZE = 100;

  /// @dev whitelist of reward contracts
  mapping(IERC20Ext => EnumerableSet.AddressSet) internal rewardContractsPerToken;

  /// @dev vesting schedule of an account
  mapping(address => mapping(IERC20Ext => VestingSchedules)) private accountVestingSchedules;

  /// @dev An account's total escrowed balance per token to save recomputing this for fee extraction purposes
  mapping(address => mapping(IERC20Ext => uint256)) public accountEscrowedBalance;

  /// @dev An account's total vested reward per token
  mapping(address => mapping(IERC20Ext => uint256)) public accountVestedBalance;

  /* ========== EVENTS ========== */
  event RewardContractAdded(address indexed rewardContract, IERC20Ext indexed token, bool isAdded);

  /* ========== MODIFIERS ========== */

  modifier onlyRewardsContract(IERC20Ext token) {
    require(rewardContractsPerToken[token].contains(msg.sender), 'only reward contract');
    _;
  }

  constructor(address _admin) PermissionAdmin(_admin) {}

  /**
   * @notice Add a whitelisted rewards contract
   */
  function addRewardsContract(IERC20Ext token, address _rewardContract) external onlyAdmin {
    require(
      rewardContractsPerToken[token].length() < MAX_REWARD_CONTRACTS_SIZE,
      'rewardContracts is too long'
    );
    require(rewardContractsPerToken[token].add(_rewardContract), '_rewardContract is added');

    emit RewardContractAdded(_rewardContract, token, true);
  }

  /**
   * @notice Remove a whitelisted rewards contract
   */
  function removeRewardsContract(IERC20Ext token, address _rewardContract) external onlyAdmin {
    require(rewardContractsPerToken[token].remove(_rewardContract), '_rewardContract is removed');

    emit RewardContractAdded(_rewardContract, token, false);
  }

  function lock(
    IERC20Ext token,
    address account,
    uint256 quantity,
    uint32 vestingDuration
  ) external override payable {
    lockWithStartTime(token, account, quantity, _getBlockTime(), vestingDuration);
  }

  /**
   * @dev vest all completed schedules for multiple tokens
   */
  function vestCompletedSchedulesForMultipleTokens(IERC20Ext[] calldata tokens)
    external
    override
    returns (uint256[] memory vestedAmounts)
  {
    vestedAmounts = new uint256[](tokens.length);
    for (uint256 i = 0; i < tokens.length; i++) {
      vestedAmounts[i] = vestCompletedSchedules(tokens[i]);
    }
  }

  /**
   * @dev claim multiple tokens for specific vesting schedule,
   *      if schedule has not ended yet, claiming amounts are linear with vesting times
   */
  function vestScheduleForMultipleTokensAtIndices(
    IERC20Ext[] calldata tokens,
    uint256[][] calldata indices
  ) external override returns (uint256[] memory vestedAmounts) {
    require(tokens.length == indices.length, 'tokens.length != indices.length');
    vestedAmounts = new uint256[](tokens.length);
    for (uint256 i = 0; i < tokens.length; i++) {
      vestedAmounts[i] = vestScheduleAtIndices(tokens[i], indices[i]);
    }
  }

  function lockWithStartTime(
    IERC20Ext token,
    address account,
    uint256 quantity,
    uint256 startTime,
    uint32 vestingDuration
  ) public override payable onlyRewardsContract(token) {
    require(quantity > 0, '0 quantity');

    if (token == IERC20Ext(0)) {
      require(msg.value == quantity, 'Invalid msg.value');
    } else {
      // transfer token from reward contract to lock contract
      token.safeTransferFrom(msg.sender, address(this), quantity);
    }

    VestingSchedules storage schedules = accountVestingSchedules[account][token];
    uint256 schedulesLength = schedules.length;
    uint256 endTime = startTime.add(vestingDuration);

    // combine with the last schedule if they have the same start & end times
    if (schedulesLength > 0) {
      VestingSchedule storage lastSchedule = schedules.data[schedulesLength - 1];
      if (lastSchedule.startTime == startTime && lastSchedule.endTime == endTime) {
        lastSchedule.quantity = uint256(lastSchedule.quantity).add(quantity).toUint128();
        accountEscrowedBalance[account][token] = accountEscrowedBalance[account][token].add(
          quantity
        );
        emit VestingEntryQueued(schedulesLength - 1, token, account, quantity);
        return;
      }
    }

    // append new schedule
    schedules.data[schedulesLength] = VestingSchedule({
      startTime: startTime.toUint64(),
      endTime: endTime.toUint64(),
      quantity: quantity.toUint128(),
      vestedQuantity: 0
    });
    schedules.length = schedulesLength + 1;
    // record total vesting balance of user
    accountEscrowedBalance[account][token] = accountEscrowedBalance[account][token].add(quantity);

    emit VestingEntryCreated(token, account, startTime, endTime, quantity, schedulesLength);
  }

  /**
   * @dev Allow a user to vest all ended schedules
   */
  function vestCompletedSchedules(IERC20Ext token) public override returns (uint256) {
    VestingSchedules storage schedules = accountVestingSchedules[msg.sender][token];
    uint256 schedulesLength = schedules.length;

    uint256 totalVesting = 0;
    for (uint256 i = 0; i < schedulesLength; i++) {
      VestingSchedule memory schedule = schedules.data[i];
      if (_getBlockTime() < schedule.endTime) {
        continue;
      }
      uint256 vestQuantity = uint256(schedule.quantity).sub(schedule.vestedQuantity);
      if (vestQuantity == 0) {
        continue;
      }
      schedules.data[i].vestedQuantity = schedule.quantity;
      totalVesting = totalVesting.add(vestQuantity);

      emit Vested(token, msg.sender, vestQuantity, i);
    }
    _completeVesting(token, totalVesting);

    return totalVesting;
  }

  /**
   * @notice Allow a user to vest with specific schedule
   */
  function vestScheduleAtIndices(IERC20Ext token, uint256[] memory indexes)
    public
    override
    returns (uint256)
  {
    VestingSchedules storage schedules = accountVestingSchedules[msg.sender][token];
    uint256 schedulesLength = schedules.length;
    uint256 totalVesting = 0;
    for (uint256 i = 0; i < indexes.length; i++) {
      require(indexes[i] < schedulesLength, 'invalid schedule index');
      VestingSchedule memory schedule = schedules.data[indexes[i]];
      uint256 vestQuantity = _getVestingQuantity(schedule);
      if (vestQuantity == 0) {
        continue;
      }
      schedules.data[indexes[i]].vestedQuantity = uint256(schedule.vestedQuantity)
        .add(vestQuantity)
        .toUint128();

      totalVesting = totalVesting.add(vestQuantity);

      emit Vested(token, msg.sender, vestQuantity, indexes[i]);
    }
    _completeVesting(token, totalVesting);
    return totalVesting;
  }

  function vestSchedulesInRange(
    IERC20Ext token,
    uint256 startIndex,
    uint256 endIndex
  ) public override returns (uint256) {
    require(startIndex <= endIndex, 'startIndex > endIndex');
    uint256[] memory indexes = new uint256[](endIndex - startIndex + 1);
    for (uint256 index = startIndex; index <= endIndex; index++) {
      indexes[index - startIndex] = index;
    }
    return vestScheduleAtIndices(token, indexes);
  }

  /* ========== VIEW FUNCTIONS ========== */

  /**
   * @notice The number of vesting dates in an account's schedule.
   */
  function numVestingSchedules(address account, IERC20Ext token)
    external
    override
    view
    returns (uint256)
  {
    return accountVestingSchedules[account][token].length;
  }

  /**
   * @dev manually get vesting schedule at index
   */
  function getVestingScheduleAtIndex(
    address account,
    IERC20Ext token,
    uint256 index
  ) external override view returns (VestingSchedule memory) {
    return accountVestingSchedules[account][token].data[index];
  }

  /**
   * @dev Get all schedules for an account.
   */
  function getVestingSchedules(address account, IERC20Ext token)
    external
    override
    view
    returns (VestingSchedule[] memory schedules)
  {
    uint256 schedulesLength = accountVestingSchedules[account][token].length;
    schedules = new VestingSchedule[](schedulesLength);
    for (uint256 i = 0; i < schedulesLength; i++) {
      schedules[i] = accountVestingSchedules[account][token].data[i];
    }
  }

  function getRewardContractsPerToken(IERC20Ext token)
    external
    view
    returns (address[] memory rewardContracts)
  {
    rewardContracts = new address[](rewardContractsPerToken[token].length());
    for (uint256 i = 0; i < rewardContracts.length; i++) {
      rewardContracts[i] = rewardContractsPerToken[token].at(i);
    }
  }

  /* ========== INTERNAL FUNCTIONS ========== */

  function _completeVesting(IERC20Ext token, uint256 totalVesting) internal {
    require(totalVesting != 0, '0 vesting amount');
    accountEscrowedBalance[msg.sender][token] = accountEscrowedBalance[msg.sender][token].sub(
      totalVesting
    );
    accountVestedBalance[msg.sender][token] = accountVestedBalance[msg.sender][token].add(
      totalVesting
    );

    if (token == IERC20Ext(0)) {
      (bool success, ) = msg.sender.call{value: totalVesting}('');
      require(success, 'fail to transfer');
    } else {
      token.safeTransfer(msg.sender, totalVesting);
    }
  }

  /**
   * @dev implements linear vesting mechanism
   */
  function _getVestingQuantity(VestingSchedule memory schedule) internal view returns (uint256) {
    if (_getBlockTime() >= uint256(schedule.endTime)) {
      return uint256(schedule.quantity).sub(schedule.vestedQuantity);
    }
    if (_getBlockTime() <= uint256(schedule.startTime)) {
      return 0;
    }
    uint256 lockDuration = uint256(schedule.endTime).sub(schedule.startTime);
    uint256 passedDuration = _getBlockTime() - uint256(schedule.startTime);
    return passedDuration.mul(schedule.quantity).div(lockDuration).sub(schedule.vestedQuantity);
  }

  /**
   * @dev wrap block.timestamp so we can easily mock it
   */
  function _getBlockTime() internal virtual view returns (uint32) {
    return uint32(block.timestamp);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;

import "./IERC20.sol";


/**
 * @dev Interface extending ERC20 standard to include decimals() as
 *      it is optional in the OpenZeppelin IERC20 interface.
 */
interface IERC20Ext is IERC20 {
    /**
     * @dev This function is required as Kyber requires to interact
     *      with token.decimals() with many of its operations.
     */
    function decimals() external view returns (uint8 digits);
}

// SPDX-License-Identifier: agpl-3.0
pragma solidity 0.7.6;
pragma abicoder v2;

import {IERC20Ext} from './IERC20Ext.sol';

interface IKyberRewardLockerV2 {
  struct VestingSchedule {
    uint64 startTime;
    uint64 endTime;
    uint128 quantity;
    uint128 vestedQuantity;
  }

  event VestingEntryCreated(
    IERC20Ext indexed token,
    address indexed beneficiary,
    uint256 startTime,
    uint256 endTime,
    uint256 quantity,
    uint256 index
  );

  event VestingEntryQueued(
    uint256 indexed index,
    IERC20Ext indexed token,
    address indexed beneficiary,
    uint256 quantity
  );

  event Vested(
    IERC20Ext indexed token,
    address indexed beneficiary,
    uint256 vestedQuantity,
    uint256 index
  );

  /**
   * @dev queue a vesting schedule starting from now
   */
  function lock(
    IERC20Ext token,
    address account,
    uint256 amount,
    uint32 vestingDuration
  ) external payable;

  /**
   * @dev queue a vesting schedule
   */
  function lockWithStartTime(
    IERC20Ext token,
    address account,
    uint256 quantity,
    uint256 startTime,
    uint32 vestingDuration
  ) external payable;

  /**
   * @dev vest all completed schedules for multiple tokens
   */
  function vestCompletedSchedulesForMultipleTokens(IERC20Ext[] calldata tokens)
    external
    returns (uint256[] memory vestedAmounts);

  /**
   * @dev claim multiple tokens for specific vesting schedule,
   *      if schedule has not ended yet, claiming amounts are linear with vesting times
   */
  function vestScheduleForMultipleTokensAtIndices(
    IERC20Ext[] calldata tokens,
    uint256[][] calldata indices
  ) external returns (uint256[] memory vestedAmounts);

  /**
   * @dev for all completed schedule, claim token
   */
  function vestCompletedSchedules(IERC20Ext token) external returns (uint256);

  /**
   * @dev claim token for specific vesting schedule,
   * @dev if schedule has not ended yet, claiming amount is linear with vesting times
   */
  function vestScheduleAtIndices(IERC20Ext token, uint256[] calldata indexes)
    external
    returns (uint256);

  /**
   * @dev claim token for specific vesting schedule from startIndex to endIndex
   */
  function vestSchedulesInRange(
    IERC20Ext token,
    uint256 startIndex,
    uint256 endIndex
  ) external returns (uint256);

  /**
   * @dev length of vesting schedules array
   */
  function numVestingSchedules(address account, IERC20Ext token) external view returns (uint256);

  /**
   * @dev get detailed of each vesting schedule
   */
  function getVestingScheduleAtIndex(
    address account,
    IERC20Ext token,
    uint256 index
  ) external view returns (VestingSchedule memory);

  /**
   * @dev get vesting shedules array
   */
  function getVestingSchedules(address account, IERC20Ext token)
    external
    view
    returns (VestingSchedule[] memory schedules);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.7.6;


abstract contract PermissionAdmin {
    address public admin;
    address public pendingAdmin;

    event AdminClaimed(address newAdmin, address previousAdmin);

    event TransferAdminPending(address pendingAdmin);

    constructor(address _admin) {
        require(_admin != address(0), "admin 0");
        admin = _admin;
    }

    modifier onlyAdmin() {
        require(msg.sender == admin, "only admin");
        _;
    }

    /**
     * @dev Allows the current admin to set the pendingAdmin address.
     * @param newAdmin The address to transfer ownership to.
     */
    function transferAdmin(address newAdmin) public onlyAdmin {
        require(newAdmin != address(0), "new admin 0");
        emit TransferAdminPending(newAdmin);
        pendingAdmin = newAdmin;
    }

    /**
     * @dev Allows the current admin to set the admin in one tx. Useful initial deployment.
     * @param newAdmin The address to transfer ownership to.
     */
    function transferAdminQuickly(address newAdmin) public onlyAdmin {
        require(newAdmin != address(0), "admin 0");
        emit TransferAdminPending(newAdmin);
        emit AdminClaimed(newAdmin, admin);
        admin = newAdmin;
    }

    /**
     * @dev Allows the pendingAdmin address to finalize the change admin process.
     */
    function claimAdmin() public {
        require(pendingAdmin == msg.sender, "not pending");
        emit AdminClaimed(pendingAdmin, admin);
        admin = pendingAdmin;
        pendingAdmin = address(0);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;


/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such 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.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        require(value < 2**255, "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

import "./IERC20.sol";
import "./SafeMath.sol";
import "./Address.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

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

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

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

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

[{"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"}],"name":"AdminClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rewardContract","type":"address"},{"indexed":true,"internalType":"contract IERC20Ext","name":"token","type":"address"},{"indexed":false,"internalType":"bool","name":"isAdded","type":"bool"}],"name":"RewardContractAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pendingAdmin","type":"address"}],"name":"TransferAdminPending","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20Ext","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"vestedQuantity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"Vested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20Ext","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"VestingEntryCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"contract IERC20Ext","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"VestingEntryQueued","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"contract IERC20Ext","name":"","type":"address"}],"name":"accountEscrowedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"contract IERC20Ext","name":"","type":"address"}],"name":"accountVestedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"address","name":"_rewardContract","type":"address"}],"name":"addRewardsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"}],"name":"getRewardContractsPerToken","outputs":[{"internalType":"address[]","name":"rewardContracts","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getVestingScheduleAtIndex","outputs":[{"components":[{"internalType":"uint64","name":"startTime","type":"uint64"},{"internalType":"uint64","name":"endTime","type":"uint64"},{"internalType":"uint128","name":"quantity","type":"uint128"},{"internalType":"uint128","name":"vestedQuantity","type":"uint128"}],"internalType":"struct IKyberRewardLockerV2.VestingSchedule","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract IERC20Ext","name":"token","type":"address"}],"name":"getVestingSchedules","outputs":[{"components":[{"internalType":"uint64","name":"startTime","type":"uint64"},{"internalType":"uint64","name":"endTime","type":"uint64"},{"internalType":"uint128","name":"quantity","type":"uint128"},{"internalType":"uint128","name":"vestedQuantity","type":"uint128"}],"internalType":"struct IKyberRewardLockerV2.VestingSchedule[]","name":"schedules","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint32","name":"vestingDuration","type":"uint32"}],"name":"lock","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint32","name":"vestingDuration","type":"uint32"}],"name":"lockWithStartTime","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract IERC20Ext","name":"token","type":"address"}],"name":"numVestingSchedules","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"address","name":"_rewardContract","type":"address"}],"name":"removeRewardsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdminQuickly","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"}],"name":"vestCompletedSchedules","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext[]","name":"tokens","type":"address[]"}],"name":"vestCompletedSchedulesForMultipleTokens","outputs":[{"internalType":"uint256[]","name":"vestedAmounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"uint256[]","name":"indexes","type":"uint256[]"}],"name":"vestScheduleAtIndices","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext[]","name":"tokens","type":"address[]"},{"internalType":"uint256[][]","name":"indices","type":"uint256[][]"}],"name":"vestScheduleForMultipleTokensAtIndices","outputs":[{"internalType":"uint256[]","name":"vestedAmounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Ext","name":"token","type":"address"},{"internalType":"uint256","name":"startIndex","type":"uint256"},{"internalType":"uint256","name":"endIndex","type":"uint256"}],"name":"vestSchedulesInRange","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000375442dcacefc8f93be8a102ea30aa16b658f1e1

-----Decoded View---------------
Arg [0] : _admin (address): 0x375442dcacefc8f93be8a102ea30aa16b658f1e1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000375442dcacefc8f93be8a102ea30aa16b658f1e1

422:10336:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8274:225;;;;;;;;;;-1:-1:-1;8274:225:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6527:922;;;;;;;;;;-1:-1:-1;6527:922:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2553:224::-;;;;;;:::i;:::-;;:::i;:::-;;123:27:6;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;8559:416:5:-;;;;;;;;;;-1:-1:-1;8559:416:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1313:77::-;;;;;;;;;;-1:-1:-1;1313:77:5;;;;;:::i;:::-;;:::i;2291:258::-;;;;;;;;;;-1:-1:-1;2291:258:5;;;;;:::i;:::-;;:::i;3341:441::-;;;;;;;;;;-1:-1:-1;3341:441:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8023:186::-;;;;;;;;;;-1:-1:-1;8023:186:5;;;;;:::i;:::-;;:::i;1175:79::-;;;;;;;;;;-1:-1:-1;1175:79:5;;;;;:::i;:::-;;:::i;637:199:6:-;;;;;;;;;;-1:-1:-1;637:199:6;;;;;:::i;:::-;;:::i;1354:209::-;;;;;;;;;;;;;:::i;1011:239::-;;;;;;;;;;-1:-1:-1;1011:239:6;;;;;:::i;:::-;;:::i;2852:322:5:-;;;;;;;;;;-1:-1:-1;2852:322:5;;;;;:::i;:::-;;:::i;8979:337::-;;;;;;;;;;-1:-1:-1;8979:337:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;7453:441::-;;;;;;;;;;-1:-1:-1;7453:441:5;;;;;:::i;:::-;;:::i;1844:380::-;;;;;;;;;;-1:-1:-1;1844:380:5;;;;;:::i;:::-;;:::i;97:20:6:-;;;;;;;;;;;;;:::i;5630:824:5:-;;;;;;;;;;-1:-1:-1;5630:824:5;;;;;:::i;:::-;;:::i;3786:1777::-;;;;;;:::i;:::-;;:::i;8274:225::-;8406:22;;:::i;:::-;-1:-1:-1;;;;;;8443:32:5;;;;;;;:23;:32;;;;;;;;:39;;;;;;;;;;;:51;;;:44;;;;:51;;;;;;8436:58;;;;;;;;;;;;;;;-1:-1:-1;;;8436:58:5;;;;;;;;;;-1:-1:-1;;;;;;;;8436:58:5;;;;;;;;;;;;;;;;;;;;;8274:225;;;;;;:::o;6527:922::-;6716:10;6638:7;6692:35;;;:23;:35;;;;;;;;-1:-1:-1;;;;;6692:42:5;;;;;;;;;6766:16;;6638:7;;6818:559;6842:7;:14;6838:1;:18;6818:559;;;6892:15;6879:7;6887:1;6879:10;;;;;;;;;;;;;;:28;6871:63;;;;-1:-1:-1;;;6871:63:5;;;;;;;:::i;:::-;;;;;;;;;6942:31;6976:9;:14;;:26;6991:7;6999:1;6991:10;;;;;;;;;;;;;;;;;;;6976:26;;;;;;;;;;;;;-1:-1:-1;6976:26:5;;;6942:60;;;;;;;;;;;;;;;-1:-1:-1;;;6942:60:5;;;;;;;;;;-1:-1:-1;;;;;;;;6942:60:5;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7033:29:5;6942:60;7033:19;:29::i;:::-;7010:52;-1:-1:-1;7074:17:5;7070:50;;7103:8;;;;7070:50;7179:23;;;;7171:80;;:59;;-1:-1:-1;;;;;7171:32:5;7217:12;7171:45;:59::i;:::-;:78;:80::i;:::-;7127:9;:14;;:26;7142:7;7150:1;7142:10;;;;;;;;;;;;;;7127:26;;;;;;;;;;;:41;;;:124;;;;;-1:-1:-1;;;;;7127:124:5;;;;;-1:-1:-1;;;;;7127:124:5;;;;;;7275:30;7292:12;7275;:16;;:30;;;;:::i;:::-;7260:45;;7333:10;-1:-1:-1;;;;;7319:51:5;7326:5;-1:-1:-1;;;;;7319:51:5;;7345:12;7359:7;7367:1;7359:10;;;;;;;;;;;;;;7319:51;;;;;;;:::i;:::-;;;;;;;;6818:559;;;6858:3;;6818:559;;;;7382:37;7399:5;7406:12;7382:16;:37::i;:::-;7432:12;-1:-1:-1;;;6527:922:5;;;;;:::o;2553:224::-;2695:77;2713:5;2720:7;2729:8;2739:15;:13;:15::i;:::-;2695:77;;2756:15;2695:17;:77::i;:::-;2553:224;;;;:::o;123:27:6:-;;;-1:-1:-1;;;;;123:27:6;;:::o;8559:416:5:-;-1:-1:-1;;;;;8740:32:5;;;8714:23;8740:32;;;:23;:32;;;;;;;;:39;;;;;;;;;:46;8670:34;;8740:46;8804:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;8792:50;;8853:9;8848:123;8872:15;8868:1;:19;8848:123;;;-1:-1:-1;;;;;8917:32:5;;;;;;;:23;:32;;;;;;;;:39;;;;;;;;;;;:47;;;:44;;;;:47;;;;;;8902:62;;;;;;;;;;;;;;;-1:-1:-1;;;8902:62:5;;;;;;;;;;-1:-1:-1;;;;;;;;8902:62:5;;;;;;;;;;;;;;;;;;;;;:12;;:9;;8962:1;;8902:12;;;;;;;;;;;;;;;:62;8889:3;;8848:123;;;;8559:416;;;;;:::o;1313:77::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;2291:258::-;446:5:6;;-1:-1:-1;;;;;446:5:6;432:10;:19;424:42;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;;;;-1:-1:-1;;;;;2397:30:5;::::1;;::::0;;;:23:::1;:30;::::0;;;;:54:::1;::::0;2435:15;2397:37:::1;:54::i;:::-;2389:93;;;;-1:-1:-1::0;;;2389:93:5::1;;;;;;;:::i;:::-;2531:5;-1:-1:-1::0;;;;;2494:50:5::1;2514:15;-1:-1:-1::0;;;;;2494:50:5::1;;2538:5;2494:50;;;;;;:::i;:::-;;;;;;;;2291:258:::0;;:::o;3341:441::-;3487:30;3533:31;;;3525:75;;;;-1:-1:-1;;;3525:75:5;;;;;;;:::i;:::-;3636:6;3622:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3622:28:5;;3606:44;;3661:9;3656:122;3676:17;;;3656:122;;;3727:44;3749:6;;3756:1;3749:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;3760:7;;3768:1;3760:10;;;;;;;;;;;;;;;;;;:::i;:::-;3727:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3727:21:5;;-1:-1:-1;;;3727:44:5:i;:::-;3708:13;3722:1;3708:16;;;;;;;;;;;;;;;;;:63;3695:3;;3656:122;;;;3341:441;;;;;;:::o;8023:186::-;-1:-1:-1;;;;;8158:32:5;;;8134:7;8158:32;;;:23;:32;;;;;;;;:39;;;;;;;;;;;:46;;8023:186::o;1175:79::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;637:199:6:-;446:5;;-1:-1:-1;;;;;446:5:6;432:10;:19;424:42;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;;;;-1:-1:-1;;;;;713:22:6;::::1;705:46;;;::::0;;-1:-1:-1;;;705:46:6;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;766:30;::::0;;-1:-1:-1;;;;;766:30:6;::::1;::::0;;;;::::1;::::0;;;;::::1;::::0;;::::1;806:12;:23:::0;;-1:-1:-1;;806:23:6::1;-1:-1:-1::0;;;;;806:23:6;;;::::1;::::0;;;::::1;::::0;;637:199::o;1354:209::-;1401:12;;-1:-1:-1;;;;;1401:12:6;1417:10;1401:26;1393:50;;;;;-1:-1:-1;;;1393:50:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;1471:12;;;1485:5;1458:33;;;-1:-1:-1;;;;;1471:12:6;;;1458:33;;1485:5;;;;1458:33;;;;;;;;;;;;;;;;1509:12;;;;1501:20;;-1:-1:-1;;1501:20:6;;;-1:-1:-1;;;;;1509:12:6;;1501:20;;;;1531:25;;;1354:209::o;1011:239::-;446:5;;-1:-1:-1;;;;;446:5:6;432:10;:19;424:42;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;;;;-1:-1:-1;;;;;1094:22:6;::::1;1086:42;;;::::0;;-1:-1:-1;;;1086:42:6;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;1143:30;::::0;;-1:-1:-1;;;;;1143:30:6;::::1;::::0;;;;::::1;::::0;;;;::::1;::::0;;::::1;1211:5;::::0;1188:29:::1;::::0;;-1:-1:-1;;;;;1188:29:6;;::::1;::::0;;1211:5;;::::1;1188:29;::::0;::::1;::::0;;;::::1;::::0;;;;;;;;::::1;1227:5;:16:::0;;-1:-1:-1;;1227:16:6::1;-1:-1:-1::0;;;;;1227:16:6;;;::::1;::::0;;;::::1;::::0;;1011:239::o;2852:322:5:-;2969:30;3039:6;3025:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3025:28:5;;3009:44;;3064:9;3059:111;3079:17;;;3059:111;;;3130:33;3153:6;;3160:1;3153:9;;;;;;;;;;;;;;;;;;;;:::i;3130:33::-;3111:13;3125:1;3111:16;;;;;;;;;;;;;;;;;:52;3098:3;;3059:111;;;;2852:322;;;;:::o;8979:337::-;-1:-1:-1;;;;;9141:30:5;;;;;;:23;:30;;;;;9067:32;;9141:39;;:37;:39::i;:::-;9127:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9127:54:5;;9109:72;;9192:9;9187:125;9211:15;:22;9207:1;:26;9187:125;;;-1:-1:-1;;;;;9269:30:5;;;;;;:23;:30;;;;;:36;;9303:1;9269:33;:36::i;:::-;9248:15;9264:1;9248:18;;;;;;;;-1:-1:-1;;;;;9248:57:5;;;:18;;;;;;;;;;;:57;9235:3;;9187:125;;;;8979:337;;;:::o;7453:441::-;7579:7;7616:8;7602:10;:22;;7594:56;;;;-1:-1:-1;;;7594:56:5;;;;;;;:::i;:::-;7656:24;7708:10;7697:8;:21;7721:1;7697:25;7683:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7683:40:5;-1:-1:-1;7656:67:5;-1:-1:-1;7750:10:5;7729:111;7771:8;7762:5;:17;7729:111;;7828:5;7798:7;7814:10;7806:5;:18;7798:27;;;;;;;;;;;;;;;;;:35;7781:7;;7729:111;;;;7852:37;7874:5;7881:7;7852:21;:37::i;:::-;7845:44;7453:441;-1:-1:-1;;;;;7453:441:5:o;1844:380::-;446:5:6;;-1:-1:-1;;;;;446:5:6;432:10;:19;424:42;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;-1:-1:-1;;;424:42:6;;;;;;;;;;;;;;;-1:-1:-1;;;;;1954:30:5;::::1;;::::0;;;:23:::1;:30;::::0;;;;795:3:::1;::::0;1954:39:::1;::::0;:37:::1;:39::i;:::-;:67;1939:125;;;;-1:-1:-1::0;;;1939:125:5::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;2078:30:5;::::1;;::::0;;;:23:::1;:30;::::0;;;;:51:::1;::::0;2113:15;2078:34:::1;:51::i;:::-;2070:88;;;;-1:-1:-1::0;;;2070:88:5::1;;;;;;;:::i;:::-;2207:5;-1:-1:-1::0;;;;;2170:49:5::1;2190:15;-1:-1:-1::0;;;;;2170:49:5::1;;2214:4;2170:49;;;;;;:::i;97:20:6:-:0;;;-1:-1:-1;;;;;97:20:6;;:::o;5630:824:5:-;5780:10;5704:7;5756:35;;;:23;:35;;;;;;;;-1:-1:-1;;;;;5756:42:5;;;;;;;;;5830:16;;5704:7;;5883:498;5907:15;5903:1;:19;5883:498;;;5937:31;5971:17;;;:14;;;;:17;;;;;;;;;5937:51;;;;;;;;;;;;;;;-1:-1:-1;;;5937:51:5;;;;;;;;;-1:-1:-1;;;;;;;;5937:51:5;;;;;;;;;;;;;;;;;;;;;;;6000:15;:13;:15::i;:::-;:34;;;5996:67;;;6046:8;;;5996:67;6070:20;6093:55;6124:8;:23;;;-1:-1:-1;;;;;6093:55:5;6101:8;:17;;;-1:-1:-1;;;;;6093:26:5;:30;;:55;;;;:::i;:::-;6070:78;-1:-1:-1;6160:17:5;6156:50;;6189:8;;;;6156:50;6248:17;;;;;6213;;;;:14;;;;:17;;;;;:32;;;:52;;-1:-1:-1;;6213:52:5;-1:-1:-1;;;;;6213:52:5;;;;;;;;;6288:30;:12;6305;6288:16;:30::i;:::-;6273:45;;6346:10;-1:-1:-1;;;;;6332:42:5;6339:5;-1:-1:-1;;;;;6332:42:5;;6358:12;6372:1;6332:42;;;;;;;:::i;:::-;;;;;;;;5883:498;;;5924:3;;5883:498;;;;6386:37;6403:5;6410:12;6386:16;:37::i;:::-;6437:12;-1:-1:-1;;;5630:824:5;;;;:::o;3786:1777::-;-1:-1:-1;;;;;1634:30:5;;;;;;:23;:30;;;;;3976:5;;1634:51;;1674:10;1634:39;:51::i;:::-;1626:84;;;;-1:-1:-1;;;1626:84:5;;;;;;;:::i;:::-;4008:1:::1;3997:8;:12;3989:35;;;;-1:-1:-1::0;;;3989:35:5::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;4035:21:5;::::1;4031:235;;4087:8;4074:9;:21;4066:51;;;;-1:-1:-1::0;;;4066:51:5::1;;;;;;;:::i;:::-;4031:235;;;4200:59;-1:-1:-1::0;;;;;4200:22:5;::::1;4223:10;4243:4;4250:8:::0;4200:22:::1;:59::i;:::-;-1:-1:-1::0;;;;;4309:32:5;;::::1;4272:34;4309:32:::0;;;:23:::1;:32;::::0;;;;;;;:39;;::::1;::::0;;;;;;;;4380:16;;4309:39;;4420:30:::1;:9:::0;:30:::1;::::0;;::::1;::::0;:13:::1;:30;:::i;:::-;4402:48:::0;-1:-1:-1;4539:19:5;;4535:515:::1;;-1:-1:-1::0;;4622:19:5;;4568:36:::1;4607:35:::0;;;:14:::1;::::0;::::1;:35;::::0;;;;4654:22;;::::1;;:35:::0;::::1;:70:::0;::::1;;;-1:-1:-1::0;4693:20:5;;-1:-1:-1;;;4693:20:5;::::1;;;:31:::0;::::1;4654:70;4650:394;;;4768:21:::0;;4760:56:::1;::::0;:44:::1;::::0;-1:-1:-1;;;4768:21:5;::::1;-1:-1:-1::0;;;;;4768:21:5::1;4795:8:::0;4760:34:::1;:44::i;:56::-;4736:80:::0;;-1:-1:-1;;;;;4736:80:5;;::::1;-1:-1:-1::0;;;4736:80:5::1;::::0;::::1;;::::0;;-1:-1:-1;;;;;4867:31:5;;::::1;4736:21;4867:31:::0;;;:22:::1;:31;::::0;;;;;;;:38;;::::1;::::0;;;;;;;:72:::1;::::0;4921:8;4867:42:::1;:72::i;:::-;4826:22;:31;4849:7;-1:-1:-1::0;;;;;4826:31:5::1;-1:-1:-1::0;;;;;4826:31:5::1;;;;;;;;;;;;:38;4858:5;-1:-1:-1::0;;;;;4826:38:5::1;-1:-1:-1::0;;;;;4826:38:5::1;;;;;;;;;;;;:113;;;;5001:7;-1:-1:-1::0;;;;;4954:65:5::1;4994:5;-1:-1:-1::0;;;;;4954:65:5::1;4991:1;4973:15;:19;4954:65;5010:8;4954:65;;;;;;:::i;:::-;;;;;;;;5029:7;;;;;;4650:394;4535:515;;5117:160;;;;;;;;5152:20;:9;:18;:20::i;:::-;5117:160;;;;;;5189:18;:7;:16;:18::i;:::-;5117:160;;;;;;5225:20;:8;:18;:20::i;:::-;-1:-1:-1::0;;;;;5117:160:5;;::::1;::::0;;5269:1:::1;5117:160;::::0;;::::1;::::0;;;5083:31;;;:14:::1;::::0;;::::1;:31:::0;;;;;;:194;;;;;;::::1;::::0;;;::::1;::::0;;::::1;-1:-1:-1::0;;;5083:194:5::1;;::::0;;::::1;-1:-1:-1::0;;;5083:194:5::1;::::0;;;;::::1;-1:-1:-1::0;;5083:194:5;;::::1;::::0;;;::::1;;::::0;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;;::::1;-1:-1:-1::0;;5083:194:5;;;::::1;::::0;;;::::1;::::0;;;5302:19;;::::1;5283:38:::0;;-1:-1:-1;;;;;5412:31:5;;::::1;::::0;;:22:::1;:31:::0;;;;;:38;;::::1;::::0;;;;;;;:52:::1;::::0;5455:8;5412:42:::1;:52::i;:::-;-1:-1:-1::0;;;;;5371:31:5;;::::1;;::::0;;;:22:::1;:31;::::0;;;;;;;:38;;::::1;::::0;;;;;;;;;;;:93;;;;5476:82;;::::1;::::0;::::1;::::0;5512:9;;5523:7;;5532:8;;5542:15;;5476:82:::1;:::i;:::-;;;;;;;;1716:1;;;;3786:1777:::0;;;;;;:::o;10017:562::-;10102:7;10148:8;:16;;;10140:25;;10121:15;:13;:15::i;:::-;:44;;;10117:127;;10182:55;10213:8;:23;;;-1:-1:-1;;;;;10182:55:5;10190:8;:17;;;-1:-1:-1;;;;;10182:26:5;:30;;:55;;;;:::i;:::-;10175:62;;;;10117:127;10280:18;;10272:27;;10253:15;:13;:15::i;:::-;:46;;;10249:75;;-1:-1:-1;10316:1:5;10309:8;;10249:75;10382:18;;10360:16;;;;10329:20;;10352:49;;;:25;;;;:49;:29;:49::i;:::-;10329:72;;10407:22;10458:8;:18;;;10450:27;;10432:15;:13;:15::i;:::-;:45;;;10407:70;;10490:84;10550:8;:23;;;-1:-1:-1;;;;;10490:84:5;:55;10532:12;10490:37;10509:8;:17;;;-1:-1:-1;;;;;10490:37:5;:14;:18;;:37;;;;:::i;:::-;:41;;:55::i;:::-;:59;;:84::i;2682:175:9:-;2740:7;2771:5;;;2794:6;;;;2786:46;;;;;-1:-1:-1;;;2786:46:9;;;;;;;;;;;;;;;;;;;;;;;;;;;1078:181:7;1135:7;-1:-1:-1;;;1162:5:7;:14;1154:67;;;;-1:-1:-1;;;1154:67:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1246:5:7;1078:181::o;9370:585:5:-;9458:17;9450:46;;;;-1:-1:-1;;;9450:46:5;;;;;;;:::i;:::-;9569:10;9546:34;;;;:22;:34;;;;;;;;-1:-1:-1;;;;;9546:41:5;;;;;;;;;;:71;;9599:12;9546:45;:71::i;:::-;9525:10;9502:34;;;;:22;:34;;;;;;;;-1:-1:-1;;;;;9502:41:5;;;;;;;;;;;:115;;;;9665:32;;;:20;:32;;;;;:39;;;;;;;;;;:69;;9716:12;9665:43;:69::i;:::-;9644:10;9623:32;;;;:20;:32;;;;;;;;-1:-1:-1;;;;;9623:39:5;;;;;;;;;;:111;;;;9741:210;;9777:12;9795:10;-1:-1:-1;;;;;9795:15:5;9818:12;9795:40;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9776:59;;;9851:7;9843:36;;;;-1:-1:-1;;;9843:36:5;;;;;;;:::i;:::-;9741:210;;;;9900:44;-1:-1:-1;;;;;9900:18:5;;9919:10;9931:12;9900:18;:44::i;:::-;9370:585;;:::o;10651:105::-;10735:15;10651:105;:::o;6739:156:1:-;6812:4;6835:53;6843:3;-1:-1:-1;;;;;6863:23:1;;6835:7;:53::i;7222:115::-;7285:7;7311:19;7319:3;7311:7;:19::i;7669:156::-;7743:7;7793:22;7797:3;7809:5;7793:3;:22::i;6421:150::-;6491:4;6514:50;6519:3;-1:-1:-1;;;;;6539:23:1;;6514:4;:50::i;3128:155:9:-;3186:7;3218:1;3213;:6;;3205:49;;;;;-1:-1:-1;;;3205:49:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3271:5:9;;;3128:155::o;6976:165:1:-;7056:4;7079:55;7089:3;-1:-1:-1;;;;;7109:23:1;;7079:9;:55::i;858:203:8:-;985:68;;;-1:-1:-1;;;;;985:68:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1008:27;985:68;;;958:96;;978:5;;958:19;:96::i;1546:176:7:-;1602:6;-1:-1:-1;;;1628:5:7;:13;1620:65;;;;-1:-1:-1;;;1620:65:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3530:215:9;3588:7;3611:6;3607:20;;-1:-1:-1;3626:1:9;3619:8;;3607:20;3649:5;;;3653:1;3649;:5;:1;3672:5;;;;;:10;3664:56;;;;-1:-1:-1;;;3664:56:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4209:150;4267:7;4298:1;4294;:5;4286:44;;;;;-1:-1:-1;;;4286:44:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;4351:1;4347;:5;;;;;;;4209:150;-1:-1:-1;;;4209:150:9:o;677:175:8:-;786:58;;;-1:-1:-1;;;;;786:58:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;809:23;786:58;;;759:86;;779:5;;759:19;:86::i;:::-;677:175;;;:::o;2204:1512:1:-;2270:4;2407:19;;;:12;;;:19;;;;;;2441:15;;2437:1273;;2870:18;;-1:-1:-1;;2822:14:1;;;;2870:22;;;;2798:21;;2870:3;;:22;;3152;;;;;;;;;;;;;;3132:42;;3295:9;3266:3;:11;;3278:13;3266:26;;;;;;;;;;;;;;;;;;;:38;;;;3370:23;;;3412:1;3370:12;;;:23;;;;;;3396:17;;;3370:43;;3519:17;;3370:3;;3519:17;;;;;;;;;;;;;;;;;;;;;;3611:3;:12;;:19;3624:5;3611:19;;;;;;;;;;;3604:26;;;3652:4;3645:11;;;;;;;;2437:1273;3694:5;3687:12;;;;;4005:107;4087:18;;4005:107::o;4444:201::-;4538:18;;4511:7;;4538:26;-1:-1:-1;4530:73:1;;;;-1:-1:-1;;;4530:73:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4620:3;:11;;4632:5;4620:18;;;;;;;;;;;;;;;;4613:25;;4444:201;;;;:::o;1632:404::-;1695:4;1716:21;1726:3;1731:5;1716:9;:21::i;:::-;1711:319;;-1:-1:-1;1753:23:1;;;;;;;;:11;:23;;;;;;;;;;;;;1933:18;;1911:19;;;:12;;;:19;;;;;;:40;;;;1965:11;;1711:319;-1:-1:-1;2014:5:1;2007:12;;3797:127;3870:4;3893:19;;;:12;;;;;:19;;;;;;:24;;;3797:127::o;2940:751:8:-;3359:23;3385:69;3413:4;3385:69;;;;;;;;;;;;;;;;;3393:5;-1:-1:-1;;;;;3385:27:8;;;:69;;;;;:::i;:::-;3468:17;;3359:95;;-1:-1:-1;3468:21:8;3464:221;;3608:10;3597:30;;;;;;;;;;;;;;;-1:-1:-1;3597:30:8;3589:85;;;;-1:-1:-1;;;3589:85:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3573:193:0;3676:12;3707:52;3729:6;3737:4;3743:1;3746:12;3707:21;:52::i;:::-;3700:59;3573:193;-1:-1:-1;;;;3573:193:0:o;4600:523::-;4727:12;4784:5;4759:21;:30;;4751:81;;;;-1:-1:-1;;;4751:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4850:18;4861:6;4850:10;:18::i;:::-;4842:60;;;;;-1:-1:-1;;;4842:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;4973:12;4987:23;5014:6;-1:-1:-1;;;;;5014:11:0;5034:5;5042:4;5014:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5014:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4972:75;;;;5064:52;5082:7;5091:10;5103:12;5064:17;:52::i;:::-;5057:59;4600:523;-1:-1:-1;;;;;;;4600:523:0:o;718:413::-;1078:20;1116:8;;;718:413::o;7083:725::-;7198:12;7226:7;7222:580;;;-1:-1:-1;7256:10:0;7249:17;;7222:580;7367:17;;:21;7363:429;;7625:10;7619:17;7685:15;7672:10;7668:2;7664:19;7657:44;7574:145;7764:12;7757:20;;-1:-1:-1;;;7757:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:423:10:-;;;170:3;163:4;155:6;151:17;147:27;137:2;;193:6;185;178:22;137:2;-1:-1:-1;221:20:10;;264:18;253:30;;250:2;;;303:8;293;286:26;250:2;347:4;339:6;335:17;323:29;;410:3;403:4;395;387:6;383:17;375:6;371:30;367:41;364:50;361:2;;;427:1;424;417:12;361:2;127:310;;;;;:::o;442:165::-;511:20;;571:10;560:22;;550:33;;540:2;;597:1;594;587:12;612:259;;724:2;712:9;703:7;699:23;695:32;692:2;;;745:6;737;730:22;692:2;789:9;776:23;808:33;835:5;808:33;:::i;876:419::-;;;1022:2;1010:9;1001:7;997:23;993:32;990:2;;;1043:6;1035;1028:22;990:2;1087:9;1074:23;1106:33;1133:5;1106:33;:::i;:::-;1158:5;-1:-1:-1;1215:2:10;1200:18;;1187:32;1228:35;1187:32;1228:35;:::i;:::-;1282:7;1272:17;;;980:315;;;;;:::o;1300:487::-;;;;1463:2;1451:9;1442:7;1438:23;1434:32;1431:2;;;1484:6;1476;1469:22;1431:2;1528:9;1515:23;1547:33;1574:5;1547:33;:::i;:::-;1599:5;-1:-1:-1;1656:2:10;1641:18;;1628:32;1669:35;1628:32;1669:35;:::i;:::-;1421:366;;1723:7;;-1:-1:-1;;;1777:2:10;1762:18;;;;1749:32;;1421:366::o;1792:503::-;;;1956:2;1944:9;1935:7;1931:23;1927:32;1924:2;;;1977:6;1969;1962:22;1924:2;2022:9;2009:23;2055:18;2047:6;2044:30;2041:2;;;2092:6;2084;2077:22;2041:2;2136:99;2227:7;2218:6;2207:9;2203:22;2136:99;:::i;:::-;2254:8;;2110:125;;-1:-1:-1;1914:381:10;-1:-1:-1;;;;1914:381:10:o;2300:905::-;;;;;2543:2;2531:9;2522:7;2518:23;2514:32;2511:2;;;2564:6;2556;2549:22;2511:2;2609:9;2596:23;2638:18;2679:2;2671:6;2668:14;2665:2;;;2700:6;2692;2685:22;2665:2;2744:99;2835:7;2826:6;2815:9;2811:22;2744:99;:::i;:::-;2862:8;;-1:-1:-1;2718:125:10;-1:-1:-1;2950:2:10;2935:18;;2922:32;;-1:-1:-1;2966:16:10;;;2963:2;;;3000:6;2992;2985:22;2963:2;;3044:101;3137:7;3126:8;3115:9;3111:24;3044:101;:::i;:::-;2501:704;;;;-1:-1:-1;3164:8:10;-1:-1:-1;;;;2501:704:10:o;3491:419::-;;;3637:2;3625:9;3616:7;3612:23;3608:32;3605:2;;;3658:6;3650;3643:22;3915:631;;;;;;4111:3;4099:9;4090:7;4086:23;4082:33;4079:2;;;4133:6;4125;4118:22;4079:2;4177:9;4164:23;4196:33;4223:5;4196:33;:::i;:::-;4248:5;-1:-1:-1;4305:2:10;4290:18;;4277:32;4318:35;4277:32;4318:35;:::i;:::-;4372:7;-1:-1:-1;4426:2:10;4411:18;;4398:32;;-1:-1:-1;4477:2:10;4462:18;;4449:32;;-1:-1:-1;4500:40:10;4535:3;4520:19;;4500:40;:::i;:::-;4490:50;;4069:477;;;;;;;;:::o;4551:562::-;;;;;4730:3;4718:9;4709:7;4705:23;4701:33;4698:2;;;4752:6;4744;4737:22;4698:2;4796:9;4783:23;4815:33;4842:5;4815:33;:::i;:::-;4867:5;-1:-1:-1;4924:2:10;4909:18;;4896:32;4937:35;4896:32;4937:35;:::i;:::-;4991:7;-1:-1:-1;5045:2:10;5030:18;;5017:32;;-1:-1:-1;5068:39:10;5103:2;5088:18;;5068:39;:::i;:::-;5058:49;;4688:425;;;;;;;:::o;5118:1294::-;;;5289:2;5277:9;5268:7;5264:23;5260:32;5257:2;;;5310:6;5302;5295:22;5257:2;5354:9;5341:23;5373:33;5400:5;5373:33;:::i;:::-;5425:5;-1:-1:-1;5449:2:10;5487:18;;;5474:32;5525:18;5555:14;;;5552:2;;;5587:6;5579;5572:22;5552:2;5630:6;5619:9;5615:22;5605:32;;5675:7;5668:4;5664:2;5660:13;5656:27;5646:2;;5702:6;5694;5687:22;5646:2;5743;5730:16;5765:2;5761;5758:10;5755:2;;;5771:9;5755:2;5809;5805;5801:11;5841:2;5835:9;5892:2;5887;5879:6;5875:15;5871:24;5945:6;5933:10;5930:22;5925:2;5913:10;5910:18;5907:46;5904:2;;;5956:9;5904:2;5983;5976:22;6033:18;;;6067:15;;;;-1:-1:-1;6102:11:10;;;6132;;;6128:20;;6125:33;-1:-1:-1;6122:2:10;;;6176:6;6168;6161:22;6122:2;6203:6;6194:15;;6218:163;6232:2;6229:1;6226:9;6218:163;;;6289:17;;6277:30;;6250:1;6243:9;;;;;6327:12;;;;6359;;6218:163;;;6222:3;6400:6;6390:16;;;;;;;;5247:1165;;;;;:::o;6417:412::-;;;;6580:2;6568:9;6559:7;6555:23;6551:32;6548:2;;;6601:6;6593;6586:22;6548:2;6645:9;6632:23;6664:33;6691:5;6664:33;:::i;:::-;6716:5;6768:2;6753:18;;6740:32;;-1:-1:-1;6819:2:10;6804:18;;;6791:32;;6538:291;-1:-1:-1;;;6538:291:10:o;6834:438::-;6916:18;6973:2;6965:5;6959:12;6955:21;6950:3;6943:34;7038:2;7030:4;7023:5;7019:16;7013:23;7009:32;7002:4;6997:3;6993:14;6986:56;;7088:4;7081:5;7077:16;7071:23;-1:-1:-1;;;;;7197:2:10;7183:12;7179:21;7172:4;7167:3;7163:14;7156:45;7262:2;7254:4;7247:5;7243:16;7237:23;7233:32;7226:4;7221:3;7217:14;7210:56;;;6896:376;;:::o;7277:205::-;7477:3;7468:14::o;7487:226::-;-1:-1:-1;;;;;7651:55:10;;;;7633:74;;7621:2;7606:18;;7588:125::o;7718:684::-;7889:2;7941:21;;;8011:13;;7914:18;;;8033:22;;;7718:684;;7889:2;8112:15;;;;8086:2;8071:18;;;7718:684;8158:218;8172:6;8169:1;8166:13;8158:218;;;8237:13;;-1:-1:-1;;;;;8233:62:10;8221:75;;8351:15;;;;8316:12;;;;8194:1;8187:9;8158:218;;;-1:-1:-1;8393:3:10;;7869:533;-1:-1:-1;;;;;;7869:533:10:o;8407:731::-;8642:2;8694:21;;;8764:13;;8667:18;;;8786:22;;;8407:731;;8642:2;8865:15;;;;8839:2;8824:18;;;8407:731;8911:201;8925:6;8922:1;8919:13;8911:201;;;8974:56;9026:3;9017:6;9011:13;8974:56;:::i;:::-;9087:15;;;;9059:4;9050:14;;;;;8947:1;8940:9;8911:201;;9143:635;9314:2;9366:21;;;9436:13;;9339:18;;;9458:22;;;9143:635;;9314:2;9537:15;;;;9511:2;9496:18;;;9143:635;9583:169;9597:6;9594:1;9591:13;9583:169;;;9658:13;;9646:26;;9727:15;;;;9692:12;;;;9619:1;9612:9;9583:169;;9783:187;9948:14;;9941:22;9923:41;;9911:2;9896:18;;9878:92::o;9975:346::-;10177:2;10159:21;;;10216:2;10196:18;;;10189:30;10255:24;10250:2;10235:18;;10228:52;10312:2;10297:18;;10149:172::o;10326:340::-;10528:2;10510:21;;;10567:2;10547:18;;;10540:30;10606:18;10601:2;10586:18;;10579:46;10657:2;10642:18;;10500:166::o;10671:348::-;10873:2;10855:21;;;10912:2;10892:18;;;10885:30;10951:26;10946:2;10931:18;;10924:54;11010:2;10995:18;;10845:174::o;11024:350::-;11226:2;11208:21;;;11265:2;11245:18;;;11238:30;11304:28;11299:2;11284:18;;11277:56;11365:2;11350:18;;11198:176::o;11379:341::-;11581:2;11563:21;;;11620:2;11600:18;;;11593:30;11659:19;11654:2;11639:18;;11632:47;11711:2;11696:18;;11553:167::o;11725:345::-;11927:2;11909:21;;;11966:2;11946:18;;;11939:30;12005:23;12000:2;11985:18;;11978:51;12061:2;12046:18;;11899:171::o;12075:340::-;12277:2;12259:21;;;12316:2;12296:18;;;12289:30;12355:18;12350:2;12335:18;;12328:46;12406:2;12391:18;;12249:166::o;12420:344::-;12622:2;12604:21;;;12661:2;12641:18;;;12634:30;12700:22;12695:2;12680:18;;12673:50;12755:2;12740:18;;12594:170::o;12769:355::-;12971:2;12953:21;;;13010:2;12990:18;;;12983:30;13049:33;13044:2;13029:18;;13022:61;13115:2;13100:18;;12943:181::o;13129:334::-;13331:2;13313:21;;;13370:2;13350:18;;;13343:30;13409:12;13404:2;13389:18;;13382:40;13454:2;13439:18;;13303:160::o;13468:351::-;13670:2;13652:21;;;13709:2;13689:18;;;13682:30;13748:29;13743:2;13728:18;;13721:57;13810:2;13795:18;;13642:177::o;13824:272::-;14022:3;14007:19;;14035:55;14011:9;14072:6;14035:55;:::i;14101:177::-;14247:25;;;14235:2;14220:18;;14202:76::o;14283:248::-;14457:25;;;14513:2;14498:18;;14491:34;14445:2;14430:18;;14412:119::o;14536:391::-;14767:25;;;14823:2;14808:18;;14801:34;;;;14866:2;14851:18;;14844:34;14909:2;14894:18;;14887:34;14754:3;14739:19;;14721:206::o;14932:560::-;;;15091:11;15078:25;15185:2;15181:7;15170:8;15154:14;15150:29;15146:43;15126:18;15122:68;15112:2;;15207:4;15201;15194:18;15112:2;15237:33;;15289:20;;;-1:-1:-1;15332:18:10;15321:30;;15318:2;;;15367:4;15361;15354:18;15318:2;15403:4;15391:17;;;;-1:-1:-1;15450:17:10;;15434:14;15430:38;15420:49;;15417:2;;;15482:1;15479;15472:12;15497:156;-1:-1:-1;;;;;15578:5:10;15574:54;15567:5;15564:65;15554:2;;15643:1;15640;15633:12;15554:2;15544:109;:::o

ipfs://0633c0ac5ce65d609b85e85a593924b5e073d8addf7dba96726f78ad7f75a46f