Problem:
Score : 700 points

Problem Statement

There is a circle with a circumference of L.
Each point on the circumference has a coordinate value, which represents the arc length from a certain reference point clockwise to the point.
On this circumference, there are N ants.
These ants are numbered 1 through N in order of increasing coordinate, and ant i is at coordinate X_i.

The N ants have just started walking.
For each ant i, you are given the initial direction W_i. Ant i is initially walking clockwise if W_i is 1; counterclockwise if W_i is 2.
Every ant walks at a constant speed of 1 per second.
Sometimes, two ants bump into each other.
Each of these two ants will then turn around and start walking in the opposite direction.

For each ant, find its position after T seconds.

Constraints

All input values are integers.

1 \leq N \leq 10^5

1 \leq L \leq 10^9

1 \leq T \leq 10^9

0 \leq X_1 < X_2 < ... < X_N \leq L - 1

1 \leq W_i \leq 2

Input

The input is given from Standard Input in the following format:

N L T
X_1 W_1
X_2 W_2
:
X_N W_N

Output

Print N lines.
The i-th line should contain the coordinate of ant i after T seconds. Here, each coordinate must be between 0 and L-1, inclusive.

Sample Input 1

3 8 3
0 1
3 2
6 1

Sample Output 1

1
3
0

1.5 seconds after the ants start walking, ant 1 and 2 bump into each other at coordinate 1.5.
1 second after that, ant 1 and 3 bump into each other at coordinate 0.5.
0.5 seconds after that, that is, 3 seconds after the ants start walking, ants 1, 2 and 3 are at coordinates 1, 3 and 0, respectively.

Sample Input 2

4 20 9
7 2
9 1
12 1
18 1

Sample Output 2

7
18
18
1

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

// package atcoder.agc.agc013;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        long L = in.nextLong();
        long T = in.nextLong();
        long[][] ants = in.nextLongTable(n, 2);

        List<Integer> clockWiseAnts = new ArrayList<>();
        List<Integer> counterClockWiseAnts = new ArrayList<>();
        for (int i = 0; i < n ; i++) {
            if (ants[i][1] == 1) {
                clockWiseAnts.add(i);
            } else {
                counterClockWiseAnts.add(i);
            }
        }

        long[][] goalPositions = new long[n][3];
        for (int i = 0; i < n ; i++) {
            goalPositions[i][0] = i;
            goalPositions[i][1] = ants[i][0] + ((ants[i][1] == 1) ? (T % L) : (L - T % L));
            goalPositions[i][1] %= L;
            goalPositions[i][2] = ants[i][1];
        }

        if (clockWiseAnts.size() == 0 || counterClockWiseAnts.size() == 0) {
            for (int i = 0; i < n ; i++) {
                out.println(goalPositions[i][1]);
            }
            out.flush();
            return;
        }


        long p = ants[clockWiseAnts.get(0)][0];
        long[] ctr = new long[counterClockWiseAnts.size()];
        for (int i = 0 ; i < counterClockWiseAnts.size() ; i++) {
            ctr[i] = (ants[counterClockWiseAnts.get(i)][0] + L - p) % L;
        }
        Arrays.sort(ctr);

        long hit = (T / L) * 2 * counterClockWiseAnts.size();
        long mod = T % L; // [0, mod)

        for (int i = 0 ; i < ctr.length ; i++) {
            if (ctr[i] < mod * 2) {
                hit++;
            }
            if (ctr[i] + L < mod * 2) {
                hit++;
            }
        }

        long[] ans = new long[n];
        Arrays.sort(goalPositions, (a, b) -> (a[1] == b[1]) ? Long.compare(a[2], b[2]) : Long.compare(a[1], b[1]));
        for (int i = 0 ; i < n ; i++) {
            if (goalPositions[i][0] == clockWiseAnts.get(0)) {
                int start = (int)(n + i - (hit % n)) % n;
                int aStart = clockWiseAnts.get(0);
                for (int j = 0; j < n ; j++) {
                    ans[(j+aStart)%n] = goalPositions[(j+start)%n][1];
                }
                break;
            }
        }
        for (int i = 0; i < n ; i++) {
            out.println(ans[i]);
        }

        out.flush();
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int[] nextInts(int n) {
            int[] ret = new int[n];
            for (int i = 0; i < n; i++) {
                ret[i] = nextInt();
            }
            return ret;
        }

        private int[][] nextIntTable(int n, int m) {
            int[][] ret = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    ret[i][j] = nextInt();
                }
            }
            return ret;
        }

        private long[] nextLongs(int n) {
            long[] ret = new long[n];
            for (int i = 0; i < n; i++) {
                ret[i] = nextLong();
            }
            return ret;
        }

        private long[][] nextLongTable(int n, int m) {
            long[][] ret = new long[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    ret[i][j] = nextLong();
                }
            }
            return ret;
        }

        private double[] nextDoubles(int n) {
            double[] ret = new double[n];
            for (int i = 0; i < n; i++) {
                ret[i] = nextDouble();
            }
            return ret;
        }

        private int next() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public char nextChar() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            if ('a' <= c && c <= 'z') {
                return (char) c;
            }
            if ('A' <= c && c <= 'Z') {
                return (char) c;
            }
            throw new InputMismatchException();
        }

        public String nextToken() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            StringBuilder res = new StringBuilder();
            do {
                res.append((char) c);
                c = next();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public int nextInt() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c-'0';
                c = next();
            } while (!isSpaceChar(c));
            return res*sgn;
        }

        public long nextLong() {
            int c = next();
            while (isSpaceChar(c))
                c = next();
            long sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c-'0';
                c = next();
            } while (!isSpaceChar(c));
            return res*sgn;
        }

        public double nextDouble() {
            return Double.valueOf(nextToken());
        }

        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }
}