/**
* code generated by JHelper
* More info: https://g...content-available-to-author-only...b.com/AlexeyDmitriev/JHelper
* @author RiaD
*/
#include <iostream>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <vector>
template <typename T>
T phi(T x) {
T result = x;
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
result /= i;
result *= i - 1;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
result /= x;
result *= x - 1;
}
return result;
}
#include <cassert>
#include <iterator>
#include <string>
#include <stdexcept>
#ifndef SPCPPL_ASSERT
#ifdef SPCPPL_DEBUG
#define SPCPPL_ASSERT(condition) \
if(!(condition)) { \
throw std::runtime_error(std::string() + #condition + " in line " + std::to_string(__LINE__) + " in " + __PRETTY_FUNCTION__); \
}
#else
#define SPCPPL_ASSERT(condition)
#endif
#endif
/**
* Support decrementing and multi-passing, but not declared bidirectional(or even forward) because
* it's reference type is not a reference.
*
* It doesn't return reference because
* 1. Anyway it'll not satisfy requirement [forward.iterators]/6
* If a and b are both dereferenceable, then a == b if and only if *a and
* b are bound to the same object.
* 2. It'll not work with reverse_iterator that returns operator * of temporary which is temporary for this iterator
*
* Note, reverse_iterator is not guaranteed to work now too since it works only with bidirectional iterators,
* but it's seems to work at least on my implementation.
*
* It's not really useful anywhere except iterating anyway.
*/
template <typename T>
class IntegerIterator: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
explicit IntegerIterator(T value): value(value) {
}
IntegerIterator& operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator& operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const {
return value;
}
bool operator==(IntegerIterator rhs) const {
return value == rhs.value;
}
bool operator!=(IntegerIterator rhs) const {
return !(*this == rhs);
}
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end): begin_(begin), end_(end) {
SPCPPL_ASSERT(begin <= end);
}
IntegerIterator<T> begin() const {
return IntegerIterator<T>(begin_);
}
IntegerIterator<T> end() const {
return IntegerIterator<T>(end_);
}
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
typedef std::reverse_iterator<IntegerIterator<T>> IteratorType;
public:
ReversedIntegerRange(T begin, T end): begin_(begin), end_(end) {
SPCPPL_ASSERT(begin >= end);
}
IteratorType begin() const {
return IteratorType(IntegerIterator<T>(begin_));
}
IteratorType end() const {
return IteratorType(IntegerIterator<T>(end_));
}
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
return ReversedIntegerRange<T>(from + 1, to);
}
#include <map>
using namespace std;
vector<int> prefix_function (string s) {
int n = (int) s.length();
vector<int> pi (n);
for (int i=1; i<n; ++i) {
int j = pi[i-1];
while (j > 0 && s[i] != s[j])
j = pi[j-1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
return pi;
}
class TaskF {
public:
void solve(std::istream& in, std::ostream& out) {
string s, t;
in >> s >> t;
if (s.front() != t.front()) {
out << -1;
return;
}
if (s.back() != t.back()) {
out << -1;
return;
}
int n = (int)s.size();
int phi = ::phi(n - 1);
vector<int> used(n);
std::map<int, vector<int>> can;
for (int i = 1; i < s.size() - 1; ++i) {
if (used[i]) {
continue;
}
string cur;
string cur2;
for (int j = i; !used[j]; j = (2 * j) % (n - 1)) {
used[j] = true;
cur += s[j];
cur2 += t[j];
}
assert(phi
% cur.
size() == 0); //swap(cur, cur2);
//cur += cur;
string s = cur2 + "#" + cur + cur;
auto pi = prefix_function(s);
//pi.erase(pi.begin(), pi.begin() + cur.size() + cur.size());
auto& mapa = can[cur.size()];
if (mapa.empty()) {
mapa.assign(cur.size(), 1);
}
for (int u = 0; u < cur.size(); ++u) {
if (pi[u + 2 * cur.size()] != cur.size()) {
mapa[u] = 0;
}
}
}
for (int i: range(phi)) {
bool can_all = true;
for (auto& p: can) {
if (!p.second[i % p.first]) {
can_all = false;
break;
}
}
if (can_all) {
out << i;
return;
}
}
out << -1;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
TaskF solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(0);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}