Two little greedy bears have found two pieces of cheese in the forest of weight *a* and *b* grams, correspondingly. The bears are so greedy that they are ready to fight for the larger piece. That's where the fox comes in and starts the dialog: "Little bears, wait a little, I want to make your pieces equal" "Come off it fox, how are you going to do that?", the curious bears asked. "It's easy", said the fox. "If the mass of a certain piece is divisible by two, then I can eat exactly a half of the piece. If the mass of a certain piece is divisible by three, then I can eat exactly two-thirds, and if the mass is divisible by five, then I can eat four-fifths. I'll eat a little here and there and make the pieces equal". 

The little bears realize that the fox's proposal contains a catch. But at the same time they realize that they can not make the two pieces equal themselves. So they agreed to her proposal, but on one condition: the fox should make the pieces equal as quickly as possible. Find the minimum number of operations the fox needs to make pieces equal.
The first line contains two space-separated integers *a* and *b* (1 ≤ *a*, *b* ≤ 10<sup class="upper-index">9</sup>).
import sys
from collections import defaultdict
import math


VALID = {2, 3, 5}
def get_primes(n, primes, sieve) -> list[int]:
    if sieve[n]:
        return [n]
    result = []
    for prime in primes:
        # if n is not prime, it will be the product of two ints a and b, where one of them has to be at most sqrt(n)
        if n < prime * prime:
            break
        while n % prime == 0:
            n //= prime
            result.append(prime)
    if n > 1:
        result.append(n)
    return result



def compute_sieve(n) -> tuple[list[int], list[int]]:
    # nloglogn bvy the prime number theorem
    primes = []
    sieve = [1] * (n + 1)
    sieve[0] = sieve[1] = 0
    for i in range(2, n + 1):
        if sieve[i] == 1:
            for j in range(i * i, n + 1, i):
                sieve[j] = 0
            primes.append(i)
    return sieve, primes


def main() -> None:
    read = sys.stdin.readline
    a, b = (int(i) for i in read().split())
    if a == b:
        print(0)
        return
    sieve, primes = compute_sieve(int(math.sqrt(1e9)))
    a_primes = get_primes(a, primes, sieve)
    b_primes = get_primes(b, primes, sieve)

    a_primes_dict = defaultdict(lambda: 0)
    b_primes_dict = defaultdict(lambda: 0)
    for p in a_primes:
        a_primes_dict[p] += 1
    for p in b_primes:
        b_primes_dict[p] += 1

    cost = 0
    # del everything not in common

    keys_to_del = []
    for p in a_primes_dict.keys():
        if p not in b_primes_dict and p in VALID:
            cost += a_primes_dict[p]
            keys_to_del.append(p)
    for k in keys_to_del:
        del a_primes_dict[k]

    keys_to_del = []


    for p in b_primes_dict.keys():
        if p not in a_primes_dict and p in VALID:
            cost += b_primes_dict[p]
            keys_to_del.append(p)

    for k in keys_to_del:
        del b_primes_dict[k]


    if len(a_primes_dict) != len(b_primes_dict):
        print(-1)
        return

    for p in a_primes_dict.keys():
        if a_primes_dict[p] != b_primes_dict[p]:
            cost += min(a_primes_dict[p], b_primes_dict[p])

    print(cost)


if __name__ == '__main__':
    main()