#include "bits/stdc++.h"

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;

typedef long double ld;

const ld eps = 1e-9;
const ld pi = acos(-1);

//#define ENABLE_FREAD

namespace io_impl
{
	inline bool maybe_digit(char c)
	{
		return c >= '0' && c <= '9';
	}

	struct io_s
	{
	private:
		FILE* fin = stdin;
		FILE* fout = stdout;

		bool negative;
		bool ok = true;
		char ch;

		int precious;
		long double epslion;

#ifdef ENABLE_FREAD
		inline char next_char() {
			static char buf[100000], *p1 = buf, *p2 = buf;
			return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, fin), p1 == p2) ? EOF : *p1++;
		}
#else
		char next_char() const
		{
			return fgetc(fin);
		}
#endif
	public:
		void init()
		{
			ch = next_char();
		}

		void init(FILE* _in, FILE* _out)
		{
			fin = _in;
			fout = _out;
			init();
		}

#pragma region read int

		template <typename T>
		bool rn(T& _v)
		{
			negative = false;
			_v = 0;
			while (!maybe_digit(ch) && ch != EOF)
			{
				negative = ch == '-';
				ch = next_char();
			}
			if (ch == EOF)return ok = false;
			do
			{
				_v = (_v << 1) + (_v << 3) + ch - '0';
			} while (maybe_digit(ch = next_char()));
			if (negative) _v = -_v;
			return true;
		}

		template <typename T>
		void rn_unsafe(T& _v)
		{
			negative = false;
			_v = 0;
			while (!maybe_digit(ch))
			{
				negative = ch == '-';
				ch = next_char();
			}
			do
			{
				_v = (_v << 1) + (_v << 3) + ch - '0';
			} while (maybe_digit(ch = next_char()));
			if (negative) _v = -_v;
		}

		template <typename T>
		T rn()
		{
			T v = T();
			rn_unsafe(v);
			return v;
		}

#pragma endregion

#pragma region read unsigned

		template <typename T>
		bool run(T& _v)
		{
			_v = 0;
			while (!maybe_digit(ch) && ch != EOF) ch = next_char();
			if (ch == EOF)return ok = false;
			do
			{
				_v = (_v << 1) + (_v << 3) + ch - '0';
			} while (maybe_digit(ch = next_char()));
			return true;
		}

		template <typename T>
		void run_unsafe(T& _v)
		{
			_v = 0;
			while (!maybe_digit(ch)) ch = next_char();
			do
			{
				_v = (_v << 1) + (_v << 3) + ch - '0';
			} while (maybe_digit(ch = next_char()));
		}

		template <typename T>
		T run()
		{
			T v = T();
			run_unsafe(v);
			return v;
		}

#pragma endregion

#pragma region read float

		template <typename T>
		bool rd(T& _v)
		{
			negative = false;
			_v = 0;
			while (!maybe_digit(ch) && ch != EOF)
			{
				negative = ch == '-';
				ch = next_char();
			}
			if (ch == EOF)return ok = false;
			do
			{
				_v = (_v * 10) + (ch - '0');
			} while (maybe_digit(ch = next_char()));
			static int stk[70], tp;
			if (ch == '.')
			{
				tp = 0;
				T _v2 = 0;
				while (maybe_digit(ch = next_char()))
				{
					stk[tp++] = ch - '0';
				}
				while (tp--)
				{
					_v2 = _v2 / 10 + stk[tp];
				}
				_v += _v2 / 10;
			}
			if (ch == 'e' || ch == 'E')
			{
				ch = next_char();
				static bool _neg = false;
				if (ch == '+') ch = next_char();
				else if (ch == '-') _neg = true, ch = next_char();
				if (maybe_digit(ch))
				{
					_v *= pow(10, run<LL>() * (_neg ? -1 : 1));
				}
			}
			if (negative) _v = -_v;
			return true;
		}

		template <typename T>
		T rd()
		{
			T v = T();
			rd(v);
			return v;
		}

#pragma endregion

#pragma region read string

		int gets(char* s)
		{
			char* c = s;
			while (ch == '\n' || ch == '\r' || ch == ' ') ch = next_char();
			if (ch == EOF) return (ok = false), *c = 0;
			do
			{
				*(c++) = ch;
				ch = next_char();
			} while (ch != '\n' && ch != '\r' && ch != ' ' && ch != EOF);
			*(c++) = '\0';
			return static_cast<int>(c - s - 1);
		}

		int getline(char* s)
		{
			char* c = s;
			while (ch == '\n' || ch == '\r') ch = next_char();
			if (ch == EOF) return (ok = false), *c = 0;
			do
			{
				*(c++) = ch;
				ch = next_char();
			} while (ch != '\n' && ch != '\r' && ch != EOF);
			*(c++) = '\0';
			return static_cast<int>(c - s - 1);
		}

		char get_alpha()
		{
			while (!isalpha(ch)) ch = next_char();
			const char ret = ch;
			ch = next_char();
			return ret;
		}

		char get_nonblank()
		{
			while (iswspace(ch)) ch = next_char();
			const char ret = ch;
			ch = next_char();
			return ret;
		}

		char get_char()
		{
			const char ret = ch;
			ch = next_char();
			return ret;
		}

		template <typename T>
		void o(T p)
		{
			static int stk[70], tp;
			if (p == 0)
			{
				putchar('0');
				return;
			}
			if (p < 0)
			{
				p = -p;
				putchar('-');
			}
			while (p) stk[++tp] = p % 10, p /= 10;
			while (tp) putchar(stk[tp--] + '0');
		}

		template <typename T>
		void od(T v)
		{
			static int stk[70], tp;
			tp = 0;
			if (fabs(v) < epslion / 10)
			{
				putchar('0');
				if (precious > 0)
				{
					putchar('.');
					for (int i = 0; i < precious; ++i) putchar('0');
				}
				return;
			}
			if (v < 0)
			{
				v = -v;
				putchar('-');
			}
			v += epslion / 2;
			T p = floor(v) + epslion / 10;
			while (fabs(p) > 1 - epslion)
			{
				stk[++tp] = fmod(p, 10), p = floor(p / 10) + epslion;
			}
			if (tp == 0) putchar('0');
			while (tp) putchar(stk[tp--] + '0');
			if (precious == 0) return;
			putchar('.');
			v -= floor(v);
			for (int i = 0; i < precious; ++i)
			{
				v *= 10;
				putchar((int)floor(v) + '0');
				v = fmod(v, 1);
			}
		}

#pragma endregion

#pragma region enhancement

		typedef void io_operator_func(io_s& v);
		typedef char* charptr;

		template <typename T>
		io_s& operator >>(T& x)
		{
			if (numeric_limits<T>::is_signed) rn(x);
			else run(x);
			return *this;
		}

		template <typename TFirst, typename TSecond>
		io_s& operator >>(pair<TFirst, TSecond>& pr)
		{
			*this >> pr.first >> pr.second;
			return *this;
		}

		template <typename T>
		io_s& operator <<(const T& x);

		io_s& operator <<(const io_operator_func*& x)
		{
			x(*this);
			return *this;
		}

		operator bool() const { return ok; }

		void set_precious(int x)
		{
			precious = x;
			epslion = pow(10, -x);
		}

		int ri() { return rn<int>(); }
		LL rll() { return rn<LL>(); }

		static void new_line(io_s& v)
		{
			putchar('\n');
		}

		static void flush(io_s& v)
		{
			fflush(stdout);
		}
#pragma endregion

#pragma region batch

		template <typename T>
		void o(T begin, T end)
		{
			while (begin != end)
			{
				o(*begin++);
				o(begin == end ? '\n' : ' ');
			}
		}

#pragma endregion
	};

#pragma region input fix

	template <>
	inline io_s& io_s::operator >>(char*& x)
	{
		gets(x);
		return *this;
	}

	template <>
	inline io_s& io_s::operator >>(char& x)
	{
		x = get_nonblank();
		return *this;
	}

	template <>
	inline io_s& io_s::operator >>(float& x)
	{
		rd(x);
		return *this;
	}

	template <>
	inline io_s& io_s::operator >>(double& x)
	{
		rd(x);
		return *this;
	}

	template <>
	inline io_s& io_s::operator >>(long double& x)
	{
		rd(x);
		return *this;
	}
#pragma region output fix

	template <>
	inline void io_s::o(const char p)
	{
		putchar(p);
	}

	template <>
	inline void io_s::o(const char* p)
	{
		printf(p);
	}

	template <>
	inline void io_s::o(float p)
	{
		od(p);
	}

	template <>
	inline void io_s::o(double p)
	{
		od(p);
	}

	template <>
	inline void io_s::o(long double p)
	{
		od(p);
	}

	template <typename T>
	io_s& io_s::operator <<(const T& x)
	{
		o(x);
		return *this;
	}

	io_s::io_operator_func* nl = io_s::new_line;
	io_s::io_operator_func* fl = io_s::flush;
#pragma endregion
}

using namespace io_impl;

io_s io;

typedef void InitFunction();
typedef bool SolveFunction(int);

struct env_s
{
private:
	bool global_inited = false;

	bool case_inited = false;
public:
	bool once()
	{
		return global_inited ? false : (global_inited = true);
	}

	bool every()
	{
		return case_inited ? false : (case_inited = true);
	}

	InitFunction *_initOnce, *_init;

	template <InitFunction TInitOnce, InitFunction TInit>
	void configure()
	{
		_initOnce = TInitOnce;
		_init = TInit;
	}

	void init(bool global)
	{
		if (global) if (_initOnce != nullptr)_initOnce();
		if (_init != nullptr) _init();
	}

	void empty_init()
	{
	}

	template <SolveFunction TSolve>
	void solve_single()
	{
		global_inited = false;
		case_inited = false;
		init(true);
		TSolve(0);
	}

	template <SolveFunction TSolve>
	void solve_many()
	{
		global_inited = false;
		int T = io.ri();
		for (int cs = 1; T--; ++cs)
		{
			case_inited = false;
			init(cs == 1);
			if (!TSolve(cs))break;
		}
	}

	template <SolveFunction TSolve>
	void solve_much()
	{
		global_inited = false;
		case_inited = false;
		for (int cs = 1; init(cs == 1), TSolve(cs); ++cs)
			case_inited = false;
	}
} env;

#define FOR(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i > _##i; --i)
#ifdef _DEBUG
#define dbg(...) do { cerr << "Debug: " << # __VA_ARGS__ << " -> "; err(## __VA_ARGS__); } while (0)
#define fuck(x) do { printf("fuck@%d\n", x); } while(0)
#else
#define dbg(...)
#define fuck(...)
#endif
void err() { cerr << endl; }

template <typename T, typename... Args>
void err(T a, Args ... args)
{
	cerr << a << ' ';
	err(args...);
}

// ----------------------------------------------------------------

namespace solution
{
#pragma region init

	void init_once()
	{
		srand(time(nullptr));
		io.set_precious(12);
		//io.set_precious(2);
	}

	void init_every()
	{
	}

#pragma endregion

	const int N = 1e5 + 10;

	char a[N], b[N];

	int gcd(int x, int y)
	{
		return x == 0 ? y : gcd(y%x, x);
	}

	bool solve(int _cas)
	{
		int n, m; io >> n >> m;
		io.gets(a);
		io.gets(b);
		int g = gcd(n, m);
		int aa = n / g, bb = m / g;
		FOR(i, 0, g)
		{
			if (a[aa*i] != b[bb*i])
			{
				io << "-1" << nl;
				return true;
			}
		}
		io << 1LL * n*m / g << nl;
		return true;
	}
}

//#define DEBUGTOOL 1

#ifdef _DEBUG

#ifndef ONLINE_JUDGE

#define DEBUGTOOL 1

#endif

#endif

int main()
{
#if DEBUGTOOL
	clock_t t = clock();
	io.init();
	//io.init(fopen("data.in", "r"), stdout);
	//io.init(fopen("data.in", "r"), fopen("data.out", "w"));
#else
	io.init();
#endif
	env.configure<solution::init_once, solution::init_every>();
	env.solve_single<solution::solve>();
#if DEBUGTOOL
	io << "time: " << (clock() - t) * 0.001 << "s" << nl;
	system("pause");
#endif
	return 0;
}

Measured memory_bytes: 384