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

namespace IO {
    const int BUFFER_SIZE = 1 << 15;

    char input_buffer[BUFFER_SIZE];
    int input_pos = 0, input_len = 0;

    char output_buffer[BUFFER_SIZE];
    int output_pos = 0;

    char number_buffer[100];
    uint8_t lookup[100];

    void _update_input_buffer() {
        input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
        input_pos = 0;

        if (input_len == 0)
            input_buffer[0] = EOF;
    }

    inline char next_char(bool advance = true) {
        if (input_pos >= input_len)
            _update_input_buffer();

        return input_buffer[advance ? input_pos++ : input_pos];
    }

    template<typename T>
    inline void read_int(T &number) {
        bool negative = false;
        number = 0;

        while (!isdigit(next_char(false)))
            if (next_char() == '-')
                negative = true;

        do {
            number = 10 * number + (next_char() - '0');
        } while (isdigit(next_char(false)));

        if (negative)
            number = -number;
    }

    template<typename T, typename... Args>
    inline void read_int(T &number, Args &... args) {
        read_int(number);
        read_int(args...);
    }

    inline void read_double(double &number) {
        bool negative = false;
        number = 0;

        while (!isdigit(next_char(false)))
            if (next_char() == '-')
                negative = true;

        do {
            number = 10 * number + (next_char() - '0');
        } while (isdigit(next_char(false)));

        if (next_char(false) == '.') {
            next_char();

            for (double multiplier = 0.1; isdigit(next_char(false)); multiplier *= 0.1)
                number += multiplier * (next_char() - '0');
        }

        if (negative)
            number = -number;
    }

    void _flush_output() {
        fwrite(output_buffer, sizeof(char), output_pos, stdout);
        output_pos = 0;
    }

    inline void write_char(char c) {
        if (output_pos == BUFFER_SIZE)
            _flush_output();

        output_buffer[output_pos++] = c;
    }

    template<typename T>
    inline void write_int(T number, char after = '\0') {
        if (number < 0) {
            write_char('-');
            number = -number;
        }

        int length = 0;

        while (number >= 10) {
            uint8_t lookup_value = lookup[number % 100];
            number /= 100;
            number_buffer[length++] = (lookup_value & 15) + '0';
            number_buffer[length++] = (lookup_value >> 4) + '0';
        }

        if (number != 0 || length == 0)
            write_char(number + '0');

        for (int i = length - 1; i >= 0; i--)
            write_char(number_buffer[i]);

        if (after)
            write_char(after);
    }

    inline void write_double(double number, char after = '\0', int places = 6) {
        if (number < 0) {
            write_char('-');
            number = -number;
        }

        assert(number <= 9e18);

        // Round up the number according to places.
        number += 0.5 * pow(0.1, places);
        long long floored = (long long) number;
        write_int(floored);

        if (places > 0) {
            write_char('.');
            number = (number - floored) * pow(10.0, places);
            floored = (long long) number;
            int length = 0;

            for (int i = 0; i < places / 2; i++) {
                uint8_t lookup_value = lookup[floored % 100];
                floored /= 100;
                number_buffer[length++] = (lookup_value & 15) + '0';
                number_buffer[length++] = (lookup_value >> 4) + '0';
            }

            if (places % 2)
                number_buffer[length++] = floored + '0';

            assert(length == places);

            for (int i = places - 1; i >= 0; i--)
                write_char(number_buffer[i]);
        }

        if (after)
            write_char(after);
    }

    void init() {
        // Make sure _flush_output() is called at the end of the program.
        bool exit_success = atexit(_flush_output) == 0;
        assert(exit_success);

        for (int i = 0; i < 100; i++)
            lookup[i] = (i / 10 << 4) + i % 10;
    }
}

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 main() {
    IO::init();

    int N;
    long long L;
    IO::read_int(N, L);
    deque<point> poly_line = {point(0, 0)};

    for (int i = 0; i < N; i++) {
        long long T, V;
        IO::read_int(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();

        // Truncate the last line so that the total width is exactly L.
        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 / delta.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;
        IO::write_double(answer, '\n');
    }
}


Measured memory_bytes: 24892