//#define NDEBUG
#define _CRT_SECURE_NO_WARNINGS
#include <cassert>
#include <functional>
#include <utility>
#include <vector>

template <typename ValueMonoid, typename OperatorMonoid> class LazySegmentTree {
public:
	using value_type = ValueMonoid;
	using reference = value_type &;
	using const_reference = const value_type &;
	using operator_type = OperatorMonoid;

private:
	using operator_constref = const operator_type &;
	using container_type = std::vector<std::pair<value_type, operator_type>>;

public:
	using size_type = typename container_type::size_type;

private:
	using F = std::function<value_type(const_reference, const_reference)>;
	using G = std::function<operator_type(operator_constref, operator_constref)>;
	using H = std::function<value_type(const_reference, operator_constref)>;
	const F f;
	const G g;
	const H h;
	const value_type v_neutral;
	const operator_type o_neutral;
	size_type height, size_;
	container_type tree;
	static size_type getheight(const size_type size) {
		size_type ret = 0;
		while ((size_type)1 << ret < size)
			++ret;
		return ret;
	}
	value_type reflect(const size_type index) {
		return h(tree[index].first, tree[index].second);
	}
	void recalc(const size_type index) {
		tree[index].first = f(reflect(index << 1), reflect(index << 1 | 1));
	}
	void assign(const size_type index, operator_constref data) {
		tree[index].second = g(tree[index].second, data);
	}
	void push(const size_type index) {
		assign(index << 1, tree[index].second);
		assign(index << 1 | 1, tree[index].second);
		tree[index].second = o_neutral;
	}
	void propagate(const size_type index) {
		for (size_type i = height; i; --i)
			push(index >> i);
	}
	void thrust(const size_type index) {
		tree[index].first = reflect(index);
		push(index);
	}
	void evaluate(const size_type index) {
		for (size_type i = height; i; --i)
			thrust(index >> i);
	}
	void build(size_type index) {
		while (index >>= 1)
			recalc(index);
	}

public:
	LazySegmentTree(
		const size_type size, const F &value_addition = std::plus<value_type>(),
		const_reference value_neutral = value_type(),
		const G &operator_multiplication = std::multiplies<operator_type>(),
		operator_constref operator_neutral = operator_type(),
		const H &mutual_multiplication =
		[](const_reference l, operator_constref r) { return l * r; })
		: f(value_addition), v_neutral(value_neutral), g(operator_multiplication),
		o_neutral(operator_neutral), h(mutual_multiplication),
		height(getheight(size)), size_((size_type)1 << height),
		tree(size_ << 1, std::make_pair(v_neutral, o_neutral)) {}
	void update(size_type begin, size_type end, operator_constref data) {
		assert(begin <= end);
		assert(begin <= size_);
		assert(end <= size_);
		begin += size_;
		end += size_;
		propagate(begin);
		propagate(end - 1);
		for (size_type left = begin, right = end; left < right;
			left >>= 1, right >>= 1) {
			if (left & 1)
				assign(left++, data);
			if (right & 1)
				assign(right - 1, data);
		}
		build(begin);
		build(end - 1);
	}
	void update(size_type index,
		const std::function<value_type(const_reference)> &e) {
		assert(index < size_);
		index += size_;
		propagate(index);
		tree[index].first = e(reflect(index));
		tree[index].second = o_neutral;
		build(index);
	}
	void update(const size_type index, const_reference data) {
		assert(index < size_);
		update(index, [&data](const_reference d) { return data; });
	}
	value_type range(size_type begin, size_type end) {
		assert(begin <= end);
		assert(begin <= size_);
		assert(end <= size_);
		begin += size_;
		end += size_;
		evaluate(begin);
		evaluate(end - 1);
		value_type retL = v_neutral, retR = v_neutral;
		for (; begin < end; begin >>= 1, end >>= 1) {
			if (begin & 1)
				retL = f(retL, reflect(begin++));
			if (end & 1)
				retR = f(reflect(end - 1), retR);
		}
		return f(retL, retR);
	}
	size_type search(const std::function<bool(const_reference)> &b) {
		if (!b(reflect(1)))
			return size_;
		value_type acc = v_neutral;
		size_type i = 1;
		while (i < size) {
			thrust(i);
			if (!b(f(acc, reflect(i <<= 1))))
				acc = f(acc, reflect(i++));
		}
		return i - size_;
	}
	size_type size() const { return size_; }
};

#include <algorithm>
#include <limits>

template<typename T>
struct Assign {
	T a;
	bool f;
	Assign():f(1){}
	Assign(const T &x):a(x),f(0){}
	Assign operator*(const Assign &o)const {
		return o.f ? *this : o;
	}
};
template<typename T>
struct Add {
	T a;
	Add(const T &x=T(0)):a(x){}
	Add operator*(const Add &o)const {
		return Add(a + o.a);
	}
};
template<typename T>
struct Mini {
	T a;
	Mini(const T &x=std::numeric_limits<T>::max()):a(x){}
	Mini operator+(const Mini &o)const {
		return Mini(std::min(a, o.a));
	}
	Mini operator*(const Assign<T> &o)const {
		return o.f ? *this : Mini(o.a);
	}
	Mini operator*(const Add<T> &o)const {
		return Mini(a + o.a);
	}
};

#include <cstdint>
#include <iostream>

int main(void) {
	using int32 = std::int_fast32_t;
	using uint32 = std::uint_fast32_t;
	using M = Mini<int32>;
	using A = Add<int32>;
	uint32 n, q;
	std::cin >> n >> q;
	LazySegmentTree<M, A> T(n);
	for (uint32 i = 0;i < T.size();++i) {
		T.update(i, M(0));
	}
	while (q--) {
		uint32 c, s, t;
		int32 x;
		std::cin >> c >> s >> t;
		if (c) {
			std::cout << T.range(s, t + 1).a << std::endl;
		}
		else {
			std::cin >> x;
			T.update(s, t + 1, A(x));
		}
	}
	return 0;
}


Measured memory_bytes: 7056