For problem statement at 1000-1999/1500-1599/1500-1509/1500/problemB.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1500-1509/1500/verifierB.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func extGcd(a, b int64) (int64, int64, int64) {
	if b == 0 {
		return a, 1, 0
	}
	g, x1, y1 := extGcd(b, a%b)
	return g, y1, x1 - (a/b)*y1
}

func modInverse(a, m int64) int64 {
	_, x, _ := extGcd(a, m)
	return (x%m + m) % m
}

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

	a := make([]int, n)
	b := make([]int, m)

	posA := make(map[int]int)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
		posA[a[i]] = i
	}

	posB := make(map[int]int)
	for i := 0; i < m; i++ {
		fmt.Fscan(reader, &b[i])
		posB[b[i]] = i
	}

	n64 := int64(n)
	m64 := int64(m)
	g := gcd(n64, m64)
	l := n64 / g * m64

	matchDays := make([]int64, 0)

	for color, indexA := range posA {
		if indexB, ok := posB[color]; ok {
			x := int64(indexA)
			y := int64(indexB)

			if x%g == y%g {
				mod := m64 / g
				rhs := (y - x) / g
				rhs = (rhs%mod + mod) % mod
				inv := modInverse(n64/g, mod)
				kCoeff := (rhs * inv) % mod
				z := x + kCoeff*n64
				matchDays = append(matchDays, z)
			}
		}
	}

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

	countMatches := func(t int64) int64 {
		q := t / l
		r := t % l
		cnt := q * int64(len(matchDays))
		rem := sort.Search(len(matchDays), func(i int) bool {
			return matchDays[i] >= r
		})
		return cnt + int64(rem)
	}

	low := int64(1)
	high := int64(2e18)

	for low < high {
		mid := low + (high-low)/2
		matches := countMatches(mid)
		diff := mid - matches
		if diff >= k {
			high = mid
		} else {
			low = mid + 1
		}
	}

	fmt.Println(low)
}
```