#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

using lld = int64_t;
using llf = long double;
using P = complex<lld>;

int sgn(lld x) {
  return (x > 0) - (x < 0);
}
lld cross(P a, P b) {
  return imag(conj(a) * b);
}
int ori(P a, P b, P c) {
  return sgn(cross(b - a, c - a));
}

namespace std {
  bool operator<(P a, P b) {
    return make_pair(real(a), imag(a)) < make_pair(real(b), imag(b));
  }
}

vector<P> convex_hull(vector<P> v) {
  sort(all(v));
  if (v[0] == v.back()) return {v[0]};
  int t = 0, s = 1; vector<P> h(v.size() + 1);
  for (int _ = 2; _--; s = t--, reverse(all(v)))
    for (P p : v) {
      while (t > s && ori(p, h[t - 1], h[t - 2]) >= 0) t--;
      h[t++] = p;
    }
  return h.resize(t), h;
}

vector<P> Minkowski(vector<P> A, vector<P> B) {
  const int N = (int)A.size(), M = (int)B.size();
  vector<P> sa(N), sb(M), C(N + M + 1);
  for (int i = 0; i < N; i++) sa[i] = A[(i + 1) % N] - A[i];
  for (int i = 0; i < M; i++) sb[i] = B[(i + 1) % M] - B[i];
  C[0] = A[0] + B[0];
  for (int i = 0, j = 0; i < N || j < M; ) {
    P e = (j >= M || (i < N && cross(sa[i], sb[j]) >= 0))
      ? sa[i++] : sb[j++];
    C[i + j] = e;
  }
  partial_sum(all(C), C.begin());
  C.pop_back();
  return convex_hull(C);
}


llf slope(P z) {
  return imag(z) / llf(real(z));
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int T;
  cin >> T;
  while (T--) {
    int n, v;
    cin >> n >> v;

    vector<P> l, r;
    for (int i = 0; i < n; i++) {
      int64_t p;
      int vi;
      cin >> p >> vi;
      if (p < 0) {
        l.emplace_back(vi, -p);
      } else {
        r.emplace_back(vi, p);
      }
    }

    l = convex_hull(l);
    r = convex_hull(r);

    long double t = 1e18;
    if (l.size() <= 2 || r.size() <= 2) {
      for (auto a : l)
        for (auto b : r) {
          debug(a + b, slope(a + b));
          t = min(t, slope(a + b));
        }
    } else {
      orange(all(l));
      orange(all(r));
      for (auto p : Minkowski(l, r)) {
        debug(p, slope(p));
        t = min(t, slope(p));
      }
    }

    cout << fixed << setprecision(20);
    cout << t * v << '\n';
  }
  return 0;
}