For problem statement at 1000-1999/1100-1199/1180-1189/1185/problemG2.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1180-1189/1185/verifierG2.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

const MOD = 1000000007

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, T int
	if _, err := fmt.Fscan(reader, &n, &T); err != nil {
		return
	}

	N := make([]int, 4)
	M := make([]int, 4)
	items := make([][]int, 4)
	for i := 0; i < n; i++ {
		var t, g int
		fmt.Fscan(reader, &t, &g)
		items[g] = append(items[g], t)
		N[g]++
		M[g] += t
	}

	fact := make([]int, 51)
	fact[0] = 1
	for i := 1; i <= 50; i++ {
		fact[i] = int((int64(fact[i-1]) * int64(i)) % MOD)
	}

	ways := make([][][][4]int, N[1]+1)
	for i := 0; i <= N[1]; i++ {
		ways[i] = make([][][4]int, N[2]+1)
		for j := 0; j <= N[2]; j++ {
			ways[i][j] = make([][4]int, N[3]+1)
		}
	}

	if N[1] > 0 {
		ways[1][0][0][1] = 1
	}
	if N[2] > 0 {
		ways[0][1][0][2] = 1
	}
	if N[3] > 0 {
		ways[0][0][1][3] = 1
	}

	for i := 0; i <= N[1]; i++ {
		for j := 0; j <= N[2]; j++ {
			for k := 0; k <= N[3]; k++ {
				if i+j+k <= 1 {
					continue
				}
				if i > 0 {
					ways[i][j][k][1] = (ways[i-1][j][k][2] + ways[i-1][j][k][3]) % MOD
				}
				if j > 0 {
					ways[i][j][k][2] = (ways[i][j-1][k][1] + ways[i][j-1][k][3]) % MOD
				}
				if k > 0 {
					ways[i][j][k][3] = (ways[i][j][k-1][1] + ways[i][j][k-1][2]) % MOD
				}
			}
		}
	}

	V := make([][][]int, 4)
	for genre := 1; genre <= 3; genre++ {
		V[genre] = make([][]int, N[genre]+1)
		for c := 0; c <= N[genre]; c++ {
			V[genre][c] = make([]int, M[genre]+1)
		}
		V[genre][0][0] = 1
		for _, t := range items[genre] {
			for c := N[genre]; c >= 1; c-- {
				for w := M[genre]; w >= t; w-- {
					V[genre][c][w] = (V[genre][c][w] + V[genre][c-1][w-t]) % MOD
				}
			}
		}
		for c := 0; c <= N[genre]; c++ {
			for w := 0; w <= M[genre]; w++ {
				V[genre][c][w] = int((int64(V[genre][c][w]) * int64(fact[c])) % MOD)
			}
		}
	}

	type pair struct {
		w, v int
	}
	nzV := make([][][]pair, 4)
	for genre := 1; genre <= 3; genre++ {
		nzV[genre] = make([][]pair, N[genre]+1)
		for c := 0; c <= N[genre]; c++ {
			for w := 0; w <= M[genre]; w++ {
				if V[genre][c][w] > 0 {
					nzV[genre][c] = append(nzV[genre][c], pair{w, V[genre][c][w]})
				}
			}
		}
	}

	S := make([][][]int, N[1]+1)
	for i := 0; i <= N[1]; i++ {
		S[i] = make([][]int, N[2]+1)
		for j := 0; j <= N[2]; j++ {
			S[i][j] = make([]int, M[3]+1)
			for k := 0; k <= N[3]; k++ {
				G := (ways[i][j][k][1] + ways[i][j][k][2] + ways[i][j][k][3]) % MOD
				if G == 0 {
					continue
				}
				for _, p := range nzV[3][k] {
					S[i][j][p.w] = int((int64(S[i][j][p.w]) + int64(G)*int64(p.v)) % MOD)
				}
			}
		}
	}

	R := make([][]int, N[1]+1)
	for i := 0; i <= N[1]; i++ {
		R[i] = make([]int, M[2]+M[3]+1)
		for j := 0; j <= N[2]; j++ {
			if len(nzV[2][j]) == 0 {
				continue
			}
			var nzS []pair
			for w := 0; w <= M[3]; w++ {
				if S[i][j][w] > 0 {
					nzS = append(nzS, pair{w, S[i][j][w]})
				}
			}
			if len(nzS) == 0 {
				continue
			}

			for _, p2 := range nzV[2][j] {
				for _, ps := range nzS {
					R[i][p2.w+ps.w] = int((int64(R[i][p2.w+ps.w]) + int64(p2.v)*int64(ps.v)) % MOD)
				}
			}
		}
	}

	ans := 0
	for i := 0; i <= N[1]; i++ {
		for _, p1 := range nzV[1][i] {
			w_rem := T - p1.w
			if w_rem >= 0 && w_rem <= M[2]+M[3] {
				ans = int((int64(ans) + int64(p1.v)*int64(R[i][w_rem])) % MOD)
			}
		}
	}

	fmt.Println(ans)
}
```