For problem statement at 1000-1999/1600-1699/1620-1629/1621/problemG.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1620-1629/1621/verifierG.go ends with All tests passed can you fix the verifier? ```go
package main

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

const MOD = 1000000007

func updateAdd(tree []int, idx int, val int) {
	for idx < len(tree) {
		tree[idx] = (tree[idx] + val) % MOD
		idx += idx & -idx
	}
}

func querySum(tree []int, idx int) int {
	res := 0
	for idx > 0 {
		res = (res + tree[idx]) % MOD
		idx -= idx & -idx
	}
	return res
}

func updateMax(tree []int, idx int, val int) {
	for idx < len(tree) {
		if val > tree[idx] {
			tree[idx] = val
		}
		idx += idx & -idx
	}
}

func queryMax(tree []int, idx int) int {
	res := 0
	for idx > 0 {
		if tree[idx] > res {
			res = tree[idx]
		}
		idx -= idx & -idx
	}
	return res
}

type Scanner struct {
	buf  []byte
	pos  int
	size int
	f    *os.File
}

func NewScanner(f *os.File) *Scanner {
	return &Scanner{
		buf:  make([]byte, 1024*1024),
		pos:  0,
		size: 0,
		f:    f,
	}
}

func (s *Scanner) nextInt() int {
	for {
		if s.pos >= s.size {
			n, err := s.f.Read(s.buf)
			if err != nil || n == 0 {
				return 0
			}
			s.pos = 0
			s.size = n
		}
		if s.buf[s.pos] > ' ' {
			break
		}
		s.pos++
	}
	res := 0
	for {
		if s.pos >= s.size {
			n, err := s.f.Read(s.buf)
			if err != nil || n == 0 {
				break
			}
			s.pos = 0
			s.size = n
		}
		if s.buf[s.pos] <= ' ' {
			break
		}
		res = res*10 + int(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

func main() {
	scanner := NewScanner(os.Stdin)
	t := scanner.nextInt()
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	for tc := t; tc > 0; tc-- {
		n := scanner.nextInt()
		a := make([]int, n+1)
		sortedA := make([]int, n)
		for i := 1; i <= n; i++ {
			a[i] = scanner.nextInt()
			sortedA[i-1] = a[i]
		}

		sort.Ints(sortedA)
		uniqueA := make([]int, 0, n)
		for i := 0; i < n; i++ {
			if i == 0 || sortedA[i] != sortedA[i-1] {
				uniqueA = append(uniqueA, sortedA[i])
			}
		}

		maxVal := len(uniqueA)
		val := make([]int, n+1)
		for i := 1; i <= n; i++ {
			val[i] = sort.SearchInts(uniqueA, a[i]) + 1
		}

		bitL := make([]int, maxVal+1)
		L := make([]int, n+1)
		for i := 1; i <= n; i++ {
			v := val[i]
			sum := querySum(bitL, v-1)
			L[i] = (1 + sum) % MOD
			updateAdd(bitL, v, L[i])
		}

		bitR := make([]int, maxVal+1)
		R := make([]int, n+1)
		for i := n; i >= 1; i-- {
			v := val[i]
			sum := (querySum(bitR, maxVal) - querySum(bitR, v) + MOD) % MOD
			R[i] = (1 + sum) % MOD
			updateAdd(bitR, v, R[i])
		}

		bitNxt := make([]int, maxVal+1)
		nxt := make([]int, n+1)
		for i := n; i >= 1; i-- {
			v := val[i]
			revV := maxVal - v + 1
			nxt[i] = queryMax(bitNxt, revV-1)
			updateMax(bitNxt, revV, i)
		}

		S := make([][]int, n+1)
		for i := 1; i <= n; i++ {
			if nxt[i] != 0 {
				S[nxt[i]] = append(S[nxt[i]], i)
			}
		}

		W := make([]int, n+1)
		bitW := make([]int, maxVal+1)
		for v := 1; v <= n; v++ {
			if len(S[v]) == 0 {
				continue
			}
			for j := len(S[v]) - 1; j >= 0; j-- {
				u := S[v][j]
				vu := val[u]
				sum := (querySum(bitW, maxVal) - querySum(bitW, vu) + MOD) % MOD
				W[u] = (1 + sum) % MOD
				updateAdd(bitW, vu, W[u])
			}
			for j := len(S[v]) - 1; j >= 0; j-- {
				u := S[v][j]
				vu := val[u]
				updateAdd(bitW, vu, (MOD-W[u])%MOD)
			}
		}

		for i := 1; i <= n; i++ {
			if nxt[i] == 0 {
				W[i] = 1
			}
		}

		ans := 0
		for i := 1; i <= n; i++ {
			term := (R[i] - W[i] + MOD) % MOD
			term = int((int64(term) * int64(L[i])) % MOD)
			ans = (ans + term) % MOD
		}

		fmt.Fprintln(writer, ans)
	}
}
```