// clang-format off
	#define BADSEED chrono::high_resolution_clock::now().time_since_epoch().count()
	#include <bits/stdc++.h>
	using namespace std;
	using uint = unsigned int;
	#define TM_(...) template <class __VA_ARGS__>
	#define ENABLE(...) TM_(T) static enable_if_t<__VA_ARGS__>
	#define SFINAE(name, ...)                                                  \
		TM_(, class = void) struct name##_s : false_type {};                   \
		TM_(T) struct name##_s<T, decltype(void(__VA_ARGS__))> : true_type {}; \
		TM_(T) constexpr bool name = name##_s<T>::value;
	ostream &operator<<(ostream &os, int8_t c) { return os << static_cast<int>(c); }
	namespace narut {
		TM_(T) using TupSz = tuple_size<decay_t<T>>;
		SFINAE(Iterable, begin(declval<T &>()))
		SFINAE(IsTuple, TupSz<T>{})
		SFINAE(Coutable, cout << declval<T &>())
		SFINAE(Cinable, cin >> declval<T &>())
		TM_(T) constexpr char Spc(T &&) { return (Iterable<T> or IsTuple<T>) ? '\n' : ' '; }
		template <ostream &os, bool Red> struct Writer {
			ENABLE(Coutable<T>) Write(T const &t) { os << t; }
			ENABLE(!Coutable<T> and Iterable<T>) Write(T const &t) {
				auto it = begin(t), e = end(t);
				if (it != e) Write(*it++);
				for (; it != e; Write(*it++)) os << Spc(*it);
			}
			TM_(T, size_t... Is) static void WriteTup(T const &t, index_sequence<Is...>) {
				(void)(int[]){0, ((Is == 0) ? 0 : ((os << ' '), 0), Write(get<Is>(t)), 0)...};
			}
			ENABLE(!Coutable<T> and !Iterable<T> and IsTuple<T>) Write(T const &t) {
				WriteTup(t, make_index_sequence<TupSz<T>::value>{});
			}
			void operator()() const { os << '\n'; }
			TM_(F, class... Ts) void operator()(F const &f, Ts const &... ts) {
				if (Red) os << "\033[0;31m";
				Write(f);
				(void)(int[]){0, (os << ' ', Write(ts), 0)...};
				if (Red)
					os << "\033[0m\n";
				else
					os << '\n';
			}
		};
		struct Cin {
			ENABLE(Cinable<T>) Read(T &t) { cin >> t; }
			ENABLE(!Cinable<T> and Iterable<T>) Read(T &t) {
				for (auto &&x : t) Read(x);
			}
			TM_(T, size_t... Is) static void ReadTup(T &t, index_sequence<Is...>) {
				(void)(int[]){0, (Read(get<Is>(t)), 0)...};
			}
			ENABLE(!Cinable<T> and !Iterable<T> and IsTuple<T>) Read(T &t) {
				ReadTup(t, make_index_sequence<TupSz<T>::value>{});
			}
			TM_(T) void operator()(T &t) const { Read(t); }
			TM_(T) void operator()(T &t, uint n) const { t.resize(n), Read(t); }
			TM_(T) operator T() const {
				T t;
				return Read(t), t;
			}
		};
		struct Big {
			TM_(T) constexpr operator T() const {
				return 0x3f3f3f3f3f3f3f3f & numeric_limits<T>::max();
			}
		};
		TM_(T, size_t N, size_t... Ns) struct arr {
			using type = array<typename arr<T, Ns...>::type, N>;
		};
		TM_(T, size_t N) struct arr<T, N> { using type = array<T, N>; };
		TM_(T, size_t N, size_t... Ns) using Arr = typename arr<T, N, Ns...>::type;
		template <class C, class T> auto Fill(C &c, T const &t) -> decltype(void(*begin(c) = t)) {
			fill(begin(c), end(c), t);
		}
		template <class C, class T> auto Fill(C &c, T const &t) -> decltype(void(begin(*begin(c)))) {
			for (auto &x : c) Fill(x, t);
		}
	} // namespace narut
	narut::Cin Cin;
	narut::Writer<cout, false> Cout;
	narut::Big Big;
	using narut::Arr;
	using narut::Fill;
	using ll = long long;
	#define FOR(i, j, n) for (int i = static_cast<int>(j); i < static_cast<int>(n); ++i)
	#define ROF(i, j, n) for (int i = static_cast<int>(n) - 1; i >= static_cast<int>(j); --i)
	#ifdef NARUT_LOCAL
	narut::Writer<cerr, true> Cerr;
	#define DBG(...) __VA_ARGS__
	#define Debug(...) Cerr(__VA_ARGS__)
	#else
	#define Debug(...) 0
	#define DBG(...)
	#endif
	#ifndef BADSEED
	#define BADSEED random_device{}()
	#endif

// clang-format on
// STUCK : READ THE PROBLEM CAREFULLY. LOOK AT ALL THE CONSTRAINTS

//FIXTHE DAMN SIEVE!!!

struct NonSieve {
	template <class T> auto PrimeFactorize(T num) const {
		vector<T> primes;
		uint cnt = 0;
		for (; num % 2 == 0; ++cnt, num /= 2)
			;
		if (cnt) primes.push_back(2);
		for (T p = 3; p * p <= num; p += 2) {
			for (cnt = 0; num % p == 0; ++cnt, num /= p)
				;
			if (cnt) primes.push_back(p);
		}
		if (num > 1) primes.push_back(num);
		return primes;
	}

	template <class T> auto PrimeCounts(T num) const {
		vector<pair<T, int>> primes;
		uint cnt = 0;
		for (; num % 2 == 0; ++cnt, num /= 2)
			;
		if (cnt) primes.emplace_back(2, cnt);
		for (T p = 3; p * p <= num; p += 2) {
			for (cnt = 0; num % p == 0; ++cnt, num /= p)
				;
			if (cnt) primes.emplace_back(p, cnt);
		}
		if (num > 1) primes.emplace_back(num, 1);
		return primes;
	}

	template <class T> auto PrimePowers(T num) const {
		vector<pair<T, T>> primes;
		T cnt = 1;
		for (; num % 2 == 0; cnt *= 2, num /= 2)
			;
		if (cnt != 1) primes.emplace_back(2, cnt);
		for (T p = 3; p * p <= num; p += 2) {
			for (cnt = 1; num % p == 0; cnt *= p, num /= p)
				;
			if (cnt != 1) primes.emplace_back(p, cnt);
		}
		if (num > 1) primes.emplace_back(num, num);
		return primes;
	}
};





const int cap = 1'000'000+1;

auto Run()
{
	long a, b;
	cin>>a>>b;

	NonSieve ns;
	auto pA = ns.PrimeFactorize(a);
	auto pB = ns.PrimeFactorize(b);

	vector<ll> pcommon;
	set_intersection(pA.begin(), pA.end(), begin(pB), end(pB), back_inserter(pcommon));
	cout << pcommon.size() + 1;

}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout << fixed << setprecision(10);
#ifdef NARUT_LOCAL
	cerr << fixed << setprecision(10);
	assert(freopen("./io/test.in", "r", stdin));
	// assert(freopen("./io/test.out", "w", stdout));
#endif

	Run();
}


Measured memory_bytes: 256