#include <iostream>
#include <algorithm>
#include <array>
#include <cstdint>
#include <climits>
#include <functional>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <type_traits>
#include <utility>
#include <vector>

using int32 = std::int_fast32_t;
using int64 = std::int_fast64_t;
using uint32 = std::uint_fast32_t;
using uint64 = std::uint_fast64_t;
using intl32 = std::int_least32_t;
using intl64 = std::int_least64_t;
using uintl32 = std::uint_least32_t;
using uintl64 = std::uint_least64_t;




struct ADD {
	int64 e;
	ADD(int64 x = 0) { e = x; }
	ADD operator*(const ADD &other) {
		return ADD(e + other.e);
	}
};
struct MIN {
	int64 e;
	MIN(int64 x = 2147483647) { e = x; }
	MIN operator~() {
		return *this;
	}
	MIN operator+(const MIN &other) {
		if (e < other.e) return *this;
		return other;
	};
	MIN operator*(const MIN &other) {
		return other;
	}
	MIN operator*(const ADD &other) {
		return MIN(e + other.e);
	}
};
struct MAX {
	int64 e;
	MAX(int64 x = std::numeric_limits<int64>::min()) { e = x; }
	MAX operator~() {
		return *this;
	}
	MAX operator+(const MAX &other) {
		if (e > other.e) return *this;
		return other;
	};
	MAX operator*(const MAX &other) {
		return other;
	}
	MAX operator*(const ADD &other) {
		return MAX(e + other.e);
	}
};
struct SUM {
	int64 e;
	int64 s;
	SUM(int64 x = 0, int64 y = 1) { e = x;s = y; }
	SUM operator~() {
		return *this;
	}
	SUM operator+(const SUM &other) {
		return  SUM(e + other.e, s + other.s);
	};
	SUM operator*(const SUM &other) {
		return SUM(s*other.e, s);
	}
	SUM operator*(const ADD &other) {
		return SUM(e + s*other.e, s);
	}
};

template<typename Monoid, typename Operand>
class lazy_segment_tree {
	struct node {
		Monoid element;
		Operand lazy;
		bool h;
	};
	std::vector<node> tree;
	std::uint_fast32_t size, height;
	void assign(std::uint_fast32_t index,const Operand &data) {
		if (tree[index].h) tree[index].lazy = tree[index].lazy*data;
		else { tree[index].lazy = data;tree[index].h = 1; }
	}
	Monoid reflect(std::uint_fast32_t index) {
		if (tree[index].h) return tree[index].element*tree[index].lazy;
		return tree[index].element;
	}
	void recalc(std::uint_fast32_t index) {
		tree[index].element = reflect(index << 1) + reflect(index << 1 | 1);
	}
	void push(std::uint_fast32_t index) {
		if (!tree[index].h) return;
		assign(index << 1, tree[index].lazy);
		assign(index << 1 | 1, tree[index].lazy);
		tree[index].element = tree[index].element*tree[index].lazy;
		tree[index].h = 0;
	}
	void propagate(std::uint_fast32_t index) {
		std::uint_fast32_t i = height;
		do { push(index >> i); } while (--i);
	}
	void build(std::uint_fast32_t index) {
		while (index >>= 1)recalc(index);
	}
public:
	void update(std::uint_fast32_t begin, std::uint_fast32_t end, const Operand &data) {
		begin += size;
		end += size - 1;
		propagate(begin);
		propagate(end);
		for (std::uint_fast32_t left = begin, right = end + 1;left < right;left >>= 1, right >>= 1) {
			if (left & 1) assign(left++, data);
			if (right & 1) assign(--right, data);
		}
		build(begin);
		build(end);
	}
	Monoid range(std::uint_fast32_t begin, std::uint_fast32_t end) {
		begin += size;end += size;
		propagate(begin);
		propagate(end - 1);
		Monoid retL, retR;
		for (;begin < end;begin >>= 1, end >>= 1) {
			if (begin & 1) retL = retL + reflect(begin++);
			if (end & 1) retR = reflect(--end) + retR;
		}
		return retL + retR;
	}
	//trueを返す最小のインデックス
	std::uint_fast32_t binary_search(std::function<bool(Monoid)> bound) {
		if (!bound(reflect(1))) return size;
		Monoid ret;
		std::uint_fast32_t i = 1;
		while (i < size) {
			push(i);
			if (!bound(ret + reflect(i <<= 1))) ret = ret + reflect(i++);
		}
		return i - size;
	}
	lazy_segment_tree(std::uint_fast32_t length) :height(static_cast<std::uint_fast32_t>(0)) {
		--length;
		length |= length >> 1;
		length |= length >> 2;
		length |= length >> 4;
		length |= length >> 8;
		length |= length >> 16;
		if (!length) length = 1;
		height = __builtin_popcount(length);
		size = length + 1;
		tree = std::vector<node>(size << 1);
		initialize();
	}
	void update(std::uint_fast32_t index, std::function<Monoid(Monoid)> f) {
		index += size;
		propagate(index);
		if (tree[index].h) {
			tree[index].element = tree[index].element*tree[index].lazy;
			tree[index].h = 0;
		}
		tree[index].element = f(tree[index].element);
		build(index);
	}
	void initialize(void) {
		std::uint_fast32_t const s = size;
		std::uint_fast32_t i = s << 1;
		while (--i >= s) { tree[i].element = Monoid();tree[i].h = 0; }
		do { recalc(i);tree[i].h = 0; } while (--i);
	}
};

int main(void) {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	uint32 n, q;
	std::cin >> n >> q;
	lazy_segment_tree<MIN, MIN> T(n);
	uint32 c, s, t;
	std::function<MIN(MIN, uint32)> F = [](const MIN &m, uint32 x)->MIN {
		return MIN((int64)x);
	};
	do {
		std::cin >> c >> s >> t;
		if (c) {
			std::cout << T.range(s, t + 1).e << "\n";
		}
		else {
			T.update(s, std::bind(F, std::placeholders::_1, t));
		}
	} while (--q);
	return 0;
}



Measured memory_bytes: 8872