package main

import (
	"fmt"
)

func main() {
	var s1, s2 string
	if _, err := fmt.Scan(&s1, &s2); err != nil {
		return
	}
	var n int
	if _, err := fmt.Scan(&n); err != nil {
		return
	}

	type rule struct {
		A, B, C byte
	}
	var rules []rule
	for i := 0; i < n; i++ {
		var r string
		fmt.Scan(&r)
		if len(r) >= 5 {
			rules = append(rules, rule{r[0] - 'a', r[3] - 'a', r[4] - 'a'})
		}
	}

	reach1 := make([][]uint32, len(s1))
	for i := range reach1 {
		reach1[i] = make([]uint32, len(s1))
		reach1[i][i] = 1 << (s1[i] - 'a')
	}

	for L := 2; L <= len(s1); L++ {
		for i := 0; i <= len(s1)-L; i++ {
			j := i + L - 1
			for k := i; k < j; k++ {
				for _, r := range rules {
					if (reach1[i][k]&(1<<r.B) != 0) && (reach1[k+1][j]&(1<<r.C) != 0) {
						reach1[i][j] |= 1 << r.A
					}
				}
			}
		}
	}

	reach2 := make([][]uint32, len(s2))
	for i := range reach2 {
		reach2[i] = make([]uint32, len(s2))
		reach2[i][i] = 1 << (s2[i] - 'a')
	}

	for L := 2; L <= len(s2); L++ {
		for i := 0; i <= len(s2)-L; i++ {
			j := i + L - 1
			for k := i; k < j; k++ {
				for _, r := range rules {
					if (reach2[i][k]&(1<<r.B) != 0) && (reach2[k+1][j]&(1<<r.C) != 0) {
						reach2[i][j] |= 1 << r.A
					}
				}
			}
		}
	}

	dp := make([][]int, len(s1)+1)
	for i := range dp {
		dp[i] = make([]int, len(s2)+1)
		for j := range dp[i] {
			dp[i][j] = 1e9
		}
	}
	dp[0][0] = 0

	for i := 1; i <= len(s1); i++ {
		for j := 1; j <= len(s2); j++ {
			for ip := 0; ip < i; ip++ {
				for jp := 0; jp < j; jp++ {
					if dp[ip][jp] != 1e9 {
						if (reach1[ip][i-1] & reach2[jp][j-1]) != 0 {
							if dp[ip][jp]+1 < dp[i][j] {
								dp[i][j] = dp[ip][jp] + 1
							}
						}
					}
				}
			}
		}
	}

	if dp[len(s1)][len(s2)] == 1e9 {
		fmt.Println("-1")
	} else {
		fmt.Println(dp[len(s1)][len(s2)])
	}
}