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.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class E {

	static int n, b, bS;
	static long[][] blocks, colorfull;
	static long[] color, extra, total;

	static void fix(int b, int l, int r, int c) {
		if(color[b] != -1) {
			for (int j = 0; j < bS; j++) {
				blocks[b][j] = color[b];
				colorfull[b][j] += extra[b];
			}
			color[b] = -1;
			extra[b] = 0;
		}
		if(c != -1) {
			for (int j = l; j <= r; j++) {
				colorfull[b][j] += Math.abs(blocks[b][j] - c);
				total[b] += Math.abs(blocks[b][j] - c);
				blocks[b][j] = c;
			}
		}
	}

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		n = sc.nextInt();
		int q = sc.nextInt();
		bS =  (int) Math.sqrt(n + 1);
		b = (n + bS - 1) / bS;
		blocks = new long[b][bS];
		colorfull = new long[b][bS];
		color = new long[b];
		Arrays.fill(color, -1);
		extra = new long[b];
		total = new long[b];
		for (int i = 0; i < b; i++) {
			for (int j = 0; j < bS && i * bS + j < n; j++) {
				blocks[i][j] = i * bS + j + 1;
				colorfull[i][j] = 0;
			}
		}

		for (int i = 0; i < q; i++) {
			int t = sc.nextInt();
			int l = sc.nextInt() - 1;
			int r = sc.nextInt() - 1;
			int lB = l / bS;
			int rB = r / bS;

			int lI = l % bS;
			int rI = r % bS;

			if(t == 1) {
				int c = sc.nextInt();
				if(lB == rB) {
					fix(lB, lI, rI, c);
				}else {
					fix(lB, lI, bS - 1, c);
					fix(rB, 0, rI, c);


					for (int j = lB + 1; j < rB; j++) {
						if(color[j] == -1) {
							fix(j, 0, bS - 1, c);
							color[j] = c;
							extra[j] = 0;
						}else {
							extra[j] += Math.abs(color[j] - c);
							total[j] += Math.abs(color[j] - c) * bS;
							color[j] = c;
						}
					}	
				}
			}else {
				if(lB == rB) {
					fix(lB, lI, rI, -1);
					
					long ans = 0;
					for (int j = lI; j <= rI; j++) 
						ans += colorfull[lB][j];
						
					out.println(ans);
				}else {
					fix(lB, lI, bS - 1, -1);
					fix(rB, 0, rI, -1);
					
					long ans = 0;
					for (int j = lI; j < bS; j++) 
						ans += colorfull[lB][j];

					for (int j = 0; j <= rI; j++) 
						ans += colorfull[rB][j];
					
					for (int j = lB + 1; j < rB; j++) 
						ans += total[j];
					out.println(ans);
				}
			}
		}

		out.flush(); 
		out.close();
	}





	static class Scanner 
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
		public Scanner(String file) throws FileNotFoundException{	br = new BufferedReader(new FileReader(file));}
		public String next() throws IOException 
		{
			while (st == null || !st.hasMoreTokens()) 
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

		public boolean ready() throws IOException {return br.ready();}


	}
}