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.*;
import java.util.*;
import java.math.*;
import java.util.concurrent.*;

public final class dzy_col
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static Random rnd=new Random();
	static long[] sum,add;
	static int[] a,color;
	
	static void build(int node,int s,int e)
	{
		if(s>e)
		{
			return;
		}
		
		if(s==e)
		{
			color[node]=a[s];sum[node]=0;
		}
		
		else
		{
			int mid=(s+e)>>1;
			
			build(node<<1,s,mid);build(node<<1|1,mid+1,e);
			
			color[node]=-1;
		}
	}
	
	static void merge(int node,int left,int right)
	{
		sum[node]=sum[left]+sum[right];
			
		if(color[left]==color[right] && color[left]!=-1)
		{
			color[node]=color[left];
		}
		
		else
		{
			color[node]=-1;
		}
	}
	
	static void push(int node,int s,int e)
	{
		sum[node]=sum[node]+((e-s+1)*1L*add[node]);
		
		if(s!=e)
		{
			add[node<<1]+=add[node];
			
			add[node<<1|1]+=add[node];
			
			if(color[node]!=-1)
			{
				color[node<<1]=color[node<<1|1]=color[node];
			}
		}
		
		add[node]=0;
	}
	
	static void update(int node,int s,int e,int l,int r,int x)
	{
		push(node,s,e);
		
		if(s>e || l>e || r<s)
		{
			return;
		}
		
		if(l<=s && r>=e && color[node]!=-1)
		{	
			sum[node]+=(e-s+1)*1L*Math.abs(color[node]-x);
			
			if(s!=e)
			{
				add[node<<1]+=Math.abs(color[node]-x);
				
				add[node<<1|1]+=Math.abs(color[node]-x);
				
				color[node<<1]=x;color[node<<1|1]=x;
			}
			
			color[node]=x;
		}
		
		else
		{
			int mid=(s+e)>>1;
			
			update(node<<1,s,mid,l,r,x);update(node<<1|1,mid+1,e,l,r,x);
			
			merge(node,node<<1,node<<1|1);
		}
	}
	
	static long query(int node,int s,int e,int l,int r)
	{
		push(node,s,e);
		
		if(s>e || l>e || r<s)
		{
			return 0;
		}
		
		if(l<=s && r>=e)
		{
			return sum[node];
		}
		
		else
		{
			int mid=(s+e)>>1;
			
			return query(node<<1,s,mid,l,r)+query(node<<1|1,mid+1,e,l,r);
		}
	}
	
    public static void main(String args[]) throws Exception
    {
		int n=sc.nextInt(),q=sc.nextInt();a=new int[n];
		
		for(int i=0;i<n;i++)
		{
			a[i]=(i+1);
		}
		
		sum=new long[4*n];add=new long[4*n];color=new int[4*n];build(1,0,n-1);
		
		while(q>0)
		{
			int t=sc.nextInt();
			
			if(t==1)
			{
				int l=sc.nextInt()-1,r=sc.nextInt()-1,x=sc.nextInt();
				
				update(1,0,n-1,l,r,x);
			}
			
			else
			{
				int l=sc.nextInt()-1,r=sc.nextInt()-1;
				
				out.println(query(1,0,n-1,l,r));
			}
		
			q--;
		}
		
		out.close();
    }
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }
	
    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
	
	public String next() throws Exception {
		return nextToken().toString();
	}
	
    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}