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.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		
		int _n = 1;
		while (_n < n) {
			_n *= 2;
		}
		long[][] seg = new long[2][_n * 2 - 1];
		
		Comparator<int[]> cmp = new Comparator<int[]>() {
			public int compare(int[] a, int[] b) {
				if (a[1] <= b[0]) {
					return -1;
				}
				else if (b[1] <= a[0]) {
					return 1;
				}
				else {
					return 0;
				}
			}
		};
		TreeSet<int[]> set = new TreeSet<int[]>(cmp);
		for (int i = 0; i < n; i++) {
			set.add(new int[]{i, i + 1, i + 1});
		}
		
		for (; m > 0; m--) {
			int type = in.nextInt();
			if (type == 1) {
				int l = in.nextInt() - 1;
				int r = in.nextInt();
				int x = in.nextInt();
				
				int[] e = set.ceiling(new int[]{l, l, 0});
				if (e[0] < l && l < e[1]) {
					set.remove(e);
					set.add(new int[]{e[0], l, e[2]});
					set.add(new int[]{l, e[1], e[2]});
				}
				e = set.floor(new int[]{r, r, 0});
				if (e[0] < r && r < e[1]) {
					set.remove(e);
					set.add(new int[]{e[0], r, e[2]});
					set.add(new int[]{r, e[1], e[2]});
				}
				
				SortedSet<int[]> sub = set.subSet(new int[]{l, l, 0}, new int[]{r, r, 0});
				for (int[] _e: sub) {
					add(seg, _e[0], _e[1], Math.abs(_e[2] - x), 0, 0, _n);
				}
				sub.clear();
				set.add(new int[]{l, r, x});
			}
			if (type == 2) {
				int l = in.nextInt() - 1;
				int r = in.nextInt();
				System.out.println(sum(seg, l, r, 0, 0, _n));
			}
		}
	}
	
	static long sum(long[][] seg, int a, int b, int i, int l, int r) {
		if (b <= l || r <= a) {
			return 0;
		}
		else if (a <= l && r <= b) {
			return (r - l) * seg[0][i] + seg[1][i];
		}
		else {
			long res = (Math.min(b, r) - Math.max(a, l)) * seg[0][i];
			res += sum(seg, a, b, i * 2 + 1, l, (l + r) / 2);
			res += sum(seg, a, b, i * 2 + 2, (l + r) / 2, r);
			return res;
		}
	}
	
	static void add(long[][] seg, int a, int b, long x, int i, int l, int r) {
		if (a <= l && r <= b) {
			seg[0][i] += x;
		}
		else if (l < b && a < r) {
			seg[1][i] += (Math.min(b, r) - Math.max(a, l)) * x;
			add(seg, a, b, x, i * 2 + 1, l, (l + r) / 2);
			add(seg, a, b, x, i * 2 + 2, (l + r) / 2, r);
		}
	}
}