import java.util.*;

/**
 * Use Sqrt Decomposition.
 * Instead of trying to keep track of the length of mountain segments, keep
 * track of how much of the x axis is covered, then multiply by sqrt(2).
 *
 * In each block in the sqrt decomposition we keep track of how many mountains
 * cover a particular segment of the x axis. For each block we also keep track
 * of a total of how much of the block is covered and how many mountain segments
 * fully cover the entire block. Since w is up to 10^9, use coordinate compression
 * and only keep track of the points that are actually used.
 *
 * Time complexity: O(3*q*sqrt(2*q))
 *
 * @author Finn Lidbetter
 */

public class mountaincraft_finn {
    static int blockSize = 1;
    static int numBlocks = 1;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt();
        long w = sc.nextInt();
        long[] x = new long[q];
        long[] y = new long[q];
        long[] keyPoints = new long[2*q+2];
        double rt2 = Math.sqrt(2.0);
        for (int i=0; i<q; i++) {
            x[i] = sc.nextInt();
            y[i] = sc.nextInt();
            keyPoints[2*i] = x[i] + y[i];
            keyPoints[2*i+1] = x[i] - y[i];
        }
        keyPoints[2*q] = 0;
        keyPoints[2*q+1] = w;
        Arrays.sort(keyPoints);
        HashMap<Long,Integer> pointToIndex = new HashMap<>();
        ArrayList<Long> indexToPoint = new ArrayList<>();
        long prev = Long.MIN_VALUE;
        int index = 0;
        for (long k: keyPoints) {
            if (k>=0 && k<=w && k!=prev) {
                pointToIndex.put(k,index);
                indexToPoint.add(k);
                index++;
            }
            prev = k;
        }
        int numVals = indexToPoint.size();
        int sqrt = (int)Math.sqrt(numVals);
        blockSize = sqrt;
        numBlocks = numVals / blockSize;
        if (blockSize*numBlocks < numVals) {
            numBlocks++;
        }
        int[] blockValues = new int[numBlocks];
        int[][] individualCounts = new int[numBlocks][blockSize];
        long[] blockWidth = new long[numBlocks];
        int[] fullyCovered = new int[numBlocks];
        for (int i=0; i<numBlocks; i++) {
            int leftIndex = i*blockSize;
            int rightIndex = (int)Math.min((i+1)*blockSize, numVals-1);
            blockWidth[i] = indexToPoint.get(rightIndex) - indexToPoint.get(leftIndex);
        }
        HashSet<Pair> active = new HashSet<>();
        for (int t=0; t<q; t++) {
            Pair p = new Pair(x[t], y[t]);
            int delta = 1;
            if (active.contains(p)) {
                active.remove(p);
                delta = -1;
            } else {
                active.add(p);
                delta = 1;
            }
            long leftPoint = x[t] - y[t];
            if (leftPoint<0) {
                leftPoint = 0;
            }
            long rightPoint = x[t] + y[t];
            if (rightPoint>w) {
                rightPoint = w;
            }
            int leftIndex = pointToIndex.get(leftPoint);
            int rightIndex = pointToIndex.get(rightPoint);
            int leftBlock = getBlock(leftIndex);
            int leftOffset = getOffset(leftIndex);
            int rightBlock = getBlock(rightIndex);
            int rightOffset = getOffset(rightIndex);
            for (int block = leftBlock+1; block<rightBlock; block++) {
                fullyCovered[block] += delta;
            }
            if (leftBlock==rightBlock) {
                for (int i=leftOffset; i<rightOffset; i++) {
                    int j = leftBlock*blockSize + i;
                    long width = indexToPoint.get(j+1) - indexToPoint.get(j);
                    long prevIndividualValue = individualCounts[leftBlock][i];
                    individualCounts[leftBlock][i] += delta;
                    if (prevIndividualValue * individualCounts[leftBlock][i] == 0) {
                        blockValues[leftBlock] += delta * width;
                    }
                }
            } else {
                for (int i=leftOffset; i<blockSize; i++) {
                    int j = leftBlock*blockSize + i;
                    long width = indexToPoint.get(j+1) - indexToPoint.get(j);
                    long prevIndividualValue = individualCounts[leftBlock][i];
                    individualCounts[leftBlock][i] += delta;
                    if (prevIndividualValue * individualCounts[leftBlock][i] == 0) {
                        blockValues[leftBlock] += delta * width;
                    }
                }
                for (int i=0; i<rightOffset; i++) {
                    int j = rightBlock*blockSize + i;
                    long width = indexToPoint.get(j+1) - indexToPoint.get(j);
                    long prevIndividualValue = individualCounts[rightBlock][i];
                    individualCounts[rightBlock][i] += delta;
                    if (prevIndividualValue * individualCounts[rightBlock][i] == 0) {
                        blockValues[rightBlock] += delta * width;
                    }
                }
            }
            long querySum = 0;
            for (int block=0; block<numBlocks; block++) {
                if (fullyCovered[block] > 0) {
                    querySum += blockWidth[block];
                } else {
                    querySum += blockValues[block];
                }
            }
            System.out.println(querySum*rt2);
        }
    }
    static int getBlock(int index) {
        return index / blockSize;
    }
    static int getOffset(int index) {
        return index % blockSize;
    }
}
class Pair {
    long x,y;
    public Pair(long xx, long yy) {
        x = xx;
        y = yy;
    }
    public boolean equals(Object obj) { 
        Pair p2 = (Pair) obj;
        return x==p2.x && y==p2.y;
    }
    public int hashCode() {
        return Objects.hash(x,y);
    }
}