Problem:
Score : 300 points

Problem Statement

You are given a string S of length N and another string T of length M.
These strings consist of lowercase English letters.

A string X is called a good string when the following conditions are all met:

Let L be the length of X. L is divisible by both N and M.

Concatenating the 1-st, (\frac{L}{N}+1)-th, (2 \times \frac{L}{N}+1)-th, ..., ((N-1)\times\frac{L}{N}+1)-th characters of X, without changing the order, results in S.

Concatenating the 1-st, (\frac{L}{M}+1)-th, (2 \times \frac{L}{M}+1)-th, ..., ((M-1)\times\frac{L}{M}+1)-th characters of X, without changing the order, results in T.

Determine if there exists a good string. If it exists, find the length of the shortest such string.

Constraints

1 \leq N,M \leq 10^5

S and T consist of lowercase English letters.

|S|=N

|T|=M

Input

Input is given from Standard Input in the following format:

N M
S
T

Output

If a good string does not exist, print -1; if it exists, print the length of the shortest such string.

Sample Input 1

3 2
acp
ae

Sample Output 1

6

For example, the string accept is a good string.
There is no good string shorter than this, so the answer is 6.

Sample Input 2

6 3
abcdef
abc

Sample Output 2

-1

Sample Input 3

15 9
dnsusrayukuaiia
dujrunuma

Sample Output 3

45

Solution in Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"fmt"
	"os"
)

func main() {
	var n, m int
	var s, t string
	fmt.Scanf("%d %d", &n, &m)
	fmt.Scanf("%s", &s)
	fmt.Scanf("%s", &t)

	// cheat
	/*
		if strings.Contains(s, t) || strings.Contains(t, s) {
			bad()
			return
		}
	*/

	candidates := genL(n, m)

	for _, l := range candidates {
		if judge(l, s, t) {
			fmt.Println(l)
			return
		}
	}
	bad()
}

func judge(l int, s, t string) bool {
	sIdxes := abbrIdxes(l, len(s))
	tIdxes := abbrIdxes(l, len(t))

	var i = 0
	for {
		if i == len(s) || i == len(t) {
			return true
		} else {
			//fmt.Printf("l: %d, s: %d, t: %d, i: %d\n", l, len(s), len(t), i)
		}
		var sAbbr = false
		var sNum = 0
		var tAbbr = false
		var tNum = 0

		for j, sIdx := range sIdxes {
			if sIdx == i+1 {
				sAbbr = true
				sNum = j
				//sIdxes = sIdxes[1:]
				break
			}
		}
		for j, tIdx := range tIdxes {
			if tIdx == i+1 {
				tAbbr = true
				tNum = j
				// tIdxes = tIdxes[1:]
				break
			}
		}
		// fmt.Println(i, sAbbr, tAbbr)
		if sAbbr && tAbbr {
			if s[i] != t[i] {
				return false
			}
			if sNum != tNum {
				bad()
				os.Exit(0)
				return false
			}
		}
		i++
	}
}

func cond1(l, n, m int) bool {
	return l%n == 0 && l%m == 0
}

func genL(n, m int) []int {
	var ns []int
	for i := 1; i <= 100000; i++ {
		if cond1(i, n, m) {
			ns = append(ns, i)
		}
	}
	return ns
}

func abbrIdxes(l, n int) []int {
	var idxes []int
	var ac = l / n
	for i := 1; i <= n; i++ {
		idx := (i-1)*ac + 1
		idxes = append(idxes, idx)
	}
	return idxes
}

func bad() {
	fmt.Println("-1")
}