For problem statement at 1000-1999/1500-1599/1580-1589/1583/problemG.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1580-1589/1583/verifierG.go ends with Problem G is not implemented and cannot be automatically verified. can you fix the verifier? ```go
package main

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

type Task struct {
	id int
	a  int
	b  int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(reader, &n)

	tasks := make([]Task, n)
	for i := 0; i < n; i++ {
		tasks[i].id = i + 1
		fmt.Fscan(reader, &tasks[i].a, &tasks[i].b)
	}

	var t int
	fmt.Fscan(reader, &t)
	s := make([]int, t)
	inS := make([]bool, n+1)
	for i := 0; i < t; i++ {
		fmt.Fscan(reader, &s[i])
		inS[s[i]] = true
	}

	sTasks := make([]Task, 0, t)
	for i := 0; i < n; i++ {
		if inS[tasks[i].id] {
			sTasks = append(sTasks, tasks[i])
		}
	}

	sort.Slice(sTasks, func(i, j int) bool {
		return sTasks[i].b > sTasks[j].b
	})

	threshold := make([]int, n+1)
	inV := make([]bool, n+1)
	C_L := 0
	for _, task := range sTasks {
		if task.a > C_L {
			inV[task.id] = true
			threshold[task.id] = C_L
			C_L = task.a
		}
	}

	sort.Slice(tasks, func(i, j int) bool {
		return tasks[i].b < tasks[j].b
	})

	maxVal := 2 * n
	bit := make([]int, maxVal+1)
	add := func(idx, val int) {
		for ; idx <= maxVal; idx += idx & -idx {
			bit[idx] = (bit[idx] + val) % 1000000007
		}
	}
	query := func(idx int) int {
		sum := 0
		for ; idx > 0; idx -= idx & -idx {
			sum = (sum + bit[idx]) % 1000000007
		}
		return sum
	}

	MOD := 1000000007
	total_ans := 0

	for _, task := range tasks {
		if inV[task.id] {
			sum_gt_T := (query(maxVal) - query(threshold[task.id]) + MOD) % MOD
			total_ans = (total_ans + sum_gt_T + 1) % MOD
		}

		sum_gt_a := (query(maxVal) - query(task.a) + MOD) % MOD
		dp := (sum_gt_a + 1) % MOD
		add(task.a, dp)
	}

	fmt.Println(total_ans)
}
```