#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iostream>
#include <vector>
using namespace std;

using my_double = long double;

struct point {
    my_double x, y;

    point() : x(0), y(0) {}

    point(my_double _x, my_double _y) : x(_x), y(_y) {}

    point& operator+=(const point &other) { x += other.x; y += other.y; return *this; }
    point& operator-=(const point &other) { x -= other.x; y -= other.y; return *this; }
    point& operator*=(my_double mult) { x *= mult; y *= mult; return *this; }

    point operator+(const point &other) const { return point(*this) += other; }
    point operator-(const point &other) const { return point(*this) -= other; }
    point operator*(my_double mult) const { return point(*this) *= mult; }

    // Warning: does exact floating-point comparisons.
    bool operator==(const point &other) const { return x == other.x && y == other.y; }
    bool operator!=(const point &other) const { return !(*this == other); }

    point operator-() const { return point(-x, -y); }
    point rotate90() const { return point(-y, x); }

    my_double norm() const {
        return x * x + y * y;
    }

    my_double dist() const {
        return sqrt(norm());
    }

    bool top_half() const {
        return make_pair(y, x) > pair<my_double, my_double>(0, 0);
    }

    friend ostream& operator<<(ostream &stream, const point &p) {
        return stream << '(' << p.x << ", " << p.y << ')';
    }
};

my_double cross(const point &a, const point &b) {
    return a.x * b.y - b.x * a.y;
}

my_double dot(const point &a, const point &b) {
    return a.x * b.x + a.y * b.y;
}

bool left_turn_strict(const point &a, const point &b, const point &c) {
    return cross(b - a, c - a) > 0;
}

bool left_turn_lenient(const point &a, const point &b, const point &c) {
    return cross(b - a, c - a) >= 0;
}

// Warning: does a floating-point comparison to exactly 0.
bool collinear(const point &a, const point &b, const point &c) {
    return cross(b - a, c - a) == 0;
}

// Returns the signed, doubled area formed by three points in a triangle. Positive when a -> b -> c is a left turn.
my_double area_signed_doubled(const point &a, const point &b, const point &c) {
    return cross(b - a, c - a);
}

my_double distance_to_line(const point &p, const point &a, const point &b) {
    assert(a != b);
    return abs(area_signed_doubled(p, a, b)) / (a - b).dist();
}

my_double manhattan_dist(const point &a, const point &b) {
    return abs(a.x - b.x) + abs(a.y - b.y);
}

my_double infinity_norm_dist(const point &a, const point &b) {
    return max(abs(a.x - b.x), abs(a.y - b.y));
}

// Sort in increasing order of y, with ties broken in increasing order of x.
bool yx_compare(const point &a, const point &b) {
    return (b - a).top_half();
}

// Sort in increasing order of angle to the x-axis.
bool angle_compare(const point &a, const point &b) {
    if (a.top_half() ^ b.top_half())
        return a.top_half();

    return cross(a, b) > 0;
}


int N;
long long L;

int main() {
    scanf("%d %lld", &N, &L);
    deque<point> poly_line = {point(0, 0)};

    for (int i = 0; i < N; i++) {
        long long T, V;
        scanf("%lld %lld", &T, &V);
        poly_line.push_front(poly_line.front() + point(-V, -T * V));

        while (poly_line[poly_line.size() - 2].x - poly_line.front().x >= L)
            poly_line.pop_back();

        point second_last = poly_line[poly_line.size() - 2];
        point delta = poly_line.back() - second_last;
        my_double portion = poly_line.front().x + L - second_last.x;
        delta *= portion / (poly_line.back().x - second_last.x);
        poly_line.back() = second_last + delta;

        while (poly_line.size() >= 3 && left_turn_lenient(poly_line[0], poly_line[1], poly_line[2])) {
            poly_line[1] = poly_line[0];
            poly_line.pop_front();
        }

        my_double answer = (poly_line.back().y - poly_line.front().y) / L;
        printf("%.7g\n", (double) answer);
    }
}


Measured memory_bytes: 22844