#define ENABLE_DEBUG 1
// Kana's kitchen {{{
#include<bits/stdc++.h>
#define ALL(v) std::begin(v),std::end(v)
#define LOOP(k) for(lint ngtkana_is_a_genius=0; ngtkana_is_a_genius<(lint)k; ngtkana_is_a_genius++)
using lint=long long;
using ld=long double;
template<class T> using numr=std::numeric_limits<T>;
struct input_t {
    template<class T> operator T() {
        T t;
        std::cin>>t;
        return t;
    }
} input;
#ifdef NGTKANA
#include<debug.hpp>
#else
#define DEBUG(...)(void)0
#endif
/*}}}*/

template <class Monoid>
struct segtree
{
    using value_type = typename Monoid::value_type;

    std::vector<value_type> table;

    segtree()=default;
    segtree(segtree const&)=default;
    segtree(segtree&&)=default;
    segtree&operator=(segtree const&)=default;
    segtree&operator=(segtree&&)=default;

    segtree(std::size_t n, value_type init=Monoid::id())
        : table(2*n, init) {}

    void resize(std::size_t n) {
        assert(table.empty());
        table.resize(2*n);
    }

    std::size_t size() const { return table.size() / 2; }

    value_type fold(std::size_t l, std::size_t r) const {
        value_type fl = Monoid::id();
        value_type fr = Monoid::id();

        for(l+=size(),r+=size();l<r;l>>=1,r>>=1){
            if(l&1u) fl=Monoid::op(fl, table.at(l++));
            if(r&1u) fr=Monoid::op(fr, table.at(--r));
        }

        return Monoid::op(fl, fr);
    }

    void lazy_set(std::size_t i, value_type x) {
        table.at(i + size()) = x;
    }

    void set(std::size_t i, value_type x) {
        assert(i < size());
        i+=size();
        table.at(i) = x;
        for (i>>=1; i; i>>=1) {
            table.at(i) = Monoid::op(table.at(2*i), table.at(2*i+1));
        }
    }

    void add(std::size_t i, value_type x) { set(i, get(i) + x); }
    void sub(std::size_t i, value_type x) { set(i, get(i) - x); }
    void mul(std::size_t i, value_type x) { set(i, get(i) * x); }
    void div(std::size_t i, value_type x) { set(i, get(i) / x); }

    template <class F> void map(std::size_t i, F const& f) { set(i, f(get(i))); }

    void build() {
        for (std::size_t i=size()-1; i; i--) {
            table.at(i) = Monoid::op(table.at(2*i), table.at(2*i+1));
        }
    }

    value_type get(std::size_t i) const { return table.at(size() + i); }

    std::vector<value_type> to_vec() const {
        std::vector<value_type> ret(size());
        std::copy(table.begin()+size(), table.end(), ret.begin());
        return ret;
    }

};

template <class Value>
struct min_monoid_t {
    using value_type = Value;
    static value_type op(value_type l, value_type r) { return std::min(l, r); }
    static const value_type id() { return std::numeric_limits<Value>::max(); }
};

int main() {
    std::size_t n, q;
    std::cin >> n >> q;

    segtree<min_monoid_t<int>> seg(n, (1ll<<31)-1);
    DEBUG(n,q,seg.to_vec());

    while (q--) {
        int c;
        std::cin >> c;
        DEBUG(c);

        if (c==0) {
            std::size_t i;
            int x;
            std::cin >> i >> x;

            seg.set(i, x);
        }

        if (c==1) {
            std::size_t l, r;
            std::cin >> l >> r;
            r++;

            std::cout << seg.fold(l, r) << '\n';
        }
    }
}



Measured memory_bytes: 3584