#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

struct Frac{
    long long num;
    long long den;
    Frac(long long num, long long den): num(num), den(den) {}
};

bool operator >=(const Frac& first, const Frac& second) {
    return first.num * second.den >= second.num * first.den;
}

bool operator <(const Frac& first, const Frac& second) {
    return first.num * second.den < second.num * first.den;
}


void solve() {
    int n, v;
    cin >> n >> v;
    vector<pair<long long, long long>> right;
    vector<pair<long long, long long>> left;
    for (int i = 0; i < n; ++i) {
        long long p, vi;
        cin >> p >> vi;
        if (p > 0)
            right.emplace_back(p, vi);
        else
            left.emplace_back(-p, vi);
    }
    auto transform = [](vector<pair<long long, long long>>& cops) {
        sort(cops.begin(), cops.end(), [](const pair<long long, long long>& a, const pair<long long, long long>& b) {
            if (a.second == b.second) {
                return a.first < b.first;
            }
            return a.second < b.second;
        });
        vector<Frac> events;
        vector<pair<long long, long long>> stack;
        for (auto [p, v] : cops) {
            // same speed but closer
            if (!stack.empty() && stack.back().second == v)
                continue;
            while (!stack.empty() && (events.back() >= Frac(p - stack.back().first, v - stack.back().second))) {
                stack.pop_back();
                events.pop_back();
            }
            if (stack.empty()) {
                stack.emplace_back(p, v);
                events.emplace_back(Frac(0, 1));
            } else {
                events.emplace_back(Frac(p - stack.back().first, v - stack.back().second));
                stack.emplace_back(p, v);
            }
        }
        swap(stack, cops);
        return events;
    };
    auto events_right = transform(right);
    auto events_left = transform(left);
    int i = 0;
    int j = 0;
    Frac ans(3e12, 1);
    while (i + 1 < left.size() || j + 1 < right.size()) {
        ans = min(ans, Frac(left[i].first + right[j].first, left[i].second + right[j].second));
        if (i + 1 < left.size() && (j + 1 == right.size() || events_left[i] < events_right[j])) {
            ++i;
        } else {
            ++j;
        }
    }
    ans = min(ans, Frac(left[i].first + right[j].first, left[i].second + right[j].second));
    long double kek = ans.num * v;
    long double lol = ans.den;
    cout << fixed << setprecision(10) << kek / lol << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}