github.com/DxChainNetwork/dxc@v0.8.1-0.20220824085222-1162e304b6e7/consensus/dpos/systemcontract/contracts/Migrate.sol

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

// OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)
/**

 * @dev Library for managing

 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive

 * types.
   *

 * Sets have the following properties:
   *

 * - Elements are added, removed, and checked for existence in constant time

 * (O(1)).

 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
     *

 * ```

   ```

 * contract Example {

 * // Add the library methods

 * using EnumerableSet for EnumerableSet.AddressSet;
    *

 * // Declare a set state variable

 * EnumerableSet.AddressSet private mySet;

 * }

 * ```
   *
   ```

 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)

 * and `uint256` (`UintSet`) are supported.
   *

 * [WARNING]

 * ====

 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.

 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
   *

 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.

 * ====
   */
   library EnumerableSet {
   // To implement this library for multiple types with as little code
   // repetition as possible, we write it in terms of a generic Set type with
   // bytes32 values.
   // The Set implementation uses private functions, and user-facing
   // implementations (such as AddressSet) are just wrappers around the
   // underlying Set.
   // This means that we can only create new EnumerableSets for types that fit
   // in bytes32.

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

   /**

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

   /**

    * @dev Removes a value from a set. O(1).
      *

    * Returns true if the value was removed from the set, that is if it was

    * present.
      */
      function _remove(Set storage set, bytes32 value) private returns (bool) {
      // We read and store the value's index to prevent multiple reads from the same storage slot
      uint256 valueIndex = set._indexes[value];

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

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

          if (lastIndex != toDeleteIndex) {
              bytes32 lastValue = set._values[lastIndex];

              // Move the last value to the index where the value to delete is
              set._values[toDeleteIndex] = lastValue;
              // Update the index for the moved value
              set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
          }

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

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

          return true;

      } else {
          return false;
      }
      }

   /**

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

   /**

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

   /**

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

   /**

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

   // Bytes32Set

   struct Bytes32Set {
       Set _inner;
   }

   /**

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

   /**

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

   /**

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

   /**

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

   /**

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

   /**

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

   // AddressSet

   struct AddressSet {
       Set _inner;
   }

   /**

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

   /**

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

   /**

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

   /**

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

   /**

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

   /**

    * @dev Return the entire set in an array
      *

    * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed

    * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that

    * this function has an unbounded cost, and using it as part of a state-changing function may render the function

    * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
      */
      function values(AddressSet storage set)
      internal
      view
      returns (address[] memory)
      {
      bytes32[] memory store = _values(set._inner);
      address[] memory result;

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

      return result;
      }

   // UintSet

   struct UintSet {
       Set _inner;
   }

   /**

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

   /**

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

   /**

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

   /**

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

   /**

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

   /**

    * @dev Return the entire set in an array
      *

    * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed

    * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that

    * this function has an unbounded cost, and using it as part of a state-changing function may render the function

    * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
      */
      function values(UintSet storage set)
      internal
      view
      returns (uint256[] memory)
      {
      bytes32[] memory store = _values(set._inner);
      uint256[] memory result;

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

      return result;
      }
      }

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
/**

 * @dev Provides information about the current execution context, including the

 * sender of the transaction and its data. While these are generally available

 * via msg.sender and msg.data, they should not be accessed in such a direct

 * manner, since when dealing with meta-transactions the account sending and

 * paying for execution may not be the actual sender (as far as an application

 * is concerned).
   *

 * This contract is only required for intermediate, library-like contracts.
   */
   abstract contract Context {
   function _msgSender() internal view virtual returns (address) {
       return msg.sender;
   }

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

// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
/**

 * @dev Contract module which allows children to implement an emergency stop

 * mechanism that can be triggered by an authorized account.
   *

 * This module is used through inheritance. It will make available the

 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to

 * the functions of your contract. Note that they will not be pausable by

 * simply including this module, only once the modifiers are put in place.
   */
   abstract contract Pausable is Context {
   /**

    * @dev Emitted when the pause is triggered by `account`.
      */
      event Paused(address account);

   /**

    * @dev Emitted when the pause is lifted by `account`.
      */
      event Unpaused(address account);

   bool private _paused;

   /**

    * @dev Initializes the contract in unpaused state.
      */
      constructor() {
      _paused = false;
      }

   /**

    * @dev Modifier to make a function callable only when the contract is not paused.
      *
    * Requirements:
      *
    * - The contract must not be paused.
        */
        modifier whenNotPaused() {
        _requireNotPaused();
        _;
        }

   /**

    * @dev Modifier to make a function callable only when the contract is paused.
      *
    * Requirements:
      *
    * - The contract must be paused.
        */
        modifier whenPaused() {
        _requirePaused();
        _;
        }

   /**

    * @dev Returns true if the contract is paused, and false otherwise.
      */
      function paused() public view virtual returns (bool) {
      return _paused;
      }

   /**

    * @dev Throws if the contract is paused.
      */
      function _requireNotPaused() internal view virtual {
      require(!paused(), "Pausable: paused");
      }

   /**

    * @dev Throws if the contract is not paused.
      */
      function _requirePaused() internal view virtual {
      require(paused(), "Pausable: not paused");
      }

   /**

    * @dev Triggers stopped state.
      *
    * Requirements:
      *
    * - The contract must not be paused.
        */
        function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
        }

   /**

    * @dev Returns to normal state.
      *
    * Requirements:
      *
    * - The contract must be paused.
        */
        function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
        }
        }

// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
/**

 * @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].
   */
   abstract 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() {
       _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 making 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;
      }
      }

// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
/**

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

    * ====
      *

    * [IMPORTANT]

    * ====

    * You shouldn't rely on `isContract` to protect against flash loan attacks!
      *

    * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets

    * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract

    * constructor.

    * ====
      */
      function isContract(address account) internal view returns (bool) {
      // This method relies on extcodesize/address.code.length, which returns 0
      // for contracts in construction, since the code is only stored at the end
      // of the constructor execution.

      return account.code.length > 0;
      }

   /**

    * @dev Replacement for Solidity's `transfer`: sends `amount` wei to

    * `recipient`, forwarding all available gas and reverting on errors.
      *

    * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost

    * of certain opcodes, possibly making contracts go over the 2300 gas limit

    * imposed by `transfer`, making them unable to receive funds via

    * `transfer`. {sendValue} removes this limitation.
      *

    * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
      *

    * IMPORTANT: because control is transferred to `recipient`, care must be

    * taken to not create reentrancy vulnerabilities. Consider using

    * {ReentrancyGuard} or the

    * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
      */
      function sendValue(address payable recipient, uint256 amount) internal {
      require(
          address(this).balance >= amount,
          "Address: insufficient balance"
      );

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

   /**

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

   /**

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

   /**

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

   /**

    * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but

    * with `errorMessage` as a fallback revert reason when `target` reverts.
      *

    * _Available since v3.1._
      */
      function functionCallWithValue(
      address target,
      bytes memory data,
      uint256 value,
      string memory errorMessage
      ) internal returns (bytes memory) {
      require(
          address(this).balance >= value,
          "Address: insufficient balance for call"
      );
      require(isContract(target), "Address: call to non-contract");

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

   /**

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

   /**

    * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],

    * but performing a static call.
      *

    * _Available since v3.3._
      */
      function functionStaticCall(
      address target,
      bytes memory data,
      string memory errorMessage
      ) internal view returns (bytes memory) {
      require(isContract(target), "Address: static call to non-contract");

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

   /**

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

   /**

    * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],

    * but performing a delegate call.
      *

    * _Available since v3.4._
      */
      function functionDelegateCall(
      address target,
      bytes memory data,
      string memory errorMessage
      ) internal returns (bytes memory) {
      require(isContract(target), "Address: delegate call to non-contract");

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

   /**

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

// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
/**

 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed

 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an

 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer

 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
   *

 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be

 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in

 * case an upgrade adds a module that needs to be initialized.
   *

 * For example:
   *

 * [.hljs-theme-light.nopadding]

 * ```

   ```

 * contract MyToken is ERC20Upgradeable {

 * function initialize() initializer public {

 * __ERC20_init("MyToken", "MTK");

 * }

 * }

 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {

 * function initializeV2() reinitializer(2) public {

 * __ERC20Permit_init("MyToken");

 * }

 * }

 * ```
   *
   ```

 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as

 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
   *

 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure

 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
   *

 * [CAUTION]

 * ====

 * Avoid leaving a contract uninitialized.
   *

 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation

 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke

 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
   *

 * [.hljs-theme-light.nopadding]

 * ```

   ```

 * /// @custom:oz-upgrades-unsafe-allow constructor

 * constructor() {

 * _disableInitializers();

 * }

 * ```

   ```

 * ====
   */
   abstract contract Initializable {
   /**

    * @dev Indicates that the contract has been initialized.
    * @custom:oz-retyped-from bool
      */
      uint8 private _initialized;

   /**

    * @dev Indicates that the contract is in the process of being initialized.
      */
      bool private _initializing;

   /**

    * @dev Triggered when the contract has been initialized or reinitialized.
      */
      event Initialized(uint8 version);

   /**

    * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
    * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
      */
      modifier initializer() {
      bool isTopLevelCall = !_initializing;
      require(
          (isTopLevelCall && _initialized < 1) ||
              (!Address.isContract(address(this)) && _initialized == 1),
          "Initializable: contract is already initialized"
      );
      _initialized = 1;
      if (isTopLevelCall) {
          _initializing = true;
      }
      _;
      if (isTopLevelCall) {
          _initializing = false;
          emit Initialized(1);
      }
      }

   /**

    * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
    * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
    * used to initialize parent contracts.
      *
    * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
    * initialization step. This is essential to configure modules that are added through upgrades and that require
    * initialization.
      *
    * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
    * a contract, executing them in the right order is up to the developer or operator.
      */
      modifier reinitializer(uint8 version) {
      require(
          !_initializing && _initialized < version,
          "Initializable: contract is already initialized"
      );
      _initialized = version;
      _initializing = true;
      _;
      _initializing = false;
      emit Initialized(version);
      }

   /**

    * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
    * {initializer} and {reinitializer} modifiers, directly or indirectly.
      */
      modifier onlyInitializing() {
      require(_initializing, "Initializable: contract is not initializing");
      _;
      }

   /**

    * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
    * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
    * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
    * through proxies.
      */
      function _disableInitializers() internal virtual {
      require(!_initializing, "Initializable: contract is initializing");
      if (_initialized < type(uint8).max) {
          _initialized = type(uint8).max;
          emit Initialized(type(uint8).max);
      }
      }
      }

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
/**

 * @dev Contract module which provides a basic access control mechanism, where

 * there is an account (an owner) that can be granted exclusive access to

 * specific functions.
   *

 * By default, the owner account will be the one that deploys the contract. This

 * can later be changed with {transferOwnership}.
   *

 * This module is used through inheritance. It will make available the modifier

 * `onlyOwner`, which can be applied to your functions to restrict their use to

 * the owner.
   */
   abstract contract Ownable is Context {
   address private _owner;

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

   /**

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

   /**

    * @dev Throws if called by any account other than the owner.
      */
      modifier onlyOwner() {
      _checkOwner();
      _;
      }

   /**

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

   /**

    * @dev Throws if the sender is not the owner.
      */
      function _checkOwner() internal view virtual {
      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 {
      _transferOwnership(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"
      );
      _transferOwnership(newOwner);
      }

   /**

    * @dev Transfers ownership of the contract to a new account (`newOwner`).
    * Internal function without access restriction.
      */
      function _transferOwnership(address newOwner) internal virtual {
      address oldOwner = _owner;
      _owner = newOwner;
      emit OwnershipTransferred(oldOwner, newOwner);
      }
      }

contract Migrate is Pausable, Initializable, ReentrancyGuard, Ownable {
    using EnumerableSet for EnumerableSet.AddressSet;
    bool public burnAllFirstConfirmed;
    bool public burnAllSecondConfirmed;
    mapping(address => uint256) public balance;
    mapping(address => bool) public isClaimed;
    EnumerableSet.AddressSet _accounts;

    event LogClaim(address indexed account, uint256 balance);
    event LogBurnAll(uint256 balance);
    event LogAddAccount(address indexed account, uint256 balance);

    receive() external payable {}

    function initialize(
        address _owner,
        address[] memory _addrs,
        uint256[] memory _bals
    ) public initializer {
        _transferOwnership(_owner);
        burnAllFirstConfirmed = false;
        burnAllSecondConfirmed = false;
        _addAccountsBatch(_addrs, _bals);
    }

    function accountsLength() public view returns (uint256) {
        return _accounts.length();
    }

    function isAccountExist(address _addr) public view returns (bool) {
        return _accounts.contains(_addr);
    }

    function accounts(uint256 page, uint256 size)
        public
        view
        returns (address[] memory)
    {
        require(page > 0 && size > 0, "Migrate: Requests param error");
        uint256 start = (page - 1) * size;
        if (_accounts.length() < start) {
            size = 0;
        } else {
            uint256 length = _accounts.length() - start;
            if (length < size) {
                size = length;
            }
        }
        address[] memory addrs = new address[](size);
        for (uint256 i = 0; i < size; i++) {
            addrs[i] = _accounts.at(i + start);
        }
        return addrs;
    }

    function canClaim(address _addr) public view returns (uint256) {
        uint256 _balance = balance[_addr];
        if (isClaimed[_addr] || _balance == 0 || !_accounts.contains(_addr)) {
            return 0;
        } else {
            return _balance;
        }
    }

    function addAccount(address _addr, uint256 _bal)
        public
        onlyOwner
        nonReentrant
    {
        require(!isClaimed[_addr], "Migrate: already claim");
        require(!_accounts.contains(_addr), "Migrate: error account");
        _accounts.add(_addr);
        balance[_addr] = _bal;

        emit LogAddAccount(_addr, _bal);
    }

    function _addAccountsBatch(address[] memory _addrs, uint256[] memory _bals)
        internal
    {
        require(
            _addrs.length == _bals.length,
            "Migrate: length of addrs is not equal bals"
        );
        for (uint256 i = 0; i < _addrs.length; i++) {
            (address _addr, uint256 _bal) = (_addrs[i], _bals[i]);
            if (isClaimed[_addr] || _accounts.contains(_addr)) {
                continue;
            }
            _accounts.add(_addr);
            balance[_addr] = _bal;
            emit LogAddAccount(_addr, _bal);
        }
    }

    function addAccountsBatch(address[] memory _addrs, uint256[] memory _bals)
        public
        onlyOwner
        nonReentrant
    {
        _addAccountsBatch(_addrs, _bals);
    }

    function claim() public whenNotPaused nonReentrant {
        address _addr = msg.sender;
        uint256 _balance = balance[_addr];
        if (isClaimed[_addr] || _balance == 0 || !_accounts.contains(_addr))
            return;

        isClaimed[_addr] = true;
        _accounts.remove(_addr);
        payable(_addr).transfer(_balance);

        emit LogClaim(_addr, _balance);
    }

    function burnAll() public onlyOwner {
        if (!burnAllFirstConfirmed) {
            burnAllFirstConfirmed = true;
        } else {
            uint256 bal = address(this).balance;
            payable(address(0)).transfer(bal);
            burnAllSecondConfirmed = true;

            emit LogBurnAll(bal);
        }
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

}