using System;
using System.Linq;//リストの使用
using System.Collections.Generic;
class Program
{
static string[] input = Console.ReadLine().Split(' ');
static long n = long.Parse(input[0]);
static long q = long.Parse(input[1]);
static long[] nums = new long[600*600];
static long[] numSets = new long[600];//600*600に分割
static long[] numSetsSub = new long[600];

	static void Main()
	{
    //AreaChangeSumGetReady();
      //区間以上以下の値を全てchangeNumに変更し、区間以上以下の和を求める初期値前処理。
    //AreaChangeMaxGetReady();
      //区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値を求める初期値前処理。
    AreaChangeMinGetReady();
      //区間以上以下の値を全てchangeNumに変更し、区間以上以下の最小値を求める初期値前処理。
    //AreaChangePointGetReady();
      //区間以上以下の値を全てchangeNumに変更し、ある１点の値を求める初期値前処理。
    //AreaAddSumGetReady();
      //区間以上以下の値に全てchangeNum加算し、区間以上以下の和を求める初期値前処理。
    //AreaAddMaxGetReady();
      //区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値を求める初期値前処理。
    //AreaAddMinGetReady();
      //区間以上以下の値に全てchangeNum加算し、区間以上以下の最小値を求める初期値前処理。
      
    for(long question = 0; question < q; question++)
    {
      string[] inputq = Console.ReadLine().Split(' ');
      long howNum = long.Parse(inputq[0]);
        
      if(howNum == 0)//書き換え
      {
        int leftNum = int.Parse(inputq[1]);
        int rightNum = int.Parse(inputq[2]);
        long changeNum = long.Parse(inputq[3]);
        AreaChangeMinGet(leftNum,rightNum,changeNum);//変更処理の選択
      }
      if(howNum == 1)//値を求める
      {
        int leftNum = int.Parse(inputq[1]);
        int rightNum = int.Parse(inputq[2]);
        Console.WriteLine(AreaChangeMinGetAnswer(leftNum, rightNum));//取得（出力）処理の選択
      }
    }
    
	}

  static void AreaChangeSumGetReady()
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の和を求める初期値前処理。
  for(int i = 0; i < 600*600; i++)
  {
    nums[i] = 0;
  }
  for(int i = 0; i < 600; i++)
  {
    numSetsSub[i] = long.MinValue/2;
    for(int j = 0; j < 600; j++)
    {
      numSets[i] += nums[600*i+j];//区間の和
    }
  }
  }

  static void AreaChangeMaxMinGetReady(int minOrMax)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値1最小値-1を求める初期値前処理。
    for(int i = 0; i < 600*600; i++)
    {
      nums[i] = 2147483647;
    }
    for(int i = 0; i < 600; i++)
    {
      long max = long.MinValue/2;
      long min = long.MaxValue/2;
      for(int j = 0; j < 600; j++)
      {
        max = Math.Max(max, nums[600*i+j]);
        min = Math.Min(min, nums[600*i+j]);
      }
      if(minOrMax == -1)
      {
        numSets[i] = min;
        numSetsSub[i] = long.MinValue/2;
      }else
      {
        numSets[i] = max;
        numSetsSub[i] = long.MaxValue/2;
      }
    } 
  }

  static void AreaChangeMaxGetReady()
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値を求める初期値前処理。
    AreaChangeMaxMinGetReady(1);
  }

  static void AreaChangeMinGetReady()
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最小値を求める初期値前処理。
    AreaChangeMaxMinGetReady(-1);
  }

  static void AreaChangePointGetReady()
  {//区間以上以下の値を全てchangeNumに変更し、ある１点の値を求める初期値前処理。
    AreaChangeMinGetReady();
  }

  static void AreaAddSumGetReady()
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の和を求める初期値前処理。
    for(int i = 0; i < 600*600; i++)
    {
      nums[i] = 0;
    }
    for(int i = 0; i < 600; i++)
    {
      numSets[i] = 0;
      for(int j = 0; j < 600; j++)
      {
        numSetsSub[i] += nums[600*i+j];//区間の和
      }
    }
  }

  static void AreaAddMaxMinGetReady(int minOrMax)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値1または最小値-1を求める初期値前処理。
    for(int i = 0; i < 600*600; i++)
    {
      nums[i] = 0;
    }
    for(int i = 0; i < 600; i++)
    {
      numSets[i] = 0;
      if(minOrMax == -1)
      {
        long min = long.MaxValue/2;
        for(int j = 0; j < 600; j++)
        {
          min = Math.Min(min, nums[600*i+j]);
        }
        numSetsSub[i] = min;//各区間の最小値
      }else
      {
        long max = long.MinValue/2;
        for(int j = 0; j < 600; j++)
        {
          max = Math.Max(max, nums[600*i+j]);
        }
        numSetsSub[i] = max;//各区間の最小値
      }
    }
  }

  static void AreaAddMaxGetReady()
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値を求める初期値前処理。
    AreaAddMaxMinGetReady(1);
  }

  static void AreaAddMinGetReady()
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最小値を求める初期値前処理。
    AreaAddMaxMinGetReady(-1);
  }

  static void AreaChangeSumGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の和を求める。入力側
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);

    NumberApply(leftNum, rightNum);

    if(leftPosition == rightPosition)//左右が同じ分類のとき
    {
      for(long i = leftNum; i <= rightNum; i++)
      {
        nums[i] = changeNum;
      }
      long sum = 0;
      for(long i = 0; i < 600; i++)//区間内全てを見る
      {
        sum += nums[leftPosition*600+i];
      }
      numSets[leftPosition] = sum;
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        nums[i] = changeNum;
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        nums[i] = changeNum;
      }
      long sumL = 0;
      long sumR = 0;
      for(long i = 0; i < 600; i++)//区間内全てを見る
      {
        sumL += nums[leftPosition*600+i];
        sumR += nums[rightPosition*600+i];
      }
      numSets[leftPosition] = sumL;
      numSets[rightPosition] = sumR;
      
      for(int i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        numSetsSub[i] = changeNum;
        numSets[i] = changeNum*600;
      }
    }
  }

  static void AreaChangeMaxMinGet(int leftNum, int rightNum, long changeNum, int minOrMax)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最小値-1最大値1を求める。入力側
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);

    NumberApply(leftNum, rightNum);

    if(leftPosition == rightPosition)//左右が同じ分類のとき
    {
      for(long i = leftNum; i <= rightNum; i++)
      {
        nums[i] = changeNum;
      }
      long minMemo = long.MaxValue/2;
      long maxMemo = long.MinValue/2;
      for(long i = 0; i < 600; i++)//区間内全てを見る
      {
        minMemo = Math.Min(minMemo, nums[leftPosition*600+i]);
        maxMemo = Math.Max(maxMemo, nums[leftPosition*600+i]);
      }
      if(minOrMax == -1) numSets[leftPosition] = minMemo;
      if(minOrMax == 1) numSets[leftPosition] = maxMemo;
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        nums[i] = changeNum;
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        nums[i] = changeNum;
      }
      long minMemoL = long.MaxValue/2;
      long minMemoR = long.MaxValue/2;
      long maxMemoL = long.MaxValue/2;
      long maxMemoR = long.MaxValue/2;
      for(long i = 0; i < 600; i++)//区間内全てを見る
      {
        minMemoL = Math.Min(minMemoL, nums[leftPosition*600+i]);
        minMemoR = Math.Min(minMemoR, nums[rightPosition*600+i]);
        maxMemoL = Math.Max(maxMemoL, nums[leftPosition*600+i]);
        maxMemoR = Math.Max(maxMemoR, nums[rightPosition*600+i]);
      }
      if(minOrMax == -1)
      {
        numSets[leftPosition] = minMemoL;
        numSets[rightPosition] = minMemoR;
      }else
      {
        numSets[leftPosition] = maxMemoL;
        numSets[rightPosition] = maxMemoR;
      }
      
      for(int i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        numSetsSub[i] = changeNum;
        numSets[i] = changeNum;
      }
    }
  }

  static void AreaChangeMaxGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値を求める。入力側
    AreaChangeMaxMinGet(leftNum, rightNum, changeNum, 1);
  }

  static void AreaChangeMinGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最小値を求める。入力側
    AreaChangeMaxMinGet(leftNum, rightNum, changeNum, -1);
  }

  static void AreaChangePointGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値を全てchangeNumに変更し、ある１点の値を求める。入力側
    AreaChangeMinGet(leftNum, rightNum, changeNum);
  }

  static void AreaAddSumGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の和を求める。入力側
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);

    if(leftPosition == rightPosition)//左右が同じ分類のとき
    {
      for(long i = leftNum; i <= rightNum; i++)
      {
        nums[i] += changeNum;
        numSetsSub[leftPosition] += changeNum;
      }
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        nums[i] += changeNum;
        numSetsSub[leftPosition] += changeNum;
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        nums[i] += changeNum;
        numSetsSub[rightPosition] += changeNum;
      }
      for(int i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        numSetsSub[i] += changeNum*600;
        numSets[i] += changeNum;
      }
    }
  }

  static void AreaAddMaxMinGet(int leftNum, int rightNum, long changeNum, int minOrMax)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値1最小値-1を求める。入力側
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);

    if(minOrMax == -1) NumberAddMin(leftNum, rightNum);
    else NumberAddMax(leftNum, rightNum);

    if(leftPosition == rightPosition)//左右が同じ分類のとき
    {
      for(long i = leftNum; i <= rightNum; i++)
      {
        nums[i] += changeNum;
      }
    if(minOrMax == -1) NumberAddMin(leftNum);
    else NumberAddMax(leftNum);
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        nums[i] += changeNum;
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        nums[i] += changeNum;
      }
      if(minOrMax == -1) NumberAddMin(leftNum,rightNum);
      else NumberAddMax(leftNum,rightNum);
    
      for(int i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        numSetsSub[i] += changeNum;
        numSets[i] += changeNum;
      }
    }
  }

  static void AreaAddMaxGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値を求める。入力側
    AreaAddMaxMinGet(leftNum, rightNum, changeNum, 1);
  }

  static void AreaAddMinGet(int leftNum, int rightNum, long changeNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最小値を求める。入力側
    AreaAddMaxMinGet(leftNum, rightNum, changeNum, -1);
  }

  static long AreaChangeSumGetAnswer(int leftNum, int rightNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の和を求める。出力側
    long sum = 0;
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);
    NumberApply(leftNum, rightNum);

    if(leftPosition == rightPosition)
    {
      for(long i = leftNum; i <= rightNum; i++)//左右が同じ分類のとき
      {
        sum += nums[i];
      }
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        sum += nums[i];
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        sum += nums[i];
      }
      for(long i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        sum += numSets[i];
      }
    }
    return sum;
  }

  static long AreaChangeMaxMinGetAnswer(int leftNum, int rightNum, int minOrMax)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値1最小値-1を求める。出力側
    long minMemo = long.MaxValue/2;
    long maxMemo = long.MinValue/2;
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);

    NumberApply(leftNum, rightNum);

    if(leftPosition == rightPosition)
    {
      for(long i = leftNum; i <= rightNum; i++)//左右が同じ分類のとき
      {
        minMemo = Math.Min(minMemo, nums[i]);
        maxMemo = Math.Max(maxMemo, nums[i]);
      }
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        minMemo = Math.Min(minMemo, nums[i]);
        maxMemo = Math.Max(maxMemo, nums[i]);
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        minMemo = Math.Min(minMemo, nums[i]);
        maxMemo = Math.Max(maxMemo, nums[i]);
      }
      for(long i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        minMemo = Math.Min(minMemo, numSets[i]);
        maxMemo = Math.Max(maxMemo, numSets[i]);
      }
    }
    if(minOrMax == -1) return minMemo;
    return maxMemo;
  }

  static long AreaChangeMaxGetAnswer(int leftNum, int rightNum)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値を求める。出力側
    return AreaChangeMaxMinGetAnswer(leftNum, rightNum, 1);
  }

  static long AreaChangeMinGetAnswer(int leftNum, int rightNum)
  {//区間以上以下の値を全てchangeNumに変更し、区間以上以下の最大値を求める。出力側
    return AreaChangeMaxMinGetAnswer(leftNum, rightNum, -1);
  }

  static long AreaChangePointGetAnswer(int pointNum)
  {//区間以上以下の値を全てchangeNumに変更し、ある１点の値を求める。出力側
    int numPosition = WherePosition(pointNum);

    NumberApply(pointNum);

    return nums[pointNum];
  }

  static long AreaAddSumGetAnswer(int leftNum, int rightNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の和を求める。出力側
    long sum = 0;
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);

    if(leftPosition == rightPosition)
    {
      for(long i = leftNum; i <= rightNum; i++)//左右が同じ分類のとき
      {
        sum += numSets[leftPosition] + nums[i];
      }
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        sum += numSets[leftPosition] + nums[i];
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        sum += numSets[rightPosition] + nums[i];
      }
      for(long i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        sum += numSetsSub[i];
      }
    }
    return sum;
  }

  static long AreaAddMaxMinGetAnswer(int leftNum, int rightNum, int minOrMax)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値1最小値-1を求める。出力側
    int leftPosition = WherePosition(leftNum);
    int rightPosition = WherePosition(rightNum);
    long min = long.MaxValue/2;
    long max = long.MinValue/2;
    
    if(minOrMax == -1) NumberAddMin(leftNum, rightNum);
    else NumberAddMax(leftNum, rightNum);

    if(leftPosition == rightPosition)
    {
      for(long i = leftNum; i <= rightNum; i++)//左右が同じ分類のとき
      {
        min = Math.Min(min, nums[i]);
        max = Math.Max(max, nums[i]);
      }
    }else
    {
      for(long i = leftNum; i < 600*(leftPosition+1); i++)//左区間内（左端より右だけ見る）
      {
        min = Math.Min(min, nums[i]);
        max = Math.Max(max, nums[i]);
      }
      for(long i = 600*rightPosition; i <= rightNum; i++)//右区間内
      {
        min = Math.Min(min, nums[i]);
        max = Math.Max(max, nums[i]);
      }
      for(long i = leftPosition+1; i < rightPosition; i++)//見ていない区間内
      {
        min = Math.Min(min, numSetsSub[i]);
        max = Math.Max(max, numSetsSub[i]);
      }
    }
    if(minOrMax == -1) return min;
    else return max;
  }

  static long AreaAddMaxGetAnswer(int leftNum, int rightNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最大値を求める。出力側
    return AreaAddMaxMinGetAnswer(leftNum, rightNum, 1);
  }

  static long AreaAddMinGetAnswer(int leftNum, int rightNum)
  {//区間以上以下の値に全てchangeNum加算し、区間以上以下の最小値を求める。出力側
    return AreaAddMaxMinGetAnswer(leftNum, rightNum, -1);
  }

  static void NumberApply(int pointNum)
  {//控え中の数を個々に割り当てる
    int numPosition = WherePosition(pointNum);

    if(numSetsSub[numPosition] != long.MinValue/2)
    {
      for(int i = 0; i < 600; i++)//区間内全てを見る
      {
        nums[numPosition*600+i] = numSetsSub[numPosition];
      }
      numSetsSub[numPosition] = long.MinValue/2;
    }
  }

  static void NumberApply(int leftNum, int rightNum)
  {
    NumberApply(leftNum);
    NumberApply(rightNum);
  }

  static void NumberAddMax(int pointNum)
  {//控え中の数を個々に加算した後、最大値を求める
    int numPosition = WherePosition(pointNum);

    if(numSets[numPosition] != 0)
    {
      for(int i = 0; i < 600; i++)//区間内全てを見る
      {
        nums[numPosition*600+i] += numSets[numPosition];
      }
      numSets[numPosition] = 0;
    }

    long max = long.MinValue/2;
    for(int i = 0; i < 600; i++)
    {
      if(nums[numPosition*600+i] > max) max = nums[numPosition*600+i];
    }

    numSetsSub[numPosition] = max;
  }

  static void NumberAddMin(int pointNum)
  {//控え中の数を個々に加算した後、最小値を求める
    int numPosition = WherePosition(pointNum);

    if(numSets[numPosition] != 0)
    {
      for(int i = 0; i < 600; i++)//区間内全てを見る
      {
        nums[numPosition*600+i] += numSets[numPosition];
      }
      numSets[numPosition] = 0;
    }

    long min = long.MaxValue/2;
    for(int i = 0; i < 600; i++)
    {
      if(nums[numPosition*600+i] < min) min = nums[numPosition*600+i];
    }

    numSetsSub[numPosition] = min;
  }

  static void NumberAddMin(int leftNum, int rightNum)
  {
    NumberAddMin(leftNum);
    NumberAddMin(rightNum);
  }

  static void NumberAddMax(int leftNum, int rightNum)
  {
    NumberAddMax(leftNum);
    NumberAddMax(rightNum);
  }

  static int WherePosition(int num)//左から何番目の分類に属するか
  {
    return num / 600;
  }
  
}


Measured memory_bytes: 22932