package main

import (
	"bufio"
	"os"
	"strconv"
)

type Node struct {
	len        int
	pref, suff int
	first      int64
	last       int64
	ans        int64
}

var (
	reader = bufio.NewReaderSize(os.Stdin, 1<<20)
	writer = bufio.NewWriterSize(os.Stdout, 1<<20)
	n, q   int
	arr    []int64
	tree   []Node
)

func nextInt64() int64 {
	var sign int64 = 1
	var val int64 = 0
	c, _ := reader.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = reader.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = reader.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int64(c-'0')
		c, _ = reader.ReadByte()
	}
	return val * sign
}

func merge(a, b Node) Node {
	if a.len == 0 {
		return b
	}
	if b.len == 0 {
		return a
	}
	var res Node
	res.len = a.len + b.len
	res.first = a.first
	res.last = b.last
	res.pref = a.pref
	if a.pref == a.len && a.last <= b.first {
		res.pref = a.len + b.pref
	}
	res.suff = b.suff
	if b.suff == b.len && a.last <= b.first {
		res.suff = b.len + a.suff
	}
	res.ans = a.ans + b.ans
	if a.last <= b.first {
		res.ans += int64(a.suff) * int64(b.pref)
	}
	return res
}

func build(idx, l, r int) {
	if l == r {
		val := arr[l]
		tree[idx] = Node{len: 1, pref: 1, suff: 1, first: val, last: val, ans: 1}
		return
	}
	m := (l + r) >> 1
	build(idx<<1, l, m)
	build(idx<<1|1, m+1, r)
	tree[idx] = merge(tree[idx<<1], tree[idx<<1|1])
}

func update(idx, l, r, pos int, val int64) {
	if l == r {
		arr[l] = val
		tree[idx] = Node{len: 1, pref: 1, suff: 1, first: val, last: val, ans: 1}
		return
	}
	m := (l + r) >> 1
	if pos <= m {
		update(idx<<1, l, m, pos, val)
	} else {
		update(idx<<1|1, m+1, r, pos, val)
	}
	tree[idx] = merge(tree[idx<<1], tree[idx<<1|1])
}

func query(idx, l, r, ql, qr int) Node {
	if ql <= l && r <= qr {
		return tree[idx]
	}
	m := (l + r) >> 1
	if qr <= m {
		return query(idx<<1, l, m, ql, qr)
	}
	if ql > m {
		return query(idx<<1|1, m+1, r, ql, qr)
	}
	left := query(idx<<1, l, m, ql, qr)
	right := query(idx<<1|1, m+1, r, ql, qr)
	return merge(left, right)
}

func main() {
	n64 := nextInt64()
	q64 := nextInt64()
	n = int(n64)
	q = int(q64)
	arr = make([]int64, n)
	for i := 0; i < n; i++ {
		arr[i] = nextInt64()
	}
	tree = make([]Node, 4*n)
	build(1, 0, n-1)
	for i := 0; i < q; i++ {
		t := int(nextInt64())
		if t == 1 {
			x := int(nextInt64()) - 1
			y := nextInt64()
			update(1, 0, n-1, x, y)
		} else {
			l := int(nextInt64()) - 1
			r := int(nextInt64()) - 1
			res := query(1, 0, n-1, l, r)
			writer.WriteString(strconv.FormatInt(res.ans, 10))
			writer.WriteByte('\n')
		}
	}
	writer.Flush()
}