```go
package main

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

func readInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	b := scanner.Bytes()
	res := 0
	for _, v := range b {
		if v >= '0' && v <= '9' {
			res = res*10 + int(v-'0')
		}
	}
	return res
}

func readInt64(scanner *bufio.Scanner) int64 {
	scanner.Scan()
	b := scanner.Bytes()
	var res int64 = 0
	for _, v := range b {
		if v >= '0' && v <= '9' {
			res = res*10 + int64(v-'0')
		}
	}
	return res
}

func power(base, exp, mod 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
}

func floorSum(n, m, a, b int64) int64 {
	var ans int64 = 0
	if a >= m {
		ans += (n - 1) * n / 2 * (a / m)
		a %= m
	}
	if b >= m {
		ans += n * (b / m)
		b %= m
	}
	yMax := (a*n + b) / m
	if yMax == 0 {
		return ans
	}
	xMax := yMax*m - b
	ans += (n - (xMax+a-1)/a) * yMax
	ans += floorSum(yMax, a, m, (a-xMax%a)%a)
	return ans
}

var inv2, inv6, inv12, inv30 int64

func getT(k int64, M int64) (int64, int64, int64, int64, int64) {
	kMod := k % M
	kMinus1 := (k - 1) % M

	T1 := kMod * kMinus1 % M * inv2 % M

	T2 := kMod * kMinus1 % M * (2*kMod - 1) % M * inv6 % M
	if T2 < 0 {
		T2 += M
	}

	T3 := T1 * T1 % M

	poly4 := (3*kMod*kMod - 3*kMod - 1) % M
	if poly4 < 0 {
		poly4 += M
	}
	T4 := kMod * kMinus1 % M * (2*kMod - 1) % M * poly4 % M * inv30 % M
	if T4 < 0 {
		T4 += M
	}

	poly5 := (2*kMod*kMod - 2*kMod - 1) % M
	if poly5 < 0 {
		poly5 += M
	}
	T5 := kMod * kMod % M * (kMinus1 * kMinus1 % M) % M * poly5 % M * inv12 % M
	if T5 < 0 {
		T5 += M
	}

	return T1, T2, T3, T4, T5
}

func expectedSp(p int, a, D, kMod int64, T []int64, M int64) int64 {
	ans := int64(0)
	C := [][]int64{
		{1},
		{1, 1},
		{1, 2, 1},
		{1, 3, 3, 1},
		{1, 4, 6, 4, 1},
		{1, 5, 10, 10, 5, 1},
	}
	for c := 0; c <= p; c++ {
		term := C[p][c]
		term = term * power(a, int64(p-c), M) % M
		term = term * power(D, int64(c), M) % M
		var tc int64
		if c == 0 {
			tc = kMod
		} else {
			tc = T[c-1]
		}
		term = term * tc % M
		ans = (ans + term) % M
	}
	return ans
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 10*1024*1024)
	scanner.Buffer(buf, 10*1024*1024)

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	if !scanner.Scan() {
		return
	}
	N, _ := strconv.Atoi(scanner.Text())
	scanner.Scan()
	Q, _ := strconv.Atoi(scanner.Text())

	M := int64(1000000007)
	inv2 = power(2, M-2, M)
	inv6 = power(6, M-2, M)
	inv12 = power(12, M-2, M)
	inv30 = power(30, M-2, M)

	A := make([]int64, N)
	for i := 0; i < N; i++ {
		A[i] = readInt64(scanner)
	}

	prefExact := make([]int64, N+1)
	prefMod2 := make([]int64, N+1)
	prefMod3 := make([]int64, N+1)
	prefMod4 := make([]int64, N+1)
	prefMod5 := make([]int64, N+1)

	for i := 1; i <= N; i++ {
		val := A[i-1]
		prefExact[i] = prefExact[i-1] + val

		v2 := val * val % M
		prefMod2[i] = (prefMod2[i-1] + v2) % M

		v3 := v2 * val % M
		prefMod3[i] = (prefMod3[i-1] + v3) % M

		v4 := v3 * val % M
		prefMod4[i] = (prefMod4[i-1] + v4) % M

		v5 := v4 * val % M
		prefMod5[i] = (prefMod5[i-1] + v5) % M
	}

	K_st := 1
	for (1 << K_st) <= N {
		K_st++
	}
	minSt := make([][]int32, K_st)
	maxSt := make([][]int32, K_st)
	for i := 0; i < K_st; i++ {
		minSt[i] = make([]int32, N)
		maxSt[i] = make([]int32, N)
	}
	for i := 0; i < N; i++ {
		minSt[0][i] = int32(A[i])
		maxSt[0][i] = int32(A[i])
	}
	for j := 1; j < K_st; j++ {
		for i := 0; i+(1<<j) <= N; i++ {
			v1 := minSt[j-1][i]
			v2 := minSt[j-1][i+(1<<(j-1))]
			if v1 < v2 {
				minSt[j][i] = v1
			} else {
				minSt[j][i] = v2
			}

			v1M := maxSt[j-1][i]
			v2M := maxSt[j-1][i+(1<<(j-1))]
			if v1M > v2M {
				maxSt[j][i] = v1M
			} else {
				maxSt[j][i] = v2M
			}
		}
	}

	log2 := make([]int, N+1)
	for i := 2; i <= N; i++ {
		log2[i] = log2[i/2] + 1
	}

	isSame := func(L, R int) bool {
		length := R - L + 1
		j := log2[length]
		v1 := minSt[j][L]
		v2 := minSt[j][R-(1<<j)+1]
		minVal := v1
		if v2 < v1 {
			minVal = v2
		}
		v1M := maxSt[j][L]
		v2M := maxSt[j][R-(1<<j)+1]
		maxVal := v1M
		if v2M > v1M {
			maxVal = v2M
		}
		return minVal == maxVal
	}

	for i := 0; i < Q; i++ {
		L := readInt(scanner)
		R := readInt(scanner)
		D_i := readInt64(scanner)

		if L > R {
			L, R = R, L
		}

		k := R - L + 1
		if k == 1 {
			fmt.Fprintln(writer, "Yes")
			continue
		}

		if D_i == 0 {
			if isSame(L-1, R-1) {
				fmt.Fprintln(writer, "Yes")
			} else {
				fmt.Fprintln(writer, "No")
			}
			continue
		}

		S_exact := prefExact[R] - prefExact[L-1]
		S1_mod := S_exact % M

		T1, T2, T3, T4, T5 := getT(int64(k), M)
		T := []int64{T1, T2, T3, T4, T5}

		invK := power(int64(k), M-2, M)
		a := (S1_mod - D_i*T1) % M
		if a < 0 {
			a += M
		}
		a = a * invK % M

		W := floorSum(int64(k), M, D_i, a)
		term1 := uint64(k) * uint64(a)
		pairs := uint64(k) * uint64(k-1) / 2
		term2 := uint64(D_i) * pairs
		term3 := uint64(M) * uint64(W)

		expected_exact_u := term1 + term2 - term3
		if S_exact != int64(expected_exact_u) {
			fmt.Fprintln(writer, "No")
			continue
		}

		S2_mod := (prefMod2[R] - prefMod2[L-1]) % M
		if S2_mod < 0 {
			S2_mod += M
		}
		if S2_mod != expectedSp(2, a, D_i, int64(k)%M, T, M) {
			fmt.Fprintln(writer, "No")
			continue
		}

		S3_mod := (prefMod3[R] - prefMod3[L-1]) % M
		if S3_mod < 0 {
			S3_mod += M
		}
		if S3_mod != expectedSp(3, a, D_i, int64(k)%M, T, M) {
			fmt.Fprintln(writer, "No")
			continue
		}

		S4_mod := (prefMod4[R] - prefMod4[L-1]) % M
		if S4_mod < 0 {
			S4_mod += M
		}
		if S4_mod != expectedSp(4, a, D_i, int64(k)%M, T, M) {
			fmt.Fprintln(writer, "No")
			continue
		}

		S5_mod := (prefMod5[R] - prefMod5[L-1]) % M
		if S5_mod < 0 {
			S5_mod += M
		}
		if S5_mod != expectedSp(5, a, D_i, int64(k)%M, T, M) {
			fmt.Fprintln(writer, "No")
			continue
		}

		fmt.Fprintln(writer, "Yes")
	}
}
```