#include <cmath>


#define NDEBUG
NDEBUG


#include <algorithm>
#include <cassert>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <memory>
#include <random>

#define FOR(i, n) for (int i = 0; i < (n); ++i)


using namespace std;

// TC_REMOVE_BEGIN
/// caide keep
bool __hack = std::ios::sync_with_stdio(false);
/// caide keep
auto __hack1 = cin.tie(nullptr);
// TC_REMOVE_END


namespace template_util {
    

    constexpr int bytecount(uint64_t x) {
        return x ? 1 + bytecount(x >> 8) : 0;
    }

    /// caide keep
    template<int N>
    struct bytetype {
        
    };

    /// caide keep
    template<>
    struct bytetype<4> {
        
    };

    /// caide keep
    template<>
    struct bytetype<3> {
        
    };

    /// caide keep
    template<>
    struct bytetype<2> {
        
    };

    /// caide keep
    template<>
    struct bytetype<1> {
        
    };

    /// caide keep
    template<>
    struct bytetype<0> {
        
    };

    /// caide keep
    template<uint64_t N>
    struct minimal_uint : bytetype<bytecount(N)> {
    };
}


template <typename T>
struct BasePoint {
    T x, y;
    BasePoint(T _x, T _y) : x(_x), y(_y) {}

    
};


template <typename T>
struct Point : BasePoint<T> {
    
    
};

template<>
struct Point<double> : BasePoint<double> {
    
    Point(double _x, double _y) : BasePoint<double>(_x, _y) {}
    
    
};


//
//template <typename T>
//inline T area(const Point<T>& A, const Point<T>& B, const Point<T>& C) {
//    return (B.x - A.x) * (C.y - A.y) - (B.y - A.y) * (C.x - A.x);
//}
//
//inline bool intersectHelper(int a, int b, int c, int d) {
//    if (a > b) {
//        swap (a, b);
//    }
//    if (c > d) {
//        swap (c, d);
//    }
//    return max(a,c) <= min(b,d);
//}
//
//bool intersect (pt a, pt b, pt c, pt d) {
//    return intersect_1 (a.x, b.x, c.x, d.x)
//           && intersect_1 (a.y, b.y, c.y, d.y)
//           && area(a,b,c) * area(a,b,d) <= 0
//           && area(c,d,a) * area(c,d,b) <= 0;
//}
//
//bool segmentIntersection(Point<double> A, Point<double> B, Point<double> C, Point<double> D){
//    double t = ((A - C) * (C - D)) / ((A - B) * (C - D));
//    return A + (B - A) * t;
//}
#include <deque>


template<class T>
T next(istream& in) {
    T ret;
    in >> ret;
    return ret;
}


double sum;
int cur_v;
int L;
typedef Point<double> Pnt;
deque<Pnt> q;
void process(double t, int v) {
    Pnt cur(t, v);
    while (q.size() >= 2) {
        auto A = q.back(); q.pop_back();
        auto B = q.back(); q.pop_back();
        if (B.x >= A.x) {
            q.push_back(Pnt((A.x * A.y + B.x * B.y) / (A.y + B.y), A.y + B.y));
        } else {
            q.push_back(B);
            q.push_back(A);
            break;
        }
    }
    q.push_back(cur);
    cur_v += v;
    sum += t * v;
    while (cur_v > L) {
        if (cur_v - q.front().y >= L) {
            cur_v -= q.front().y;
            sum -= q.front().x * q.front().y;
            q.pop_front();
        } else {
            Pnt A = q.front();
            q.pop_front();
            A.y -= (cur_v - L);
            sum -= (cur_v - L) * A.x;
            q.push_front(A);
            cur_v = L;
        }
    }
}

void solve(istream& in, ostream& out) {
    int n = next<int>(in);
    L = next<int>(in);
    cur_v = 0;
    sum = 0;
    FOR(i, n) {
        int t = next<int>(in);
        int x = next<int>(in);
        process(t, x);
        out << setprecision(10) << fixed << sum / L << endl;
    }
}


int main() {
    solve(cin, cout);
    return 0;
}



Measured memory_bytes: 18704