```go
package main

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

const maxBits = 21

type Pair struct {
	Val int32
	Cnt int32
}

type Node struct {
	Pre    [maxBits]Pair
	PreLen int
	Suf    [maxBits]Pair
	SufLen int
	Ans    int64
}

var x int32

func merge(a, b Node) Node {
	if a.PreLen == 0 {
		return b
	}
	if b.PreLen == 0 {
		return a
	}
	var res Node

	copy(res.Pre[:], a.Pre[:a.PreLen])
	res.PreLen = a.PreLen
	lastVal := a.Pre[a.PreLen-1].Val
	for i := 0; i < b.PreLen; i++ {
		newVal := lastVal | b.Pre[i].Val
		if newVal == res.Pre[res.PreLen-1].Val {
			res.Pre[res.PreLen-1].Cnt += b.Pre[i].Cnt
		} else {
			res.Pre[res.PreLen] = Pair{newVal, b.Pre[i].Cnt}
			res.PreLen++
		}
	}

	copy(res.Suf[:], b.Suf[:b.SufLen])
	res.SufLen = b.SufLen
	lastVal = b.Suf[b.SufLen-1].Val
	for i := 0; i < a.SufLen; i++ {
		newVal := lastVal | a.Suf[i].Val
		if newVal == res.Suf[res.SufLen-1].Val {
			res.Suf[res.SufLen-1].Cnt += a.Suf[i].Cnt
		} else {
			res.Suf[res.SufLen] = Pair{newVal, a.Suf[i].Cnt}
			res.SufLen++
		}
	}

	res.Ans = a.Ans + b.Ans
	for i := 0; i < a.SufLen; i++ {
		av := a.Suf[i].Val
		ac := a.Suf[i].Cnt
		for j := 0; j < b.PreLen; j++ {
			if (av | b.Pre[j].Val) >= x {
				res.Ans += int64(ac) * int64(b.Pre[j].Cnt)
			}
		}
	}
	return res
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1<<20), 1<<20)
	scanner.Split(bufio.ScanWords)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	readInt := func() int {
		scanner.Scan()
		v, _ := strconv.Atoi(scanner.Text())
		return v
	}

	n := readInt()
	m := readInt()
	x = int32(readInt())

	arr := make([]int32, n)
	for i := 0; i < n; i++ {
		arr[i] = int32(readInt())
	}

	N := 1
	for N < n {
		N <<= 1
	}
	tree := make([]Node, 2*N)

	for i := 0; i < n; i++ {
		v := arr[i]
		idx := N + i
		tree[idx].Pre[0] = Pair{v, 1}
		tree[idx].PreLen = 1
		tree[idx].Suf[0] = Pair{v, 1}
		tree[idx].SufLen = 1
		if v >= x {
			tree[idx].Ans = 1
		}
	}

	for i := N - 1; i >= 0; i-- {
		tree[i] = merge(tree[2*i], tree[2*i+1])
	}

	for q := 0; q < m; q++ {
		typ := readInt()
		if typ == 1 {
			pos := readInt() - 1
			val := int32(readInt())
			idx := N + pos
			tree[idx].Pre[0] = Pair{val, 1}
			tree[idx].PreLen = 1
			tree[idx].Suf[0] = Pair{val, 1}
			tree[idx].SufLen = 1
			if val >= x {
				tree[idx].Ans = 1
			} else {
				tree[idx].Ans = 0
			}
			for idx > 0 {
				idx >>= 1
				tree[idx] = merge(tree[2*idx], tree[2*idx+1])
			}
		} else {
			l := readInt() - 1
			r := readInt() - 1
			l += N
			r += N
			var leftRes, rightRes Node
			for l <= r {
				if l&1 == 1 {
					leftRes = merge(leftRes, tree[l])
					l++
				}
				if r&1 == 0 {
					rightRes = merge(tree[r], rightRes)
					r--
				}
				l >>= 1
				r >>= 1
			}
			res := merge(leftRes, rightRes)
			writer.WriteString(strconv.FormatInt(res.Ans, 10))
			writer.WriteByte('\n')
		}
	}
}
```