DZY loves colors, and he enjoys painting.

On a colorful day, DZY gets a colorful ribbon, which consists of n units (they are numbered from 1 to n from left to right). The color of the i-th unit of the ribbon is i at first. It is colorful enough, but we still consider that the colorfulness of each unit is 0 at first.

DZY loves painting, we know. He takes up a paintbrush with color x and uses it to draw a line on the ribbon. In such a case some contiguous units are painted. Imagine that the color of unit i currently is y. When it is painted by this paintbrush, the color of the unit becomes x, and the colorfulness of the unit increases by |x - y|.

DZY wants to perform m operations, each operation can be one of the following:

  1. Paint all the units with numbers between l and r (both inclusive) with color x. 
  2. Ask the sum of colorfulness of the units between l and r (both inclusive). 



Can you help DZY?

Input

The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105).

Each of the next m lines begins with a integer type (1 ≤ type ≤ 2), which represents the type of this operation.

If type = 1, there will be 3 more integers l, r, x (1 ≤ l ≤ r ≤ n; 1 ≤ x ≤ 108) in this line, describing an operation 1.

If type = 2, there will be 2 more integers l, r (1 ≤ l ≤ r ≤ n) in this line, describing an operation 2.

Output

For each operation 2, print a line containing the answer — sum of colorfulness.

Examples

Input

3 3
1 1 2 4
1 2 3 5
2 1 3


Output

8


Input

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


Output

3
2
1


Input

10 6
1 1 5 3
1 2 7 9
1 10 10 11
1 3 8 12
1 1 10 3
2 1 10


Output

129

Note

In the first sample, the color of each unit is initially [1, 2, 3], and the colorfulness is [0, 0, 0].

After the first operation, colors become [4, 4, 3], colorfulness become [3, 2, 0].

After the second operation, colors become [4, 5, 5], colorfulness become [3, 3, 2].

So the answer to the only operation of type 2 is 8.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class DZYLovesColors {
    
    void solve() {
        int n = in.nextInt(), m = in.nextInt();
        
        SegmentTree seg = new SegmentTree(n);
        while (m-- > 0) {
            int t = in.nextInt(), l = in.nextInt() - 1, r = in.nextInt();
            if (t == 1) {
                int x = in.nextInt();
                seg.update(l, r, x);
            } else {
                out.println(seg.query(l, r));
            }
        }
    }
    
    static class SegmentTree {
        int n;
        int[] color;
        long[] sum, lazy;
        
        SegmentTree(int m) {
            int x = 0;
            while ((1 << x) < m) x++;
            n = 1 << x;
            color = new int[2 * n - 1];
            for (int i = 0; i < m; i++) {
                color[n - 1 + i] = i + 1;
            }
            sum = new long[2 * n - 1];
            lazy = new long[2 * n - 1];
        }
        
        void update(int a, int b, int x) {
            update(a, b, x, 0, 0, n);
        }
        
        void update(int a, int b, int x, int k, int l, int r) {
            if (a >= r || b <= l) return;
            if (color[k] == 0) {
                update(a, b, x, 2 * k + 1, l, (l + r) / 2);
                update(a, b, x, 2 * k + 2, (l + r) / 2, r);
                sum[k] = sum[2 * k + 1] + ((l + r) / 2 - l) * lazy[2 * k + 1] + sum[2 * k + 2] + (r - (l + r) / 2) * lazy[2 * k + 2];
                if (a <= l && r <= b) color[k] = x;
                return;
            }
            if (a <= l && r <= b) {
                lazy[k] += Math.abs(x - color[k]);
                color[k] = x;
                return;
            }
            color[2 * k + 1] = color[k];
            color[2 * k + 2] = color[k];
            color[k] = 0;
            update(a, b, x, 2 * k + 1, l, (l + r) / 2);
            update(a, b, x, 2 * k + 2, (l + r) / 2, r);
            sum[k] = sum[2 * k + 1] + ((l + r) / 2 - l) * lazy[2 * k + 1] + sum[2 * k + 2] + (r - (l + r) / 2) * lazy[2 * k + 2];
        }
        
        long query(int a, int b) {
            return query(a, b, 0, 0, n);
        }
        
        long query(int a, int b, int k, int l, int r) {
            if (a >= r || b <= l) return 0;
            if (a <= l && r <= b) return sum[k] + lazy[k] * (r - l);
            lazy[2 * k + 1] += lazy[k];
            lazy[2 * k + 2] += lazy[k];
            lazy[k] = 0;
            long ans = query(a, b, 2 * k + 1, l, (l + r) / 2) + query(a, b, 2 * k + 2, (l + r) / 2, r);
            sum[k] = sum[k] = sum[2 * k + 1] + ((l + r) / 2 - l) * lazy[2 * k + 1] + sum[2 * k + 2] + (r - (l + r) / 2) * lazy[2 * k + 2];
            return ans;
        }
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new DZYLovesColors().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
