import math

n, q = list(map(int, input().split()))

l = 1 << math.ceil(math.log(n, 2))

inf = 2**31-1

a = [inf]*(2*l-1)



def set_value(i, num):

    k = l-1+i

    a[k] = num

    while k > 0:

        k = (k-1)//2

        num = min(a[2*k+1], a[2*k+2])

        if a[k] == num:

            break

        else:

            a[k] = num

            

def get_minimum(x, y, k=0, l=0, r=l-1):

    if x == l and r == y:

        return a[k]

    elif not l <= x <= y <= r:

        return inf

    mid = (l+r)//2

    left_value = get_minimum(x, min(mid, y), 2*k+1, l, mid)

    right_value = get_minimum(max(mid+1, x), y, 2*k+2, mid+1, r)

    return min(left_value, right_value)

    

ans = []

for _ in [None]*q:

    c, x, y = list(map(int, input().split()))

    if c == 0:

        set_value(x, y)

    else:

        ans.append(get_minimum(x, y))

print(("\n".join([str(n) for n in ans])))
import math





class SegmentTree:

    __slots__ = ["elem_size", "tree_size", "tree"]



    def __init__(self, a: list, default: int):

        real_size = len(a)

        self.elem_size = 1 << math.ceil(math.log2(real_size))

        self.tree_size = 2 * self.elem_size

        self.tree = [default]*self.elem_size + a + [default]*(self.elem_size - real_size)

        self.init_tree()



    def init_tree(self):

        tree = self.tree

        for i in range(self.elem_size-1, 0, -1):

            left, right = tree[i << 1], tree[(i << 1)+1]

            # ===== ??????????????´???????????? =====

            tree[i] = left if left < right else right



    def get_range_index(self, x: int, y: int, k: int = 1, l_end: int = 0, r_end: int = None):

        '''[x, y), tree[k], [l_end, r_end)'''

        if r_end is None:

            r_end = self.elem_size



        if l_end == x and y == r_end:

            return [k]



        mid = (l_end + r_end) // 2

        left_y = y if y < mid else mid

        right_x = x if x > mid else mid



        left = self.get_range_index(x, left_y, k << 1, l_end, mid) if x < left_y else []

        right = self.get_range_index(right_x, y, (k << 1)+1, mid, r_end) if right_x < y else []

        return left + right



    def get_value(self, x: int, y: int):

        tree = self.tree

        index_list = self.get_range_index(x, y)



        # ===== ??????????????´???????????? =====

        return min(tree[n] for n in index_list)



    def update_tree(self, k: int):

        tree = self.tree



        while k > 1:

            k >>= 1

            left, right = tree[k << 1], tree[(k << 1)+1]

            # ===== ??????????????´???????????? =====

            tree[k] = left if left < right else right



    def set_value(self, i: int, value: int, op: str):

        k = self.elem_size + i

        if op == "=":

            self.tree[k] = value

        elif op == "+":

            self.tree[k] += value

        self.update_tree(k)





n, q = list(map(int, input().split()))

rmq = SegmentTree([2**31-1]*n, 2**31-1)

ans = []

for _ in [0]*q:

    c, x, y = list(map(int, input().split()))

    if c == 0:

        rmq.set_value(x, y, "=")

    else:

        ans.append(rmq.get_value(x, y+1))

print(("\n".join([str(n) for n in ans])))
import math

n, q = list(map(int, input().split()))
l = 1 << math.ceil(math.log(n, 2))
inf = 2**31 - 1
a = [inf] * (2 * l - 1)


def set_value(i, num):
    k = l - 1 + i
    a[k] = num
    while k > 0:
        k = (k - 1) // 2
        num = min(a[2 * k + 1], a[2 * k + 2])
        if a[k] == num:
            break
        else:
            a[k] = num


def get_minimum(x, y, k=0, l=0, r=l - 1):
    if x == l and r == y:
        return a[k]
    elif not l <= x <= y <= r:
        return inf
    mid = (l + r) // 2
    left_value = get_minimum(x, min(mid, y), 2 * k + 1, l, mid)
    right_value = get_minimum(max(mid + 1, x), y, 2 * k + 2, mid + 1, r)
    return min(left_value, right_value)


ans = []
for _ in [None] * q:
    c, x, y = list(map(int, input().split()))
    if c == 0:
        set_value(x, y)
    else:
        ans.append(get_minimum(x, y))
print(("\n".join([str(n) for n in ans])))

import math


class SegmentTree:
    __slots__ = ["elem_size", "tree_size", "tree"]

    def __init__(self, a: list, default: int):
        real_size = len(a)
        self.elem_size = 1 << math.ceil(math.log2(real_size))
        self.tree_size = 2 * self.elem_size
        self.tree = (
            [default] * self.elem_size + a + [default] * (self.elem_size - real_size)
        )
        self.init_tree()

    def init_tree(self):
        tree = self.tree
        for i in range(self.elem_size - 1, 0, -1):
            left, right = tree[i << 1], tree[(i << 1) + 1]
            # ===== ??????????????´???????????? =====
            tree[i] = left if left < right else right

    def get_range_index(
        self, x: int, y: int, k: int = 1, l_end: int = 0, r_end: int = None
    ):
        """[x, y), tree[k], [l_end, r_end)"""
        if r_end is None:
            r_end = self.elem_size
        if l_end == x and y == r_end:
            return [k]
        mid = (l_end + r_end) // 2
        left_y = y if y < mid else mid
        right_x = x if x > mid else mid
        left = self.get_range_index(x, left_y, k << 1, l_end, mid) if x < left_y else []
        right = (
            self.get_range_index(right_x, y, (k << 1) + 1, mid, r_end)
            if right_x < y
            else []
        )
        return left + right

    def get_value(self, x: int, y: int):
        tree = self.tree
        index_list = self.get_range_index(x, y)
        # ===== ??????????????´???????????? =====
        return min(tree[n] for n in index_list)

    def update_tree(self, k: int):
        tree = self.tree
        while k > 1:
            k >>= 1
            left, right = tree[k << 1], tree[(k << 1) + 1]
            # ===== ??????????????´???????????? =====
            tree[k] = left if left < right else right

    def set_value(self, i: int, value: int, op: str):
        k = self.elem_size + i
        if op == "=":
            self.tree[k] = value
        elif op == "+":
            self.tree[k] += value
        self.update_tree(k)


n, q = list(map(int, input().split()))
rmq = SegmentTree([2**31 - 1] * n, 2**31 - 1)
ans = []
for _ in [0] * q:
    c, x, y = list(map(int, input().split()))
    if c == 0:
        rmq.set_value(x, y, "=")
    else:
        ans.append(rmq.get_value(x, y + 1))
print(("\n".join([str(n) for n in ans])))

-n, q = list(map(int, input().split())) -l = 1 << math.ceil(math.log(n, 2)) -inf = 2**31 - 1 -a = [inf] * (2 * l - 1) + +class SegmentTree: +    __slots__ = ["elem_size", "tree_size", "tree"] + +    def __init__(self, a: list, default: int): +        real_size = len(a) +        self.elem_size = 1 << math.ceil(math.log2(real_size)) +        self.tree_size = 2 * self.elem_size +        self.tree = ( +            [default] * self.elem_size + a + [default] * (self.elem_size - real_size) +        ) +        self.init_tree() + +    def init_tree(self): +        tree = self.tree +        for i in range(self.elem_size - 1, 0, -1): +            left, right = tree[i << 1], tree[(i << 1) + 1] +            # ===== ??????????????´???????????? ===== +            tree[i] = left if left < right else right + +    def get_range_index( +        self, x: int, y: int, k: int = 1, l_end: int = 0, r_end: int = None +    ): +        """[x, y), tree[k], [l_end, r_end)""" +        if r_end is None: +            r_end = self.elem_size +        if l_end == x and y == r_end: +            return [k] +        mid = (l_end + r_end) // 2 +        left_y = y if y < mid else mid +        right_x = x if x > mid else mid +        left = self.get_range_index(x, left_y, k << 1, l_end, mid) if x < left_y else [] +        right = ( +            self.get_range_index(right_x, y, (k << 1) + 1, mid, r_end) +            if right_x < y +            else [] +        ) +        return left + right + +    def get_value(self, x: int, y: int): +        tree = self.tree +        index_list = self.get_range_index(x, y) +        # ===== ??????????????´???????????? ===== +        return min(tree[n] for n in index_list) + +    def update_tree(self, k: int): +        tree = self.tree +        while k > 1: +            k >>= 1 +            left, right = tree[k << 1], tree[(k << 1) + 1] +            # ===== ??????????????´???????????? ===== +            tree[k] = left if left < right else right + +    def set_value(self, i: int, value: int, op: str): +        k = self.elem_size + i +        if op == "=": +            self.tree[k] = value +        elif op == "+": +            self.tree[k] += value +        self.update_tree(k) -def set_value(i, num): -    k = l - 1 + i -    a[k] = num -    while k > 0: -        k = (k - 1) // 2 -        num = min(a[2 * k + 1], a[2 * k + 2]) -        if a[k] == num: -            break -        else: -            a[k] = num - - -def get_minimum(x, y, k=0, l=0, r=l - 1): -    if x == l and r == y: -        return a[k] -    elif not l <= x <= y <= r: -        return inf -    mid = (l + r) // 2 -    left_value = get_minimum(x, min(mid, y), 2 * k + 1, l, mid) -    right_value = get_minimum(max(mid + 1, x), y, 2 * k + 2, mid + 1, r) -    return min(left_value, right_value) - - +n, q = list(map(int, input().split())) +rmq = SegmentTree([2**31 - 1] * n, 2**31 - 1) -for _ in [None] * q: +for _ in [0] * q: -        set_value(x, y) +        rmq.set_value(x, y, "=") -        ans.append(get_minimum(x, y)) +        ans.append(rmq.get_value(x, y + 1))