from typing import List, Tuple, Callable, TypeVar, Optional import sys import itertools import heapq import bisect import math from collections import deque, defaultdict from functools import lru_cache, cmp_to_key import string input = sys.stdin.readline if __file__ != 'prog.py': sys.setrecursionlimit(10 ** 6) def readints(): return map(int, input().split()) def readlist(): return list(readints()) def readstr(): return input()[:-1] def extgcd(a: int, b: int) -> Tuple[int, int, int]: """solve ax + by = gcd(a, b)""" x, y, u, v = 1, 0, 0, 1 while b: q, r = divmod(a, b) x -= q * u y -= q * v x, u = u, x y, v = v, y a, b = b, r return a, x, y def crt(P: Tuple[int, int]) -> Tuple[int, int]: """return the smallest x that satisfies x ≡ a (mod m) for all (a, m) pairs and lcm(M) # reference: https://qiita.com/drken/items/ae02240cd1f8edfc86fd """ """ if there exist x s.t. x ≡ a1 (mod m1) and x ≡ a2 (mod m2), let g = gcd(m1, m2). since m1 and m2 are multiple of g, x ≡ a1 (mod g) and x ≡ a2 (mod g). therefore a1 ≡ a2 (mod g). there exist (p, q) s.t. m1 * p + m2 * q = gcd(m1, m2). (this can be obtained by extgcd) let g = gcd(m1, m2) and s = (a2 - a1) / g then m1 * p + m2 * q = g <=> m1 * p + m2 * q = (a2 - a1) / s <=> s * m1 * p + s * m2 * q = a2 - a1 <=> a1 + s + m1 + p = a2 - s * m2 * q let x = a1 + s * m1 * p (= a2 - s * m2 * q) then x ≡ a1 (mod m1), x ≡ a2 (mod m2). """ r = 0 M = 1 for a, m in P: g, p, q = extgcd(M, m) if (a - r) % g != 0: return (0, -1) s = (a - r) // g tmp = s * p % (m // g) r += M * tmp M *= m // g return (r, M) P = [tuple(readints()) for _ in range(3)] ans, lcm = crt(P) print(ans if lcm != -1 else -1)