package main

import (
	"fmt"
	"io"
	"os"
)

const MOD = 1000000007

var (
	prod      []int64
	mask      []uint64
	lazyProd  []int64
	lazyMask  []uint64
	a         []int
	maskOf    []uint64
	primes    = []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293}
	mult      []int64
	buffer    []byte
	pos       int
)

func nextInt() int {
	for pos < len(buffer) && buffer[pos] <= ' ' {
		pos++
	}
	res := 0
	for pos < len(buffer) && buffer[pos] > ' ' {
		res = res*10 + int(buffer[pos]-'0')
		pos++
	}
	return res
}

func nextString() string {
	for pos < len(buffer) && buffer[pos] <= ' ' {
		pos++
	}
	start := pos
	for pos < len(buffer) && buffer[pos] > ' ' {
		pos++
	}
	return string(buffer[start:pos])
}

func power(base int64, exp int) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp&1 == 1 {
			res = res * base % MOD
		}
		base = base * base % MOD
		exp >>= 1
	}
	return res
}

func build(node, l, r int) {
	lazyProd[node] = 1
	if l == r {
		prod[node] = int64(a[l])
		mask[node] = maskOf[a[l]]
		return
	}
	mid := (l + r) / 2
	build(node*2, l, mid)
	build(node*2+1, mid+1, r)
	prod[node] = prod[node*2] * prod[node*2+1] % MOD
	mask[node] = mask[node*2] | mask[node*2+1]
}

func push(node, l, r int) {
	lp := lazyProd[node]
	lm := lazyMask[node]
	if lp != 1 || lm != 0 {
		mid := (l + r) / 2

		if lp != 1 {
			prod[node*2] = prod[node*2] * power(lp, mid-l+1) % MOD
			lazyProd[node*2] = lazyProd[node*2] * lp % MOD
			prod[node*2+1] = prod[node*2+1] * power(lp, r-mid) % MOD
			lazyProd[node*2+1] = lazyProd[node*2+1] * lp % MOD
		}

		if lm != 0 {
			mask[node*2] |= lm
			lazyMask[node*2] |= lm
			mask[node*2+1] |= lm
			lazyMask[node*2+1] |= lm
		}

		lazyProd[node] = 1
		lazyMask[node] = 0
	}
}

func update(node, l, r, ql, qr int, val int64, m uint64) {
	if ql <= l && r <= qr {
		prod[node] = prod[node] * power(val, r-l+1) % MOD
		mask[node] |= m
		lazyProd[node] = lazyProd[node] * val % MOD
		lazyMask[node] |= m
		return
	}
	push(node, l, r)
	mid := (l + r) / 2
	if ql <= mid {
		update(node*2, l, mid, ql, qr, val, m)
	}
	if qr > mid {
		update(node*2+1, mid+1, r, ql, qr, val, m)
	}
	prod[node] = prod[node*2] * prod[node*2+1] % MOD
	mask[node] = mask[node*2] | mask[node*2+1]
}

func query(node, l, r, ql, qr int) (int64, uint64) {
	if ql <= l && r <= qr {
		return prod[node], mask[node]
	}
	push(node, l, r)
	mid := (l + r) / 2
	p := int64(1)
	m := uint64(0)
	if ql <= mid {
		p1, m1 := query(node*2, l, mid, ql, qr)
		p = p * p1 % MOD
		m |= m1
	}
	if qr > mid {
		p2, m2 := query(node*2+1, mid+1, r, ql, qr)
		p = p * p2 % MOD
		m |= m2
	}
	return p, m
}

func main() {
	buffer, _ = io.ReadAll(os.Stdin)

	if len(buffer) == 0 {
		return
	}

	n := nextInt()
	q := nextInt()

	a = make([]int, n+1)
	for i := 1; i <= n; i++ {
		a[i] = nextInt()
	}

	maskOf = make([]uint64, 301)
	for i := 1; i <= 300; i++ {
		for j, p := range primes {
			if i%p == 0 {
				maskOf[i] |= 1 << j
			}
		}
	}

	mult = make([]int64, len(primes))
	for i, p := range primes {
		mult[i] = int64(p-1) * power(int64(p), MOD-2) % MOD
	}

	prod = make([]int64, 4*n+4)
	mask = make([]uint64, 4*n+4)
	lazyProd = make([]int64, 4*n+4)
	lazyMask = make([]uint64, 4*n+4)

	build(1, 1, n)

	out := make([]byte, 0, 1<<20)

	for i := 0; i < q; i++ {
		op := nextString()
		if op == "MULTIPLY" {
			l := nextInt()
			r := nextInt()
			x := nextInt()
			update(1, 1, n, l, r, int64(x), maskOf[x])
		} else {
			l := nextInt()
			r := nextInt()
			p, m := query(1, 1, n, l, r)
			ans := p
			for j := 0; j < len(primes); j++ {
				if (m>>j)&1 == 1 {
					ans = ans * mult[j] % MOD
				}
			}
			out = append(out, fmt.Sprintf("%d\n", ans)...)
		}
	}
	os.Stdout.Write(out)
}