using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        var nq = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        var n = nq[0];
        var q = nq[1];
        var tree = new SegmentTree<int>(Enumerable.Repeat(int.MaxValue, n).ToArray(), (x,y) => Math.Min(x, y), int.MaxValue);
        var results = new List<int>();
        for(int i = 0; i < q; i++)
        {
            var inputs = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

            if(inputs[0] == 0)
            {
                tree.Update(inputs[1], inputs[2]);
            }
            else if(inputs[0] == 1)
            {
                var result = tree.Execute(inputs[1], inputs[2]+1);
                //Console.WriteLine(result);
                results.Add(result);
            }
        }

        foreach (var item in results) Console.WriteLine(item);
    }
}


public class SegmentTree<T>
{
    public int N { get; private set; }
    private T[] _tree;
    private readonly Func<T, T, T> _updateMethod;
    private readonly T _initValue;

    /// <summary>
    /// セグメント木の初期化
    /// </summary>
    /// <param name="items">要素達</param>
    /// <param name="updateMethod">更新する方法</param>
    /// <param name="initValue">セグメント木のノードの初期値</param>
    public SegmentTree(IEnumerable<T> items, Func<T, T, T> updateMethod, T initValue) {
        T[] array = items.ToArray();
        _updateMethod = updateMethod;
        _initValue = initValue;

        // セグ木の最下段は２の冪乗にする
        N = 1;
        while (N < array.Length) N *= 2;

        _tree = Enumerable.Repeat(initValue, 2 * N - 1).ToArray();

        // 最下段に要素達を入れた後、下の段から更新していく
        for (int i = 0; i < array.Length; i++) _tree[N + i - 1] = array[i];
        for (int i = N - 2; i >= 0; i--) _tree[i] = _updateMethod(_tree[2 * i + 1], _tree[2 * i + 2]);
    }

    /// <summary>
    /// 更新する
    /// </summary>
    /// <param name="i">更新したい値のインデックス</param>
    /// <param name="x">更新する値</param>
    public void Update(int i, T x)
    {
        // 更新したい要素のセグ木上でのインデックスを取得
        i = N + i - 1;

        // 値を更新した後に、どんどん親を更新していく
        _tree[i] = x;
        while(i > 0)
        {
            i = (i - 1) / 2;
            _tree[i] = _updateMethod(_tree[2 * i + 1], _tree[2 * i + 2]);
        }

        /*Console.Write("Tree : ");
        foreach(var item in _tree)
        {
            Console.Write(" " + item.ToString());
        }
        Console.WriteLine();*/
    }

    /// <summary>
    /// 区間内の目的の値を取得する
    /// </summary>
    /// <param name="a">要求区間[a, b)</param>
    /// <param name="b">要求区間[a, b)</param>
    /// <returns></returns>
    public T Execute(int a, int b)
    {
        //if (_tree.Length == 1) return _updateMethod(_tree[0], _initValue);
        return Execute(a, b, 0, 0, N);
    }

    private T Execute(int a, int b, int k, int l, int r)
    {
        // 要求区間[a, b)に対して対象区間[l, r)を求める
        // 今いるノードのインデックスがk

        // 要求区間と対象区間が交わらない
        if (r <= a || b <= l) return _initValue;

        // 要求区間が対象区間を完全に被覆
        if (a <= l && r <= b) return _tree[k];

        // 要求区間が対象区間の一部を被覆しているので、子について探索を行う
        // 新しい対象区間は、現在の対象区間を半分に割ったもの
        var vl = Execute(a, b, 2 * k + 1, l, (l + r) / 2);
        var vr = Execute(a, b, 2 * k + 2, (l + r) / 2, r);
        return _updateMethod(vl, vr);
    }
}



Measured memory_bytes: 27560