#include <bits/stdc++.h>
using namespace std;
int gcdExtended(int a, int b, int* x, int* y) {
  if (a == 0) {
    *x = 0, *y = 1;
    return b;
  }
  int x1, y1;
  int gcd = gcdExtended(b % a, a, &x1, &y1);
  *x = y1 - (b / a) * x1;
  *y = x1;
  return gcd;
}
long long int modInverse(int a, int m) {
  int x, y;
  int g = gcdExtended(a, m, &x, &y);
  long long int res = ((long long int)x % m + (long long int)m) % m;
  return res;
}
long long int poww(long long int x, long long int n) {
  if (n == 0)
    return 1;
  else if (n == 1)
    return x;
  else if (n % 2 == 0)
    return poww(x * x, n / 2);
  else
    return x * poww(x * x, (n - 1) / 2);
}
long long int modularExponentiation(long long int x, long long int n,
                                    long long int M) {
  long long int result = 1;
  while (n > 0) {
    if (n % 2 == 1) result = (result * x) % M;
    x = (x * x) % M;
    n = n / 2;
  }
  return result;
}
template <typename T>
T maxx(T a, T b) {
  if (a < b) return b;
  return a;
}
template <typename T, typename... Args>
T maxx(T a, T b, Args... args) {
  return (maxx(maxx(a, b), args...));
}
template <typename T>
T minn(T a, T b) {
  if (a < b) return a;
  return b;
}
template <typename T, typename... Args>
T minn(T a, T b, Args... args) {
  return (minn(minn(a, b), args...));
}
template <typename T>
void read(T& a) {
  cin >> a;
}
template <typename T, typename... Args>
void read(T& a, Args&... args) {
  cin >> a;
  read(args...);
}
template <typename T>
void write(T a) {
  cout << a << ' ';
}
template <typename T, typename... Args>
void write(T a, Args... args) {
  cout << a << ' ';
  write(args...);
}
inline long long int min(long long int a, long long int b) {
  if (a < b)
    return a;
  else
    return b;
}
inline long long int max(long long int a, long long int b) {
  if (a < b)
    return b;
  else
    return a;
}
long long int gcd(long long int a, long long int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  if (a == b) return a;
  if (a > b)
    return gcd(a - b, b);
  else
    return gcd(a, b - a);
}
long long int ncr(int n, int r) {
  long long int ans = 1;
  r = min(r, n - r);
  for (int i = 0; i < r; i++) {
    ans = ((ans * ((n - i) % 1000000007)) % 1000000007 *
           modInverse(i + 1, 1000000007)) %
          1000000007;
  }
  return ans;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  int t = 1;
  cin >> t;
  while (t--) {
    long long int n, m, k;
    cin >> n >> m;
    if (n * 2 <= m) {
      write(n, n * 2);
      cout << '\n';
    } else
      cout << "-1 -1" << '\n';
  }
  return 0;
}

### Prompt

Please formulate a CPP solution to the following problem:

Let LCM(x, y) be the minimum positive integer that is divisible by both x and y. For example, LCM(13, 37) = 481, LCM(9, 6) = 18.

You are given two integers l and r. Find two integers x and y such that l ≤ x < y ≤ r and l ≤ LCM(x, y) ≤ r.

Input

The first line contains one integer t (1 ≤ t ≤ 10000) — the number of test cases.

Each test case is represented by one line containing two integers l and r (1 ≤ l < r ≤ 10^9).

Output

For each test case, print two integers:

  * if it is impossible to find integers x and y meeting the constraints in the statement, print two integers equal to -1; 
  * otherwise, print the values of x and y (if there are multiple valid answers, you may print any of them). 

Example

Input


4
1 1337
13 69
2 4
88 89


Output


6 7
14 21
2 4
-1 -1

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int gcdExtended(int a, int b, int* x, int* y) {
  if (a == 0) {
    *x = 0, *y = 1;
    return b;
  }
  int x1, y1;
  int gcd = gcdExtended(b % a, a, &x1, &y1);
  *x = y1 - (b / a) * x1;
  *y = x1;
  return gcd;
}
long long int modInverse(int a, int m) {
  int x, y;
  int g = gcdExtended(a, m, &x, &y);
  long long int res = ((long long int)x % m + (long long int)m) % m;
  return res;
}
long long int poww(long long int x, long long int n) {
  if (n == 0)
    return 1;
  else if (n == 1)
    return x;
  else if (n % 2 == 0)
    return poww(x * x, n / 2);
  else
    return x * poww(x * x, (n - 1) / 2);
}
long long int modularExponentiation(long long int x, long long int n,
                                    long long int M) {
  long long int result = 1;
  while (n > 0) {
    if (n % 2 == 1) result = (result * x) % M;
    x = (x * x) % M;
    n = n / 2;
  }
  return result;
}
template <typename T>
T maxx(T a, T b) {
  if (a < b) return b;
  return a;
}
template <typename T, typename... Args>
T maxx(T a, T b, Args... args) {
  return (maxx(maxx(a, b), args...));
}
template <typename T>
T minn(T a, T b) {
  if (a < b) return a;
  return b;
}
template <typename T, typename... Args>
T minn(T a, T b, Args... args) {
  return (minn(minn(a, b), args...));
}
template <typename T>
void read(T& a) {
  cin >> a;
}
template <typename T, typename... Args>
void read(T& a, Args&... args) {
  cin >> a;
  read(args...);
}
template <typename T>
void write(T a) {
  cout << a << ' ';
}
template <typename T, typename... Args>
void write(T a, Args... args) {
  cout << a << ' ';
  write(args...);
}
inline long long int min(long long int a, long long int b) {
  if (a < b)
    return a;
  else
    return b;
}
inline long long int max(long long int a, long long int b) {
  if (a < b)
    return b;
  else
    return a;
}
long long int gcd(long long int a, long long int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  if (a == b) return a;
  if (a > b)
    return gcd(a - b, b);
  else
    return gcd(a, b - a);
}
long long int ncr(int n, int r) {
  long long int ans = 1;
  r = min(r, n - r);
  for (int i = 0; i < r; i++) {
    ans = ((ans * ((n - i) % 1000000007)) % 1000000007 *
           modInverse(i + 1, 1000000007)) %
          1000000007;
  }
  return ans;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  int t = 1;
  cin >> t;
  while (t--) {
    long long int n, m, k;
    cin >> n >> m;
    if (n * 2 <= m) {
      write(n, n * 2);
      cout << '\n';
    } else
      cout << "-1 -1" << '\n';
  }
  return 0;
}

```