creation_sourcecode: pragma solidity ^0.8.3;
  
  
  interface IERC20Upgradeable {
      
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      
      event Approval(address indexed owner, address indexed spender, uint256 value);
  
      
      function totalSupply() external view returns (uint256);
  
      
      function balanceOf(address account) external view returns (uint256);
  
      
      function transfer(address to, uint256 amount) external returns (bool);
  
      
      function allowance(address owner, address spender) external view returns (uint256);
  
      
      function approve(address spender, uint256 amount) external returns (bool);
  
      
      function transferFrom(
          address from,
          address to,
          uint256 amount
      ) external returns (bool);
  }
  
  library AddressUpgradeable {
      
      function isContract(address account) internal view returns (bool) {
          
          
          
  
          return account.code.length > 0;
      }
  
      
      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");
      }
  
      
      function functionCall(address target, bytes memory data) internal returns (bytes memory) {
          return functionCallWithValue(target, data, 0, "Address: low-level call failed");
      }
  
      
      function functionCall(
          address target,
          bytes memory data,
          string memory errorMessage
      ) internal returns (bytes memory) {
          return functionCallWithValue(target, data, 0, errorMessage);
      }
  
      
      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");
      }
  
      
      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");
          (bool success, bytes memory returndata) = target.call{value: value}(data);
          return verifyCallResultFromTarget(target, success, returndata, errorMessage);
      }
  
      
      function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
          return functionStaticCall(target, data, "Address: low-level static call failed");
      }
  
      
      function functionStaticCall(
          address target,
          bytes memory data,
          string memory errorMessage
      ) internal view returns (bytes memory) {
          (bool success, bytes memory returndata) = target.staticcall(data);
          return verifyCallResultFromTarget(target, success, returndata, errorMessage);
      }
  
      
      function verifyCallResultFromTarget(
          address target,
          bool success,
          bytes memory returndata,
          string memory errorMessage
      ) internal view returns (bytes memory) {
          if (success) {
              if (returndata.length == 0) {
                  
                  
                  require(isContract(target), "Address: call to non-contract");
              }
              return returndata;
          } else {
              _revert(returndata, errorMessage);
          }
      }
  
      
      function verifyCallResult(
          bool success,
          bytes memory returndata,
          string memory errorMessage
      ) internal pure returns (bytes memory) {
          if (success) {
              return returndata;
          } else {
              _revert(returndata, errorMessage);
          }
      }
  
      function _revert(bytes memory returndata, string memory errorMessage) private pure {
          
          if (returndata.length > 0) {
              
              
              assembly {
                  let returndata_size := mload(returndata)
                  revert(add(32, returndata), returndata_size)
              }
          } else {
              revert(errorMessage);
          }
      }
  }
  
  abstract contract Initializable {
      
      uint8 private _initialized;
  
      
      bool private _initializing;
  
      
      event Initialized(uint8 version);
  
      
      modifier initializer() {
          bool isTopLevelCall = !_initializing;
          require(
              (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
              "Initializable: contract is already initialized"
          );
          _initialized = 1;
          if (isTopLevelCall) {
              _initializing = true;
          }
          _;
          if (isTopLevelCall) {
              _initializing = false;
              emit Initialized(1);
          }
      }
  
      
      modifier reinitializer(uint8 version) {
          require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
          _initialized = version;
          _initializing = true;
          _;
          _initializing = false;
          emit Initialized(version);
      }
  
      
      modifier onlyInitializing() {
          require(_initializing, "Initializable: contract is not initializing");
          _;
      }
  
      
      function _disableInitializers() internal virtual {
          require(!_initializing, "Initializable: contract is initializing");
          if (_initialized < type(uint8).max) {
              _initialized = type(uint8).max;
              emit Initialized(type(uint8).max);
          }
      }
  
      
      function _getInitializedVersion() internal view returns (uint8) {
          return _initialized;
      }
  
      
      function _isInitializing() internal view returns (bool) {
          return _initializing;
      }
  }
  
  abstract contract ContextUpgradeable is Initializable {
      function __Context_init() internal onlyInitializing {
      }
  
      function __Context_init_unchained() internal onlyInitializing {
      }
      function _msgSender() internal view virtual returns (address) {
          return msg.sender;
      }
  
      function _msgData() internal view virtual returns (bytes calldata) {
          return msg.data;
      }
  
      
      uint256[50] private __gap;
  }
  
  contract ERC20Upgradeable is
    Initializable,
    ContextUpgradeable,
    IERC20Upgradeable {
    
    mapping(address => uint256) internal _balances;
  
    mapping(address => mapping(address => uint256)) internal _allowances;
  
    uint256 private _totalSupply;
  
    string private _name;
    string private _symbol;
  
    
    function __ERC20_init(
      string memory name_,
      string memory symbol_
    ) internal initializer {
      __Context_init_unchained();
      __ERC20_init_unchained(name_, symbol_);
    }
  
    function __ERC20_init_unchained(
      string memory name_,
      string memory symbol_
    ) internal initializer {
      _name = name_;
      _symbol = symbol_;
    }
  
    
    function name() public view virtual returns (string memory) {
      return _name;
    }
  
    
    function symbol() public view virtual returns (string memory) {
      return _symbol;
    }
  
    
    function decimals() public view virtual returns (uint8) {
      return 18;
    }
  
    
    function totalSupply() public view virtual override returns (uint256) {
      return _totalSupply;
    }
  
    
    function balanceOf(
      address account
    ) public view virtual override returns (uint256) {
      return _balances[account];
    }
  
    
    function transfer(
      address recipient,
      uint256 amount
    ) public virtual override returns (bool) {
      _transfer(_msgSender(), recipient, amount);
      return true;
    }
  
    
    function allowance(
      address owner,
      address spender
    ) public view virtual override returns (uint256) {
      return _allowances[owner][spender];
    }
  
    
    function approve(
      address spender,
      uint256 amount
    ) public virtual override returns (bool) {
      _approve(_msgSender(), spender, amount);
      return true;
    }
  
    
    function transferFrom(
      address sender,
      address recipient,
      uint256 amount
    ) public virtual override returns (bool) {
      _transfer(sender, recipient, amount);
  
      uint256 currentAllowance = _allowances[sender][_msgSender()];
      require(
        currentAllowance >= amount,
        "ERC20: transfer amount exceeds allowance"
      );
      _approve(sender, _msgSender(), currentAllowance - amount);
  
      return true;
    }
  
    
    function increaseAllowance(
      address spender,
      uint256 addedValue
    ) public virtual returns (bool) {
      _approve(
        _msgSender(),
        spender,
        _allowances[_msgSender()][spender] + addedValue
      );
      return true;
    }
  
    
    function decreaseAllowance(
      address spender,
      uint256 subtractedValue
    ) public virtual returns (bool) {
      uint256 currentAllowance = _allowances[_msgSender()][spender];
      require(
        currentAllowance >= subtractedValue,
        "ERC20: decreased allowance below zero"
      );
      _approve(_msgSender(), spender, currentAllowance - subtractedValue);
  
      return true;
    }
  
    
    function _transfer(
      address sender,
      address recipient,
      uint256 amount
    ) internal virtual {
      require(sender != address(0), "ERC20: transfer from the zero address");
      require(recipient != address(0), "ERC20: transfer to the zero address");
  
      _beforeTokenTransfer(sender, recipient, amount);
  
      uint256 senderBalance = _balances[sender];
      require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
      _balances[sender] = senderBalance - amount;
      _balances[recipient] += amount;
  
      emit Transfer(sender, recipient, amount);
    }
  
    
    function _mint(address account, uint256 amount) internal virtual {
      require(account != address(0), "ERC20: mint to the zero address");
  
      _beforeTokenTransfer(address(0), account, amount);
  
      _totalSupply += amount;
      _balances[account] += amount;
      emit Transfer(address(0), account, amount);
    }
  
    
    function _burn(address account, uint256 amount) internal virtual {
      require(account != address(0), "ERC20: burn from the zero address");
  
      _beforeTokenTransfer(account, address(0), amount);
  
      uint256 accountBalance = _balances[account];
      require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
      _balances[account] = accountBalance - amount;
      _totalSupply -= amount;
  
      emit Transfer(account, address(0), amount);
    }
  
    
    function _approve(
      address owner,
      address spender,
      uint256 amount
    ) internal virtual {
      require(owner != address(0), "ERC20: approve from the zero address");
      require(spender != address(0), "ERC20: approve to the zero address");
  
      _allowances[owner][spender] = amount;
      emit Approval(owner, spender, amount);
    }
  
    
    function _beforeTokenTransfer(
      address from,
      address to,
      uint256 amount
    ) internal virtual {}
  
    uint256[45] private __gap;
  }
  
  library StorageSlotUpgradeable {
      struct AddressSlot {
          address value;
      }
  
      struct BooleanSlot {
          bool value;
      }
  
      struct Bytes32Slot {
          bytes32 value;
      }
  
      struct Uint256Slot {
          uint256 value;
      }
  
      
      function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
          
          assembly {
              r.slot := slot
          }
      }
  
      
      function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
          
          assembly {
              r.slot := slot
          }
      }
  
      
      function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
          
          assembly {
              r.slot := slot
          }
      }
  
      
      function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
          
          assembly {
              r.slot := slot
          }
      }
  }
  
  library MathUpgradeable {
      enum Rounding {
          Down, 
          Up, 
          Zero 
      }
  
      
      function max(uint256 a, uint256 b) internal pure returns (uint256) {
          return a > b ? a : b;
      }
  
      
      function min(uint256 a, uint256 b) internal pure returns (uint256) {
          return a < b ? a : b;
      }
  
      
      function average(uint256 a, uint256 b) internal pure returns (uint256) {
          
          return (a & b) + (a ^ b) / 2;
      }
  
      
      function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
          
          return a == 0 ? 0 : (a - 1) / b + 1;
      }
  
      
      function mulDiv(
          uint256 x,
          uint256 y,
          uint256 denominator
      ) internal pure returns (uint256 result) {
          unchecked {
              
              
              
              uint256 prod0; 
              uint256 prod1; 
              assembly {
                  let mm := mulmod(x, y, not(0))
                  prod0 := mul(x, y)
                  prod1 := sub(sub(mm, prod0), lt(mm, prod0))
              }
  
              
              if (prod1 == 0) {
                  return prod0 / denominator;
              }
  
              
              require(denominator > prod1);
  
              
              
              
  
              
              uint256 remainder;
              assembly {
                  
                  remainder := mulmod(x, y, denominator)
  
                  
                  prod1 := sub(prod1, gt(remainder, prod0))
                  prod0 := sub(prod0, remainder)
              }
  
              
              
  
              
              uint256 twos = denominator & (~denominator + 1);
              assembly {
                  
                  denominator := div(denominator, twos)
  
                  
                  prod0 := div(prod0, twos)
  
                  
                  twos := add(div(sub(0, twos), twos), 1)
              }
  
              
              prod0 |= prod1 * twos;
  
              
              
              
              uint256 inverse = (3 * denominator) ^ 2;
  
              
              
              inverse *= 2 - denominator * inverse; 
              inverse *= 2 - denominator * inverse; 
              inverse *= 2 - denominator * inverse; 
              inverse *= 2 - denominator * inverse; 
              inverse *= 2 - denominator * inverse; 
              inverse *= 2 - denominator * inverse; 
  
              
              
              
              
              result = prod0 * inverse;
              return result;
          }
      }
  
      
      function mulDiv(
          uint256 x,
          uint256 y,
          uint256 denominator,
          Rounding rounding
      ) internal pure returns (uint256) {
          uint256 result = mulDiv(x, y, denominator);
          if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
              result += 1;
          }
          return result;
      }
  
      
      function sqrt(uint256 a) internal pure returns (uint256) {
          if (a == 0) {
              return 0;
          }
  
          
          
          
          
          
          
          
          
          
          
          uint256 result = 1 << (log2(a) >> 1);
  
          
          
          
          
          unchecked {
              result = (result + a / result) >> 1;
              result = (result + a / result) >> 1;
              result = (result + a / result) >> 1;
              result = (result + a / result) >> 1;
              result = (result + a / result) >> 1;
              result = (result + a / result) >> 1;
              result = (result + a / result) >> 1;
              return min(result, a / result);
          }
      }
  
      
      function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
          unchecked {
              uint256 result = sqrt(a);
              return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
          }
      }
  
      
      function log2(uint256 value) internal pure returns (uint256) {
          uint256 result = 0;
          unchecked {
              if (value >> 128 > 0) {
                  value >>= 128;
                  result += 128;
              }
              if (value >> 64 > 0) {
                  value >>= 64;
                  result += 64;
              }
              if (value >> 32 > 0) {
                  value >>= 32;
                  result += 32;
              }
              if (value >> 16 > 0) {
                  value >>= 16;
                  result += 16;
              }
              if (value >> 8 > 0) {
                  value >>= 8;
                  result += 8;
              }
              if (value >> 4 > 0) {
                  value >>= 4;
                  result += 4;
              }
              if (value >> 2 > 0) {
                  value >>= 2;
                  result += 2;
              }
              if (value >> 1 > 0) {
                  result += 1;
              }
          }
          return result;
      }
  
      
      function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
          unchecked {
              uint256 result = log2(value);
              return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
          }
      }
  
      
      function log10(uint256 value) internal pure returns (uint256) {
          uint256 result = 0;
          unchecked {
              if (value >= 10**64) {
                  value /= 10**64;
                  result += 64;
              }
              if (value >= 10**32) {
                  value /= 10**32;
                  result += 32;
              }
              if (value >= 10**16) {
                  value /= 10**16;
                  result += 16;
              }
              if (value >= 10**8) {
                  value /= 10**8;
                  result += 8;
              }
              if (value >= 10**4) {
                  value /= 10**4;
                  result += 4;
              }
              if (value >= 10**2) {
                  value /= 10**2;
                  result += 2;
              }
              if (value >= 10**1) {
                  result += 1;
              }
          }
          return result;
      }
  
      
      function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
          unchecked {
              uint256 result = log10(value);
              return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
          }
      }
  
      
      function log256(uint256 value) internal pure returns (uint256) {
          uint256 result = 0;
          unchecked {
              if (value >> 128 > 0) {
                  value >>= 128;
                  result += 16;
              }
              if (value >> 64 > 0) {
                  value >>= 64;
                  result += 8;
              }
              if (value >> 32 > 0) {
                  value >>= 32;
                  result += 4;
              }
              if (value >> 16 > 0) {
                  value >>= 16;
                  result += 2;
              }
              if (value >> 8 > 0) {
                  result += 1;
              }
          }
          return result;
      }
  
      
      function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
          unchecked {
              uint256 result = log256(value);
              return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
          }
      }
  }
  
  library ArraysUpgradeable {
      using StorageSlotUpgradeable for bytes32;
  
      
      function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
          if (array.length == 0) {
              return 0;
          }
  
          uint256 low = 0;
          uint256 high = array.length;
  
          while (low < high) {
              uint256 mid = MathUpgradeable.average(low, high);
  
              
              
              if (unsafeAccess(array, mid).value > element) {
                  high = mid;
              } else {
                  low = mid + 1;
              }
          }
  
          
          if (low > 0 && unsafeAccess(array, low - 1).value == element) {
              return low - 1;
          } else {
              return low;
          }
      }
  
      
      function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlotUpgradeable.AddressSlot storage) {
          bytes32 slot;
          
          assembly {
              mstore(0, arr.slot)
              slot := add(keccak256(0, 0x20), pos)
          }
          return slot.getAddressSlot();
      }
  
      
      function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlotUpgradeable.Bytes32Slot storage) {
          bytes32 slot;
          
          assembly {
              mstore(0, arr.slot)
              slot := add(keccak256(0, 0x20), pos)
          }
          return slot.getBytes32Slot();
      }
  
      
      function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlotUpgradeable.Uint256Slot storage) {
          bytes32 slot;
          
          assembly {
              mstore(0, arr.slot)
              slot := add(keccak256(0, 0x20), pos)
          }
          return slot.getUint256Slot();
      }
  }
  
  library CountersUpgradeable {
      struct Counter {
          
          
          
          uint256 _value; 
      }
  
      function current(Counter storage counter) internal view returns (uint256) {
          return counter._value;
      }
  
      function increment(Counter storage counter) internal {
          unchecked {
              counter._value += 1;
          }
      }
  
      function decrement(Counter storage counter) internal {
          uint256 value = counter._value;
          require(value > 0, "Counter: decrement overflow");
          unchecked {
              counter._value = value - 1;
          }
      }
  
      function reset(Counter storage counter) internal {
          counter._value = 0;
      }
  }
  
  abstract contract ERC20SnapshotUpgradeable is Initializable, ERC20Upgradeable {
    function __ERC20Snapshot_init() internal initializer {
      __Context_init_unchained();
      __ERC20Snapshot_init_unchained();
    }
  
    function __ERC20Snapshot_init_unchained() internal initializer {}
  
    
    
  
    using ArraysUpgradeable for uint256[];
    using CountersUpgradeable for CountersUpgradeable.Counter;
  
    
    
    struct Snapshots {
      uint256[] ids;
      uint256[] values;
    }
  
    mapping(address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;
  
    
    CountersUpgradeable.Counter private _currentSnapshotId;
  
    
    event Snapshot(uint256 id);
  
    
    function _snapshot() internal virtual returns (uint256) {
      _currentSnapshotId.increment();
  
      uint256 currentId = _currentSnapshotId.current();
      emit Snapshot(currentId);
      return currentId;
    }
  
    
    function balanceOfAt(
      address account,
      uint256 snapshotId
    ) public view virtual returns (uint256) {
      (bool snapshotted, uint256 value) = _valueAt(
        snapshotId,
        _accountBalanceSnapshots[account]
      );
  
      return snapshotted ? value : balanceOf(account);
    }
  
    
    function totalSupplyAt(
      uint256 snapshotId
    ) public view virtual returns (uint256) {
      (bool snapshotted, uint256 value) = _valueAt(
        snapshotId,
        _totalSupplySnapshots
      );
  
      return snapshotted ? value : totalSupply();
    }
  
    
    
    function _beforeTokenTransfer(
      address from,
      address to,
      uint256 amount
    ) internal virtual override {
      super._beforeTokenTransfer(from, to, amount);
  
      if (from == address(0)) {
        
        _updateAccountSnapshot(to);
        _updateTotalSupplySnapshot();
      } else if (to == address(0)) {
        
        _updateAccountSnapshot(from);
        _updateTotalSupplySnapshot();
      } else {
        
        _updateAccountSnapshot(from);
        _updateAccountSnapshot(to);
      }
    }
  
    function _valueAt(
      uint256 snapshotId,
      Snapshots storage snapshots
    ) private view returns (bool, uint256) {
      require(snapshotId > 0, "ERC20Snapshot: id is 0");
      
      require(
        snapshotId <= _currentSnapshotId.current(),
        "ERC20Snapshot: nonexistent id"
      );
  
      
      
      
      
      
      
      
      
      
      
      
      
      
  
      uint256 index = snapshots.ids.findUpperBound(snapshotId);
  
      if (index == snapshots.ids.length) {
        return (false, 0);
      } else {
        return (true, snapshots.values[index]);
      }
    }
  
    function _updateAccountSnapshot(address account) internal {
      _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }
  
    function _updateTotalSupplySnapshot() internal {
      _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }
  
    function _updateSnapshot(
      Snapshots storage snapshots,
      uint256 currentValue
    ) private {
      uint256 currentId = _currentSnapshotId.current();
      if (_lastSnapshotId(snapshots.ids) < currentId) {
        snapshots.ids.push(currentId);
        snapshots.values.push(currentValue);
      }
    }
  
    function _lastSnapshotId(
      uint256[] storage ids
    ) private view returns (uint256) {
      if (ids.length == 0) {
        return 0;
      } else {
        return ids[ids.length - 1];
      }
    }
  
    uint256[46] private __gap;
  }
  
  abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
      
      event Paused(address account);
  
      
      event Unpaused(address account);
  
      bool private _paused;
  
      
      function __Pausable_init() internal onlyInitializing {
          __Pausable_init_unchained();
      }
  
      function __Pausable_init_unchained() internal onlyInitializing {
          _paused = false;
      }
  
      
      modifier whenNotPaused() {
          _requireNotPaused();
          _;
      }
  
      
      modifier whenPaused() {
          _requirePaused();
          _;
      }
  
      
      function paused() public view virtual returns (bool) {
          return _paused;
      }
  
      
      function _requireNotPaused() internal view virtual {
          require(!paused(), "Pausable: paused");
      }
  
      
      function _requirePaused() internal view virtual {
          require(paused(), "Pausable: not paused");
      }
  
      
      function _pause() internal virtual whenNotPaused {
          _paused = true;
          emit Paused(_msgSender());
      }
  
      
      function _unpause() internal virtual whenPaused {
          _paused = false;
          emit Unpaused(_msgSender());
      }
  
      
      uint256[49] private __gap;
  }
  
  abstract contract ERC20PausableUpgradeable is
    Initializable,
    ERC20Upgradeable,
    PausableUpgradeable {
    function __ERC20Pausable_init() internal initializer {
      __Context_init_unchained();
      __Pausable_init_unchained();
      __ERC20Pausable_init_unchained();
    }
  
    function __ERC20Pausable_init_unchained() internal initializer {}
  
    
    function _beforeTokenTransfer(
      address from,
      address to,
      uint256 amount
    ) internal virtual override {
      super._beforeTokenTransfer(from, to, amount);
  
      require(!paused(), "ERC20Pausable: token transfer while paused");
    }
  
    uint256[50] private __gap;
  }
  
  abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
      address private _owner;
  
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  
      
      function __Ownable_init() internal onlyInitializing {
          __Ownable_init_unchained();
      }
  
      function __Ownable_init_unchained() internal onlyInitializing {
          _transferOwnership(_msgSender());
      }
  
      
      modifier onlyOwner() {
          _checkOwner();
          _;
      }
  
      
      function owner() public view virtual returns (address) {
          return _owner;
      }
  
      
      function _checkOwner() internal view virtual {
          require(owner() == _msgSender(), "Ownable: caller is not the owner");
      }
  
      
      function renounceOwnership() public virtual onlyOwner {
          _transferOwnership(address(0));
      }
  
      
      function transferOwnership(address newOwner) public virtual onlyOwner {
          require(newOwner != address(0), "Ownable: new owner is the zero address");
          _transferOwnership(newOwner);
      }
  
      
      function _transferOwnership(address newOwner) internal virtual {
          address oldOwner = _owner;
          _owner = newOwner;
          emit OwnershipTransferred(oldOwner, newOwner);
      }
  
      
      uint256[49] private __gap;
  }
  
  library console {
  	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
  
  	function _sendLogPayload(bytes memory payload) private view {
  		uint256 payloadLength = payload.length;
  		address consoleAddress = CONSOLE_ADDRESS;
  		assembly {
  			let payloadStart := add(payload, 32)
  			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
  		}
  	}
  
  	function log() internal view {
  		_sendLogPayload(abi.encodeWithSignature("log()"));
  	}
  
  	function logInt(int256 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
  	}
  
  	function logUint(uint256 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
  	}
  
  	function logString(string memory p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
  	}
  
  	function logBool(bool p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
  	}
  
  	function logAddress(address p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
  	}
  
  	function logBytes(bytes memory p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
  	}
  
  	function logBytes1(bytes1 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
  	}
  
  	function logBytes2(bytes2 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
  	}
  
  	function logBytes3(bytes3 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
  	}
  
  	function logBytes4(bytes4 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
  	}
  
  	function logBytes5(bytes5 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
  	}
  
  	function logBytes6(bytes6 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
  	}
  
  	function logBytes7(bytes7 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
  	}
  
  	function logBytes8(bytes8 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
  	}
  
  	function logBytes9(bytes9 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
  	}
  
  	function logBytes10(bytes10 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
  	}
  
  	function logBytes11(bytes11 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
  	}
  
  	function logBytes12(bytes12 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
  	}
  
  	function logBytes13(bytes13 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
  	}
  
  	function logBytes14(bytes14 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
  	}
  
  	function logBytes15(bytes15 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
  	}
  
  	function logBytes16(bytes16 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
  	}
  
  	function logBytes17(bytes17 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
  	}
  
  	function logBytes18(bytes18 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
  	}
  
  	function logBytes19(bytes19 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
  	}
  
  	function logBytes20(bytes20 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
  	}
  
  	function logBytes21(bytes21 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
  	}
  
  	function logBytes22(bytes22 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
  	}
  
  	function logBytes23(bytes23 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
  	}
  
  	function logBytes24(bytes24 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
  	}
  
  	function logBytes25(bytes25 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
  	}
  
  	function logBytes26(bytes26 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
  	}
  
  	function logBytes27(bytes27 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
  	}
  
  	function logBytes28(bytes28 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
  	}
  
  	function logBytes29(bytes29 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
  	}
  
  	function logBytes30(bytes30 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
  	}
  
  	function logBytes31(bytes31 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
  	}
  
  	function logBytes32(bytes32 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
  	}
  
  	function log(uint256 p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
  	}
  
  	function log(string memory p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
  	}
  
  	function log(bool p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
  	}
  
  	function log(address p0) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
  	}
  
  	function log(uint256 p0, uint256 p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
  	}
  
  	function log(uint256 p0, string memory p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
  	}
  
  	function log(uint256 p0, bool p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
  	}
  
  	function log(uint256 p0, address p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
  	}
  
  	function log(string memory p0, uint256 p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
  	}
  
  	function log(string memory p0, string memory p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
  	}
  
  	function log(string memory p0, bool p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
  	}
  
  	function log(string memory p0, address p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
  	}
  
  	function log(bool p0, uint256 p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
  	}
  
  	function log(bool p0, string memory p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
  	}
  
  	function log(bool p0, bool p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
  	}
  
  	function log(bool p0, address p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
  	}
  
  	function log(address p0, uint256 p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
  	}
  
  	function log(address p0, string memory p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
  	}
  
  	function log(address p0, bool p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
  	}
  
  	function log(address p0, address p1) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
  	}
  
  	function log(uint256 p0, uint256 p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, uint256 p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, uint256 p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, uint256 p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, string memory p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, string memory p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, string memory p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, string memory p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, bool p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, bool p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, bool p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, bool p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, address p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, address p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, address p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, address p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
  	}
  
  	function log(string memory p0, uint256 p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
  	}
  
  	function log(string memory p0, uint256 p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
  	}
  
  	function log(string memory p0, uint256 p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
  	}
  
  	function log(string memory p0, uint256 p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
  	}
  
  	function log(string memory p0, string memory p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
  	}
  
  	function log(string memory p0, string memory p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
  	}
  
  	function log(string memory p0, string memory p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
  	}
  
  	function log(string memory p0, string memory p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
  	}
  
  	function log(string memory p0, bool p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
  	}
  
  	function log(string memory p0, bool p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
  	}
  
  	function log(string memory p0, bool p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
  	}
  
  	function log(string memory p0, bool p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
  	}
  
  	function log(string memory p0, address p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
  	}
  
  	function log(string memory p0, address p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
  	}
  
  	function log(string memory p0, address p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
  	}
  
  	function log(string memory p0, address p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
  	}
  
  	function log(bool p0, uint256 p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
  	}
  
  	function log(bool p0, uint256 p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
  	}
  
  	function log(bool p0, uint256 p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
  	}
  
  	function log(bool p0, uint256 p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
  	}
  
  	function log(bool p0, string memory p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
  	}
  
  	function log(bool p0, string memory p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
  	}
  
  	function log(bool p0, string memory p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
  	}
  
  	function log(bool p0, string memory p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
  	}
  
  	function log(bool p0, bool p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
  	}
  
  	function log(bool p0, bool p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
  	}
  
  	function log(bool p0, bool p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
  	}
  
  	function log(bool p0, bool p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
  	}
  
  	function log(bool p0, address p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
  	}
  
  	function log(bool p0, address p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
  	}
  
  	function log(bool p0, address p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
  	}
  
  	function log(bool p0, address p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
  	}
  
  	function log(address p0, uint256 p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
  	}
  
  	function log(address p0, uint256 p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
  	}
  
  	function log(address p0, uint256 p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
  	}
  
  	function log(address p0, uint256 p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
  	}
  
  	function log(address p0, string memory p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
  	}
  
  	function log(address p0, string memory p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
  	}
  
  	function log(address p0, string memory p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
  	}
  
  	function log(address p0, string memory p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
  	}
  
  	function log(address p0, bool p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
  	}
  
  	function log(address p0, bool p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
  	}
  
  	function log(address p0, bool p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
  	}
  
  	function log(address p0, bool p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
  	}
  
  	function log(address p0, address p1, uint256 p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
  	}
  
  	function log(address p0, address p1, string memory p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
  	}
  
  	function log(address p0, address p1, bool p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
  	}
  
  	function log(address p0, address p1, address p2) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
  	}
  
  	function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, uint256 p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, string memory p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, bool p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(uint256 p0, address p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, uint256 p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, string memory p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, bool p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(string memory p0, address p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, uint256 p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, string memory p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, bool p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(bool p0, address p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, uint256 p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, string memory p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, bool p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, uint256 p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, uint256 p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, uint256 p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, uint256 p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, string memory p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, string memory p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, string memory p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, string memory p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, bool p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, bool p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, bool p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, bool p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, address p2, uint256 p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, address p2, string memory p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, address p2, bool p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
  	}
  
  	function log(address p0, address p1, address p2, address p3) internal view {
  		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
  	}
  
  }
  
  contract DeHubTokenV4WithVersion is
    OwnableUpgradeable,
    ERC20Upgradeable,
    ERC20PausableUpgradeable,
    ERC20SnapshotUpgradeable {
    event AuthorizedSnapshotter(address account);
    event DeauthorizedSnapshotter(address account);
    event BuySellTaxRate(uint256 buyTaxRate, uint256 sellTaxRate);
  
    
    enum TransactionType {
      REGULAR,
      TAX,
      SELL,
      BUY
    }
  
    
    mapping(address => bool) authorizedToSnapshot;
  
    
    
    
    uint256 public buyTaxRate;
    uint256 public sellTaxRate;
  
    
    
    
    
    mapping(address => bool) public poolsToTax;
  
    address public taxTo;
  
    
    uint256 internal accumulatedTax;
  
    uint256 public version;
  
    function initialize(
      string memory name,
      string memory symbol
    ) public initializer {
      __Ownable_init();
      __ERC20_init(name, symbol);
      __ERC20Snapshot_init();
      __ERC20Pausable_init();
    }
  
    
    function initializeImplementation() public initializer {
      __Ownable_init();
      _pause();
    }
  
    
    function mint(address account, uint256 amount) external onlyOwner {
      _mint(account, amount);
    }
  
    
    function burn(address account, uint256 amount) external onlyOwner {
      _burn(account, amount);
    }
  
    
    function pause() external onlyOwner {
      _pause();
    }
  
    
    function unpause() external onlyOwner {
      _unpause();
    }
  
    
    function snapshot() external returns (uint256) {
      require(
        authorizedToSnapshot[_msgSender()] || _msgSender() == owner(),
        "zDAOToken: Not authorized to snapshot"
      );
      return _snapshot();
    }
  
    
    function authorizeSnapshotter(address account) external onlyOwner {
      require(
        !authorizedToSnapshot[account],
        "zDAOToken: Account already authorized"
      );
  
      authorizedToSnapshot[account] = true;
      emit AuthorizedSnapshotter(account);
    }
  
    
    function deauthorizeSnapshotter(address account) external onlyOwner {
      require(authorizedToSnapshot[account], "zDAOToken: Account not authorized");
  
      authorizedToSnapshot[account] = false;
      emit DeauthorizedSnapshotter(account);
    }
  
    
    function transferBulk(
      address[] calldata recipients,
      uint256[] calldata amounts
    ) external onlyOwner returns (bool) {
      require(!paused(), "ERC20Pausable: token transfer while paused");
      require(recipients.length == amounts.length, "Invalid arguments length");
  
      address sender = _msgSender();
  
      uint256 length = recipients.length;
      uint256 total = 0;
      for (uint256 i = 0; i < length; ++i) {
        total += amounts[i];
      }
      require(
        _balances[sender] >= total,
        "ERC20: transfer amount exceeds balance"
      );
  
      _balances[sender] -= total;
      _updateAccountSnapshot(sender);
  
      for (uint256 i = 0; i < length; ++i) {
        address recipient = recipients[i];
        require(recipient != address(0), "ERC20: transfer to the zero address");
  
        
        
  
        _balances[recipient] += amounts[i];
  
        _updateAccountSnapshot(recipient);
  
        emit Transfer(sender, recipient, amounts[i]);
      }
  
      return true;
    }
  
    
    function transferFromBulk(
      address sender,
      address[] calldata recipients,
      uint256[] calldata amounts
    ) external onlyOwner returns (bool) {
      require(!paused(), "ERC20Pausable: token transfer while paused");
      require(recipients.length == amounts.length, "Invalid arguments length");
  
      uint256 length = recipients.length;
      uint256 total = 0;
      for (uint256 i = 0; i < length; ++i) {
        total += amounts[i];
      }
      require(
        _balances[sender] >= total,
        "ERC20: transfer amount exceeds balance"
      );
  
      
      uint256 currentAllowance = _allowances[sender][_msgSender()];
      require(
        currentAllowance >= total,
        "ERC20: transfer total exceeds allowance"
      );
      _approve(sender, _msgSender(), currentAllowance - total);
  
      _balances[sender] -= total;
      _updateAccountSnapshot(sender);
  
      for (uint256 i = 0; i < length; ++i) {
        address recipient = recipients[i];
        require(recipient != address(0), "ERC20: transfer to the zero address");
  
        
        
  
        _balances[recipient] += amounts[i];
  
        _updateAccountSnapshot(recipient);
  
        emit Transfer(sender, recipient, amounts[i]);
      }
  
      return true;
    }
  
    function burnBulk(
      address[] calldata accounts,
      uint256[] calldata amounts
    ) external onlyOwner {
      require(accounts.length == amounts.length, "Invalid argument");
      uint256 len = accounts.length;
      for (uint256 i = 0; i < len; ++i) {
        _burn(accounts[i], amounts[i]);
      }
    }
  
    
    function setBuySellTaxRate(
      uint256 buyTaxRate_,
      uint256 sellTaxRate_
    ) external onlyOwner {
      require(buyTaxRate != buyTaxRate_ && sellTaxRate != sellTaxRate_);
  
      buyTaxRate = buyTaxRate_;
      sellTaxRate = sellTaxRate_;
  
      emit BuySellTaxRate(buyTaxRate_, sellTaxRate_);
    }
  
    
    function setTaxTo(address taxTo_) external onlyOwner {
      require(taxTo != taxTo_);
  
      taxTo = taxTo_;
    }
  
    function addPoolToTax(address pool_) external onlyOwner {
      require(pool_ != address(0));
  
      poolsToTax[pool_] = true;
    }
  
    function removePoolToTax(address pool_) external onlyOwner {
      require(pool_ != address(0));
  
      poolsToTax[pool_] = false;
    }
  
    function _beforeTokenTransfer(
      address from,
      address to,
      uint256 amount
    )
      internal
      virtual
      override(
        ERC20PausableUpgradeable,
        ERC20SnapshotUpgradeable,
        ERC20Upgradeable
      )
    {
      bool alreadyPaused = paused();
      if (to == address(0)) {
        if (alreadyPaused) {
          _unpause();
        }
      }
      super._beforeTokenTransfer(from, to, amount);
      if (to == address(0)) {
        if (alreadyPaused) {
          _pause();
        }
      }
    }
  
    function _transfer(
      address sender,
      address recipient,
      uint256 amount
    ) internal virtual override {
      uint256 taxAmount = _takeFee(sender, recipient, amount);
  
      
      super._transfer(sender, recipient, amount - taxAmount);
  
      
      if (taxAmount > 0) {
        super._transfer(sender, address(this), taxAmount);
        accumulatedTax += taxAmount;
      }
    }
  
    function _takeFee(
      address sender,
      address recipient,
      uint256 amount
    ) internal virtual returns (uint256) {
      
      if (_getTransactionType(sender, recipient) == TransactionType.SELL) {
        
        return (amount * sellTaxRate) / 10000;
      } else if (_getTransactionType(sender, recipient) == TransactionType.BUY) {
        
        return (amount * buyTaxRate) / 10000;
      }
      return 0;
    }
  
    
    function _getTransactionType(
      address from,
      address to
    ) internal view returns (TransactionType) {
      if (poolsToTax[from] && !poolsToTax[to]) {
        
        return TransactionType.BUY;
      } else if (!poolsToTax[from] && poolsToTax[to]) {
        
        return TransactionType.SELL;
      } else if (from == address(this) || to == address(this)) {
        return TransactionType.TAX;
      }
      return TransactionType.REGULAR;
    }
  }
  
  interface IERC20 {
      
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      
      event Approval(address indexed owner, address indexed spender, uint256 value);
  
      
      function totalSupply() external view returns (uint256);
  
      
      function balanceOf(address account) external view returns (uint256);
  
      
      function transfer(address to, uint256 amount) external returns (bool);
  
      
      function allowance(address owner, address spender) external view returns (uint256);
  
      
      function approve(address spender, uint256 amount) external returns (bool);
  
      
      function transferFrom(
          address from,
          address to,
          uint256 amount
      ) external returns (bool);
  }
  
  interface IUniswapV2Factory {
      event PairCreated(address indexed token0, address indexed token1, address pair, uint);
  
      function feeTo() external view returns (address);
      function feeToSetter() external view returns (address);
  
      function getPair(address tokenA, address tokenB) external view returns (address pair);
      function allPairs(uint) external view returns (address pair);
      function allPairsLength() external view returns (uint);
  
      function createPair(address tokenA, address tokenB) external returns (address pair);
  
      function setFeeTo(address) external;
      function setFeeToSetter(address) external;
  }
  
  interface IUniswapV2Router01 {
      function factory() external pure returns (address);
      function WETH() external pure returns (address);
  
      function addLiquidity(
          address tokenA,
          address tokenB,
          uint amountADesired,
          uint amountBDesired,
          uint amountAMin,
          uint amountBMin,
          address to,
          uint deadline
      ) external returns (uint amountA, uint amountB, uint liquidity);
      function addLiquidityETH(
          address token,
          uint amountTokenDesired,
          uint amountTokenMin,
          uint amountETHMin,
          address to,
          uint deadline
      ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
      function removeLiquidity(
          address tokenA,
          address tokenB,
          uint liquidity,
          uint amountAMin,
          uint amountBMin,
          address to,
          uint deadline
      ) external returns (uint amountA, uint amountB);
      function removeLiquidityETH(
          address token,
          uint liquidity,
          uint amountTokenMin,
          uint amountETHMin,
          address to,
          uint deadline
      ) external returns (uint amountToken, uint amountETH);
      function removeLiquidityWithPermit(
          address tokenA,
          address tokenB,
          uint liquidity,
          uint amountAMin,
          uint amountBMin,
          address to,
          uint deadline,
          bool approveMax, uint8 v, bytes32 r, bytes32 s
      ) external returns (uint amountA, uint amountB);
      function removeLiquidityETHWithPermit(
          address token,
          uint liquidity,
          uint amountTokenMin,
          uint amountETHMin,
          address to,
          uint deadline,
          bool approveMax, uint8 v, bytes32 r, bytes32 s
      ) external returns (uint amountToken, uint amountETH);
      function swapExactTokensForTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external returns (uint[] memory amounts);
      function swapTokensForExactTokens(
          uint amountOut,
          uint amountInMax,
          address[] calldata path,
          address to,
          uint deadline
      ) external returns (uint[] memory amounts);
      function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
          external
          payable
          returns (uint[] memory amounts);
      function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
          external
          returns (uint[] memory amounts);
      function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
          external
          returns (uint[] memory amounts);
      function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
          external
          payable
          returns (uint[] memory amounts);
  
      function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
      function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
      function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
      function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
      function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
  }
  
  interface IUniswapV2Router02 is IUniswapV2Router01 {
      function removeLiquidityETHSupportingFeeOnTransferTokens(
          address token,
          uint liquidity,
          uint amountTokenMin,
          uint amountETHMin,
          address to,
          uint deadline
      ) external returns (uint amountETH);
      function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
          address token,
          uint liquidity,
          uint amountTokenMin,
          uint amountETHMin,
          address to,
          uint deadline,
          bool approveMax, uint8 v, bytes32 r, bytes32 s
      ) external returns (uint amountETH);
  
      function swapExactTokensForTokensSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
      function swapExactETHForTokensSupportingFeeOnTransferTokens(
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external payable;
      function swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
  }
  
  library SafeMathUpgradeable {
      
      function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          unchecked {
              uint256 c = a + b;
              if (c < a) return (false, 0);
              return (true, c);
          }
      }
  
      
      function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          unchecked {
              if (b > a) return (false, 0);
              return (true, a - b);
          }
      }
  
      
      function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          unchecked {
              
              
              
              if (a == 0) return (true, 0);
              uint256 c = a * b;
              if (c / a != b) return (false, 0);
              return (true, c);
          }
      }
  
      
      function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          unchecked {
              if (b == 0) return (false, 0);
              return (true, a / b);
          }
      }
  
      
      function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
          unchecked {
              if (b == 0) return (false, 0);
              return (true, a % b);
          }
      }
  
      
      function add(uint256 a, uint256 b) internal pure returns (uint256) {
          return a + b;
      }
  
      
      function sub(uint256 a, uint256 b) internal pure returns (uint256) {
          return a - b;
      }
  
      
      function mul(uint256 a, uint256 b) internal pure returns (uint256) {
          return a * b;
      }
  
      
      function div(uint256 a, uint256 b) internal pure returns (uint256) {
          return a / b;
      }
  
      
      function mod(uint256 a, uint256 b) internal pure returns (uint256) {
          return a % b;
      }
  
      
      function sub(
          uint256 a,
          uint256 b,
          string memory errorMessage
      ) internal pure returns (uint256) {
          unchecked {
              require(b <= a, errorMessage);
              return a - b;
          }
      }
  
      
      function div(
          uint256 a,
          uint256 b,
          string memory errorMessage
      ) internal pure returns (uint256) {
          unchecked {
              require(b > 0, errorMessage);
              return a / b;
          }
      }
  
      
      function mod(
          uint256 a,
          uint256 b,
          string memory errorMessage
      ) internal pure returns (uint256) {
          unchecked {
              require(b > 0, errorMessage);
              return a % b;
          }
      }
  }
  
  abstract contract Uniswap is OwnableUpgradeable {
    using SafeMathUpgradeable for uint256;
    
    IUniswapV2Router02 internal uniswapV2Router;
    
    address internal uniswapV2Pair;
    
    address internal routerAddr;
  
    
    receive() external payable {}
  
    function setRouter(address router, address pair) external onlyOwner {
      require(router != address(0));
      uniswapV2Router = IUniswapV2Router02(router);
      uniswapV2Pair = pair;
      emit RouterSet(router, pair);
    }
  
    
    function swapTokensForETH(uint256 tokenAmount) internal returns (uint256) {
      if (address(uniswapV2Router) != address(0)) {
        uint256 initialBalance = address(this).balance;
        
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
  
        
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
          tokenAmount,
          0, 
          path,
          address(this),
          block.timestamp
        );
  
        uint256 ethReceived = address(this).balance.sub(initialBalance);
        return ethReceived;
      }
      return 0;
    }
  
    function swapTokensByPath(
      uint256 tokenAmountIn,
      uint256 tokenAmountOutMin,
      address[] memory path,
      address to
    ) internal {
      if (address(uniswapV2Router) != address(0)) {
        
        uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
          tokenAmountIn,
          tokenAmountOutMin,
          path,
          to,
          block.timestamp
        );
      }
    }
  
    
    event RouterSet(address indexed router, address indexed pair);
  
    
    modifier pcsInitialized() {
      require(routerAddr != address(0), "Router address has not been set!");
      _;
    }
  }
  
  contract DeHubTokenV5 is DeHubTokenV4WithVersion, Uniswap {
    event SoldTax(uint256 tokensSold, uint256 usdtReceived);
    event SetMinTaxForSell(uint256 minTaxForSell);
  
    
    
    uint256 public minTaxForSell;
  
    address public USDT;
  
    bool internal inTriggerProcess;
    modifier lockTheProcess() {
      inTriggerProcess = true;
      _;
      inTriggerProcess = false;
    }
  
    
    function upgradeToV5() external {
      require(version < 5, "DeHubToken: Already upgraded to version 5");
      version = 5;
      console.log("v", version);
    }
  
    function setUSDT(address USDT_) external onlyOwner {
      USDT = USDT_;
    }
  
    function setMinTaxForSell(uint256 minTaxForSell_) external onlyOwner {
      require(minTaxForSell != minTaxForSell_);
      minTaxForSell = minTaxForSell_;
      emit SetMinTaxForSell(minTaxForSell_);
    }
  
    function _beforeTokenTransfer(
      address from,
      address to,
      uint256 amount
    ) internal virtual override {
      super._beforeTokenTransfer(from, to, amount);
  
      TransactionType txType = _getTransactionType(from, to);
      
      
      if (!inTriggerProcess && txType == TransactionType.REGULAR) {
        _triggerSellTax();
      }
    }
  
    function _takeFee(
      address sender,
      address recipient,
      uint256 amount
    ) internal virtual override returns (uint256) {
      if (inTriggerProcess) {
        return 0;
      }
      return super._takeFee(sender, recipient, amount);
    }
  
    function _canSellTax(
      uint256 contractTokenBalance
    ) internal view virtual returns (bool) {
      return contractTokenBalance >= minTaxForSell && minTaxForSell > 0;
    }
  
    function _triggerSellTax() internal virtual {
      uint256 contractTokenBalance = balanceOf(address(this));
      if (_canSellTax(contractTokenBalance)) {
        _sellTax(contractTokenBalance);
      }
    }
  
    function _sellTax(uint256 tokenAmount) internal virtual lockTheProcess {
      uint256 tokensSold;
      uint256 usdtReceived;
  
      if (taxTo != address(0) && tokenAmount > 0) {
        
        _approve(address(this), address(uniswapV2Router), tokenAmount);
  
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = USDT;
  
        uint256 initialBalance = IERC20(USDT).balanceOf(taxTo);
        swapTokensByPath(tokenAmount, 1, path, taxTo);
        usdtReceived = IERC20(USDT).balanceOf(taxTo) - initialBalance;
        if (usdtReceived > 0) {
          tokensSold = tokenAmount;
        }
      }
      emit SoldTax(tokensSold, usdtReceived);
    }
  }