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.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;


public class C {

    static StringTokenizer st;
    static BufferedReader br;
    static PrintWriter pw;
    static long[] t_color, t_sum, t_delta;
    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        int m = nextInt();
        t_color = new long[4*n];
        t_sum = new long[4*n];
        t_delta = new long[4*n];
        Build(1, 1, n);
        for (int i = 1; i <= m; i++) {
            int type = nextInt();
            int L = nextInt();
            int R = nextInt();
            if (type==1) {
                int x = nextInt();
                update(1, 1, n, L, R, x);
            }
            else {
                pw.println(sum(1, 1, n, L, R, 0));
            }
        }
        pw.close();
    }
    private static long sum(int v, int tl, int tr, int L, int R, long add) {
        if (L > R)
            return 0;
        if (tl==L && tr==R)
            return t_sum[v]+add * (tr-tl+1);
        int tm = (tl+tr) >> 1;
        return sum(2*v, tl, tm, L, Math.min(tm, R), add+t_delta[v])+sum(2*v+1, tm+1, tr, Math.max(L, tm+1), R, add+t_delta[v]);
    }
    private static void update(int v, int tl, int tr, int L, int R, int x) {
        if (L > R)
            return;
        if (tl==L && tr==R) {
            update2(v, tl, tr, x);
            t_color[v] = x;
        }
        else {
            int tm = (tl+tr) >> 1;
            if (t_color[v] > 0) {
                t_color[2*v] = t_color[2*v+1] = t_color[v];
                t_color[v] = 0;
            }
            update(2*v, tl, tm, L, Math.min(tm, R), x);
            update(2*v+1, tm+1, tr, Math.max(L, tm+1), R, x);
            t_sum[v] = t_sum[2*v]+t_sum[2*v+1]+t_delta[v] * (tr-tl+1);
        }
    }
    private static void update2(int v, int tl, int tr, int x) {
        if (t_color[v] != 0) {
            t_delta[v] += Math.abs(x-t_color[v]);
            t_sum[v] += Math.abs(x-t_color[v]) * (tr-tl+1);
            t_color[v] = 0;
        }
        else {
            int tm = (tl+tr) >> 1;
            update2(2*v, tl, tm, x);
            update2(2*v+1, tm+1, tr, x);
            t_sum[v] = t_sum[2*v]+t_sum[2*v+1]+t_delta[v] * (tr-tl+1);
        }
    }
    private static void Build(int v, int tl, int tr) {
        if (tl==tr)
            t_color[v] = tl;
        else {
            int tm = (tl+tr) >> 1;
            Build(2*v, tl, tm);
            Build(2*v+1, tm+1, tr);
        }
    }
    private static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    private static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    private static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    private static String next() throws IOException {
        while (st==null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}
