Problem: This year Alex has finished school, and now he is a first-year student of Berland State University. For him it was a total surprise that even though he studies programming, he still has to attend physical education lessons. The end of the term is very soon, but, unfortunately, Alex still hasn't attended a single lesson!

Since Alex doesn't want to get expelled, he wants to know the number of working days left until the end of the term, so he can attend physical education lessons during these days. But in BSU calculating the number of working days is a complicated matter:

There are n days left before the end of the term (numbered from 1 to n), and initially all of them are working days. Then the university staff sequentially publishes q orders, one after another. Each order is characterised by three numbers l, r and k:

  * If k = 1, then all days from l to r (inclusive) become non-working days. If some of these days are made working days by some previous order, then these days still become non-working days; 
  * If k = 2, then all days from l to r (inclusive) become working days. If some of these days are made non-working days by some previous order, then these days still become working days. 



Help Alex to determine the number of working days left after each order!

Input

The first line contains one integer n, and the second line — one integer q (1 ≤ n ≤ 109, 1 ≤ q ≤ 3·105) — the number of days left before the end of the term, and the number of orders, respectively.

Then q lines follow, i-th line containing three integers li, ri and ki representing i-th order (1 ≤ li ≤ ri ≤ n, 1 ≤ ki ≤ 2).

Output

Print q integers. i-th of them must be equal to the number of working days left until the end of the term after the first i orders are published.

Example

Input

4
6
1 2 1
3 4 1
2 3 2
1 3 2
2 4 1
1 4 2


Output

2
0
2
3
1
4

Solution (in JAVA):

Solution:
import javax.swing.*;
import java.io.*;
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.Map.Entry;


public class Main implements Runnable {
    static final int MOD = (int) 1e9 + 7;
    static final int MI = (int) 1e9;
    static final long ML = (long) 1e18;
    static final Reader in = new Reader();
    static final PrintWriter out = new PrintWriter(System.out);
    StringBuilder answer = new StringBuilder();

    public static void main(String[] args) {
        new Thread(null, new Main(), "persefone", 1 << 32).start();
    }

    @Override
    public void run() {
        try {
            solve();
        } catch (IOException e) {
        }
        printf();
        flush();
    }

    void solve() throws IOException {
        int n = in.nextInt();
        NavigableMap<Integer, Integer> segments = new TreeMap<>();
        segments.put(1, n);
        int workingDays = n;
        for (int test = in.nextInt(); test > 0; test--) {
            int l = in.nextInt();
            int r = in.nextInt();
            int type = in.nextInt();
        //    printf(segments);
            if (type == 2) {
                Entry<Integer, Integer> floor = segments.floorEntry(l);
                int left = l;
                if (floor != null) {
                    int vfloor = floor.getValue();
                    if (vfloor >= r) {
                        add(workingDays, '\n');
                        continue;
                    }
                    if (vfloor >= l - 1) {
                        left = floor.getKey();
                        segments.remove(left);
                        workingDays -= vfloor - left + 1;
                    }
                }
                int right = r;
                while (true) {
                    Entry<Integer, Integer> higher = segments.higherEntry(l);
                    if (higher == null) {
                        workingDays += right - left + 1;
                        segments.put(left, right);
                        break;
                    }

                    int vhigh = higher.getValue();
                    int hkey = higher.getKey();
                    if (hkey <= r + 1) {
                        right = Math.max(right, vhigh);
                        workingDays -= vhigh - hkey + 1;
                        segments.remove(hkey);
                    } else {
                        workingDays += right - left + 1;
                        segments.put(left, right);
                        break;
                    }

                }
            } else {
                while (true) {
                    Entry<Integer, Integer> lower = segments.lowerEntry(l);
                    if (lower == null) break;
                    int vlow = lower.getValue();
                    if (vlow < l) break;
                    int klow = lower.getKey();
                    workingDays -= vlow - klow + 1;
                    if (vlow > r) {
                        workingDays += vlow - r;
                        segments.put(r + 1, vlow);
                    }
                    workingDays += l - klow;
                    segments.put(klow, l - 1);
                }
                while (true) {
                    Entry<Integer, Integer> ceil = segments.ceilingEntry(l);
                    if (ceil == null) break;
                    int kceil = ceil.getKey();
                    if (kceil > r) break;
                    int vceil = ceil.getValue();
                    workingDays -= vceil - kceil + 1;
                    segments.remove(kceil);
                    if (vceil > r) {
                        workingDays += vceil - r;
                        segments.put(r + 1, vceil);
                        break;
                    }
                }
            }
            add(workingDays, '\n');
        }
    }


    static class Fenwick {
        private int n;
        private long[] sum;

        public Fenwick(int n) {
            this.n = n + 10;
            this.sum = new long[n + 10];
        }

        public void update(int i, int v) {
            for (; i < n; i += i & -i) {
                sum[i] += v;
            }
        }

        long sum(int i) {
            long res = 0;
            for (; i > 0; i -= i & -i) {
                res += sum[i];
            }
            return res;
        }

        long sum(int i, int j) {
            return sum(j) - sum(i - 1);
        }
    }

    static class SegmentTreeSum {
        private int n;
        private int[] a, sum;

        public SegmentTreeSum(int[] a, int n) {
            this.n = n;
            this.a = a;
            this.sum = new int[4 * n + 4];
            build(1, 0, n - 1);
        }

        public void build(int currentVertex, int currentLeft, int currentRight) {
            if (currentLeft == currentRight) sum[currentVertex] = a[currentLeft];
            else {
                int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
                build(doubleVex, currentLeft, mid);
                build(doubleVex + 1, mid + 1, currentRight);
                sum[currentVertex] = sum[doubleVex] + sum[doubleVex + 1];
            }
        }

        public void update(int currentVertex, int currentLeft, int currentRight, int pos, int value) {
            if (currentLeft == currentRight) sum[currentVertex] = a[pos] = value;
            else {
                int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
                if (pos <= mid)
                    update(doubleVex, currentLeft, mid, pos, value);
                else
                    update(doubleVex + 1, mid + 1, currentRight, pos, value);
                sum[currentVertex] = sum[doubleVex] + sum[doubleVex + 1];
            }
        }

        public void update(int pos, int value) {
            update(1, 0, n - 1, pos, value);
        }

        public int sum(int currentVertex, int currentLeft, int currentRight, int left, int right) {
            if (currentLeft > right || currentRight < left) return 0;
            else if (left <= currentLeft && currentRight <= right) return sum[currentVertex];
            int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
            return sum(doubleVex, currentLeft, mid, left, right) + sum(doubleVex + 1, mid + 1, currentRight, left, right);
        }

        public int sum(int left, int right) {
            return sum(1, 0, n - 1, left, right);
        }

        public int kth(int currentVertex, int currentLeft, int currentRight, int k) {
            if (k > sum[currentVertex]) return -1;
            if (currentLeft == currentRight) return currentLeft;
            int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
            if (k <= sum[doubleVex])
                return kth(doubleVex, currentLeft, mid, k);
            else
                return kth(doubleVex + 1, mid + 1, currentRight, k - sum[doubleVex]);
        }

        public int kth(int k) {
            return kth(1, 0, n - 1, k);
        }
    }


    static class TreeSetTree {
        private int n;
        private int[] a;
        private NavigableSet<Integer>[] set;

        public TreeSetTree(int[] a, int n) {
            this.n = n;
            this.a = a;
            this.set = Stream.generate(TreeSet::new).limit(4 * n + 4).toArray(NavigableSet[]::new);
            build(1, 0, n - 1);
        }

        void merge(NavigableSet<Integer> z, NavigableSet<Integer> x, NavigableSet<Integer> y) {
            z.addAll(x);
            z.addAll(y);
        }

        public void build(int currentVertex, int currentLeft, int currentRight) {
            if (currentLeft == currentRight) set[currentVertex].add(a[currentLeft]);
            else {
                int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
                build(doubleVex, currentLeft, mid);
                build(doubleVex + 1, mid + 1, currentRight);
                merge(set[currentVertex], set[doubleVex], set[doubleVex + 1]);
            }
        }

        public void update(int currentVertex, int currentLeft, int currentRight, int pos, int value) {
            set[currentVertex].remove(a[pos]);
            set[currentVertex].add(value);
            if (currentLeft == currentRight) {
                a[pos] = value;
            } else {
                int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
                if (pos <= mid)
                    update(doubleVex, currentLeft, mid, pos, value);
                else
                    update(doubleVex + 1, mid + 1, currentRight, pos, value);
            }
        }

        public void update(int pos, int value) {
            update(1, 0, n - 1, pos, value);
        }

        public int get(int currentVertex, int currentLeft, int currentRight, int left, int right, int k) {
            if (currentLeft > right || currentRight < left) return 0;
            else if (left <= currentLeft && currentRight <= right) {
                Integer floor = set[currentVertex].floor(k);
                return floor == null ? 0 : floor;
            }
            int mid = currentLeft + currentRight >> 1, doubleVex = currentVertex << 1;
            return Math.max(get(doubleVex, currentLeft, mid, left, right, k),
                    get(doubleVex + 1, mid + 1, currentRight, left, right, k));
        }

        public int get(int left, int right, int k) {
            return get(1, 0, n - 1, left, right, k);
        }
    }

    static class ListUtils {
        static int lowerBound(List<Integer> list, int l, int r, int k) {
            int m = 0, ans = r;
            while (l < r) if (list.get(m = l + r >> 1) >= k) ans = r = m;
            else l = m + 1;
            return ans;
        }

        static int upperBound(List<Integer> list, int l, int r, int k) {
            int m = 0, ans = r;
            while (l < r) if (list.get(m = l + r >> 1) > k) ans = r = m;
            else l = m + 1;
            return ans;
        }

        static int amountOfNumbersEqualTo(List<Integer> list, int l, int r, int k) {
            return upperBound(list, l, r, k) - lowerBound(list, l, r, k);
        }

        static int amountOfNumbersEqualTo(List<Integer> list, int k) {
            return upperBound(list, 0, list.size(), k) - lowerBound(list, 0, list.size(), k);
        }


    }

    static class ArrayUtils {
        static int lowerBound(int[] a, int l, int r, int k) {
            int m = 0, ans = r;
            while (l < r) if (a[m = l + r >> 1] >= k) ans = r = m;
            else l = m + 1;
            return ans;
        }

        static int upperBound(int[] a, int l, int r, int k) {
            int m = 0, ans = r;
            while (l < r) if (a[m = l + r >> 1] > k) ans = r = m;
            else l = m + 1;
            return ans;
        }

        static int lowerBound(int[] a, int k) {
            return lowerBound(a, 0, a.length, k);
        }

        static int upperBound(int[] a, int k) {
            return upperBound(a, 0, a.length, k);
        }

        static void compressed(int[] a, int n) {
            int[] b = a.clone();
            Arrays.sort(b);
            for (int i = 0; i < n; i++) {
                a[i] = lowerBound(b, a[i]) + 1;
            }
        }
    }

    static class IntegerUtils {
        // returns { gcd(a,b), x, y } such that gcd(a,b) = a*x + b*y
        static long[] euclid(long a, long b) {
            long x = 1, y = 0, x1 = 0, y1 = 1, t;
            while (b != 0) {
                long q = a / b;
                t = x;
                x = x1;
                x1 = t - q * x1;
                t = y;
                y = y1;
                y1 = t - q * y1;
                t = b;
                b = a - q * b;
                a = t;
            }
            return a > 0 ? new long[]{a, x, y} : new long[]{-a, -x, -y};
        }

        static int[] generatePrimesUpTo(int n) {
            boolean[] composite = new boolean[n + 1];
            for (int i = 2; i <= n; i++) {
                for (int j = i; 1l * i * j <= n; j++) {
                    composite[i * j] = true;
                }
            }
            return IntStream.rangeClosed(2, n).filter(i -> !composite[i]).toArray();
        }

        static int[] smallestFactor(int n) {
            int[] sf = new int[n + 1];
            for (int i = 2; i <= n; i++) {
                if (sf[i] == 0) {
                    sf[i] = i;
                    for (int j = i; 1l * i * j <= n; j++) {
                        if (sf[i * j] == 0) {
                            sf[i * j] = i;
                        }
                    }
                }
            }
            return sf;
        }

        static int phi(int n) {
            int result = n;
            for (int i = 2; 1l * i * i <= n; i++) {
                if (n % i == 0) {
                    while (n % i == 0) n /= i;
                    result -= result / i;
                }
            }
            if (n > 1) result -= result / n;
            return result;
        }

        static long phi(long n) {
            // n <= 10 ^ 12;
            long result = n;
            for (int i = 2; 1l * i * i <= n; i++) {
                if (n % i == 0) {
                    while (n % i == 0) n /= i;
                    result -= result / i;
                }
            }
            if (n > 1) result -= result / n;
            return result;
        }

        static long[] n_thFiboNaCi(long n, int p) {
            // f[n + k] = f[n + 1].f[k] + f[n].f[k - 1]
            if (n == 0) return new long[]{0, 1};
            long[] a = n_thFiboNaCi(n >> 1, p);
            long c = (2 * a[1] - a[0] + p) % p * a[0] % p;
            long d = (a[1] * a[1] % p + a[0] * a[0] % p) % p;
            if (n % 2 == 0) return new long[]{c, d};
            else return new long[]{d, (c + d) % p};
        }

        static long modPow(int base, int exponential, int p) {
            if (exponential == 0) return 1;
            long x = modPow(base, exponential >> 1, p) % p;
            return exponential % 2 == 0 ? x * x % p : x * x % p * base % p;
        }

        static long modPow(long base, int exponential, int p) {
            if (exponential == 0) return 1;
            long x = modPow(base, exponential >> 1, p) % p;
            return exponential % 2 == 0 ? x * x % p : x * x % p * base % p;
        }

        static long modPow(long base, long exponential, int p) {
            if (exponential == 0) return 1;
            long x = modPow(base, exponential >> 1, p) % p;
            return exponential % 2 == 0 ? x * x % p : x * x % p * base % p;
        }

        static long[] generateFactorialArray(int n, int p) {
            long[] factorial = new long[n + 1];
            factorial[0] = 1;
            for (int i = 1; i <= n; i++) factorial[i] = (factorial[i - 1] * i) % p;
            return factorial;
        }

        static long cNkModP(long[] factorial, int n, int k, int p) {
            return factorial[n] * modPow(factorial[k], p - 2, p) % p * modPow(factorial[n - k], p - 2, p) % p;
        }

        static long gcd(long a, long b) {
            return b == 0 ? a : gcd(b, a % b);
        }

        static int gcd(int a, int b) {
            return b == 0 ? a : gcd(b, a % b);
        }

    }

    static class SparseTableMax {
        private int n, blocks;
        private int[] log, data;
        private int[][] max;

        public SparseTableMax(int[] data, int n) {
            this.n = n;
            this.data = data;
            this.log = new int[n + 1];
            for (int i = 2; i <= n; i++) {
                log[i] = log[i >> 1] + 1;
            }
            this.blocks = log[n];
            this.max = new int[n][blocks + 1];
            for (int i = 0; i < n; i++) {
                max[i][0] = data[i];
            }
            build();
        }

        int calc(int a, int b) {
            return Math.max(a, b);
        }

        void build() {
            for (int j = 1; j <= blocks; j++) {
                for (int i = 0; i + (1 << j) <= n; i++) {
                    max[i][j] = calc(max[i][j - 1], max[i + (1 << j - 1)][j - 1]);
                }
            }
        }

        int getMax(int l, int r) {
            int k = log[r - l + 1];
            return calc(max[l][k], max[r - (1 << k) + 1][k]);
        }
    }

    static class DSU {
        protected int vertex, countCC;
        protected int[] id, size;

        public DSU(int vertex) {
            this.vertex = vertex;
            this.id = IntStream.range(0, vertex).toArray();
            this.size = new int[vertex];
            Arrays.fill(size, 1);
            countCC = vertex;
        }

        int find(int i) {
            return id[i] == i ? i : (id[i] = find(id[i]));
        }

        void unite(int i, int j) {
            int x = find(i);
            int y = find(j);
            if (x == y) return;
            countCC--;
            if (size[x] > size[y]) {
                id[y] = id[x];
                size[x] += size[y];
                size[y] = 0;
                return;
            }
            id[x] = id[y];
            size[y] += size[x];
            size[x] = 0;
        }

        boolean isConnected(int i, int j) {
            return find(i) == find(j);
        }

        int connectedComponents() {
            return countCC;
        }
    }


    void printf() {
        out.print(answer);
    }

    void close() {
        out.close();
    }

    void flush() {
        out.flush();
    }

    void printf(Stream<?> str) {
        str.forEach(o -> add(o, " "));
        add("\n");
    }


    void printf(Object... obj) {
        printf(false, obj);
    }

    void printfWithDescription(Object... obj) {
        printf(true, obj);
    }


    private void printf(boolean b, Object... obj) {

        if (obj.length > 1) {
            for (int i = 0; i < obj.length; i++) {
                if (b) add(obj[i].getClass().getSimpleName(), " - ");
                if (obj[i] instanceof Collection<?>) {
                    printf((Collection<?>) obj[i]);
                } else if (obj[i] instanceof int[][]) {
                    printf((int[][]) obj[i]);
                } else if (obj[i] instanceof long[][]) {
                    printf((long[][]) obj[i]);
                } else if (obj[i] instanceof double[][]) {
                    printf((double[][]) obj[i]);
                } else printf(obj[i]);
            }
            return;
        }

        if (b) add(obj[0].getClass().getSimpleName(), " - ");
        printf(obj[0]);
    }

    void printf(Object o) {
        if (o instanceof int[])
            printf(Arrays.stream((int[]) o).boxed());
        else if (o instanceof char[])
            printf(new String((char[]) o));
        else if (o instanceof long[])
            printf(Arrays.stream((long[]) o).boxed());
        else if (o instanceof double[])
            printf(Arrays.stream((double[]) o).boxed());
        else if (o instanceof boolean[]) {
            for (boolean b : (boolean[]) o) add(b, " ");
            add("\n");
        } else
            add(o, "\n");
    }

    void printf(int[]... obj) {
        for (int i = 0; i < obj.length; i++) printf(obj[i]);
    }

    void printf(long[]... obj) {
        for (int i = 0; i < obj.length; i++) printf(obj[i]);
    }

    void printf(double[]... obj) {
        for (int i = 0; i < obj.length; i++) printf(obj[i]);
    }

    void printf(boolean[]... obj) {
        for (int i = 0; i < obj.length; i++) printf(obj[i]);
    }

    void printf(Collection<?> col) {
        printf(col.stream());
    }

    <T, K> void add(T t, K k) {
        if (t instanceof Collection<?>) {
            ((Collection<?>) t).forEach(i -> add(i, " "));
        } else if (t instanceof Object[]) {
            Arrays.stream((Object[]) t).forEach(i -> add(i, " "));
        } else
            add(t);
        add(k);
    }


    <T> void add(T t) {
        answer.append(t);
    }

    @SuppressWarnings("unchecked")
    <T extends Comparable<? super T>> T min(T... t) {
        if (t.length == 0)
            return null;
        T m = t[0];
        for (int i = 1; i < t.length; i++)
            if (t[i].compareTo(m) < 0)
                m = t[i];
        return m;
    }

    @SuppressWarnings("unchecked")
    <T extends Comparable<? super T>> T max(T... t) {
        if (t.length == 0)
            return null;
        T m = t[0];
        for (int i = 1; i < t.length; i++)
            if (t[i].compareTo(m) > 0)
                m = t[i];
        return m;
    }

    static class Pair<K extends Comparable<? super K>, V extends Comparable<? super V>>
            implements Comparable<Pair<K, V>> {
        private K k;
        private V v;

        Pair(K k, V v) {
            this.k = k;
            this.v = v;
        }

        @SuppressWarnings("unchecked")
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || !(o instanceof Pair)) return false;
            Pair<K, V> p = (Pair<K, V>) o;
            return k.compareTo(p.k) == 0 && v.compareTo(p.v) == 0;
        }

        @Override
        public int hashCode() {
            int hash = 31;
            hash = hash * 89 + k.hashCode();
            hash = hash * 89 + v.hashCode();
            return hash;
        }

        @Override
        public int compareTo(Pair<K, V> pair) {
            return k.compareTo(pair.k) == 0 ? v.compareTo(pair.v) : k.compareTo(pair.k);
        }

        @Override
        public Pair<K, V> clone() {
            return new Pair<K, V>(this.k, this.v);
        }

        @Override
        public String toString() {
            return String.valueOf(k).concat(" ").concat(String.valueOf(v)).concat("\n");
        }
    }

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }
}