For problem statement at 1000-1999/1100-1199/1110-1119/1114/problemF.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1110-1119/1114/verifierF.go ends with All 100 tests passed can you fix the verifier? package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD = 1000000007

var primes = []int64{
	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,
}

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

var (
	tree_prod []int64
	tree_mask []uint64
	lazy_prod []int64
	lazy_mask []uint64
	mask_of   []uint64
	inv_p     []int64
	a         []int
)

func build(node, l, r int) {
	lazy_prod[node] = 1
	if l == r {
		tree_prod[node] = int64(a[l])
		tree_mask[node] = mask_of[a[l]]
		return
	}
	mid := l + (r-l)/2
	build(2*node, l, mid)
	build(2*node+1, mid+1, r)
	tree_prod[node] = (tree_prod[2*node] * tree_prod[2*node+1]) % MOD
	tree_mask[node] = tree_mask[2*node] | tree_mask[2*node+1]
}

func push(node, l, r int) {
	if lazy_prod[node] != 1 || lazy_mask[node] != 0 {
		mid := l + (r-l)/2

		tree_prod[2*node] = (tree_prod[2*node] * power(lazy_prod[node], int64(mid-l+1))) % MOD
		tree_mask[2*node] |= lazy_mask[node]
		lazy_prod[2*node] = (lazy_prod[2*node] * lazy_prod[node]) % MOD
		lazy_mask[2*node] |= lazy_mask[node]

		tree_prod[2*node+1] = (tree_prod[2*node+1] * power(lazy_prod[node], int64(r-mid))) % MOD
		tree_mask[2*node+1] |= lazy_mask[node]
		lazy_prod[2*node+1] = (lazy_prod[2*node+1] * lazy_prod[node]) % MOD
		lazy_mask[2*node+1] |= lazy_mask[node]

		lazy_prod[node] = 1
		lazy_mask[node] = 0
	}
}

func update(node, l, r, ql, qr int, x int64) {
	if ql <= l && r <= qr {
		tree_prod[node] = (tree_prod[node] * power(x, int64(r-l+1))) % MOD
		tree_mask[node] |= mask_of[x]
		lazy_prod[node] = (lazy_prod[node] * x) % MOD
		lazy_mask[node] |= mask_of[x]
		return
	}
	push(node, l, r)
	mid := l + (r-l)/2
	if ql <= mid {
		update(2*node, l, mid, ql, qr, x)
	}
	if qr > mid {
		update(2*node+1, mid+1, r, ql, qr, x)
	}
	tree_prod[node] = (tree_prod[2*node] * tree_prod[2*node+1]) % MOD
	tree_mask[node] = tree_mask[2*node] | tree_mask[2*node+1]
}

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

func readInt(r *bufio.Reader) int {
	res := 0
	started := false
	for {
		c, err := r.ReadByte()
		if err != nil {
			break
		}
		if c <= ' ' {
			if started {
				break
			}
			continue
		}
		res = res*10 + int(c-'0')
		started = true
	}
	return res
}

func readString(r *bufio.Reader) string {
	var b []byte
	for {
		c, err := r.ReadByte()
		if err != nil {
			break
		}
		if c <= ' ' {
			if len(b) > 0 {
				break
			}
			continue
		}
		b = append(b, c)
	}
	return string(b)
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 1<<20)
	writer := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer writer.Flush()

	n := readInt(reader)
	q := readInt(reader)

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

	mask_of = make([]uint64, 305)
	for i := 1; i <= 300; i++ {
		var m uint64 = 0
		for j, p := range primes {
			if i%int(p) == 0 {
				m |= (1 << j)
			}
		}
		mask_of[i] = m
	}

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

	tree_prod = make([]int64, 4*n+1)
	tree_mask = make([]uint64, 4*n+1)
	lazy_prod = make([]int64, 4*n+1)
	lazy_mask = make([]uint64, 4*n+1)

	build(1, 1, n)

	for i := 0; i < q; i++ {
		op := readString(reader)
		if op[0] == 'M' {
			ql := readInt(reader)
			qr := readInt(reader)
			x := readInt(reader)
			update(1, 1, n, ql, qr, int64(x))
		} else if op[0] == 'T' {
			ql := readInt(reader)
			qr := readInt(reader)
			p, m := query(1, 1, n, ql, qr)
			ans := p
			for j := 0; j < 62; j++ {
				if (m & (1 << j)) != 0 {
					ans = (ans * inv_p[j]) % MOD
				}
			}
			fmt.Fprintln(writer, ans)
		}
	}
}