Problem: Consider a [billiard table](https://en.wikipedia.org/wiki/Billiard_table) of rectangular size n × m with four pockets. Let's introduce a coordinate system with the origin at the lower left corner (see the picture). 

<image>

There is one ball at the point (x, y) currently. Max comes to the table and strikes the ball. The ball starts moving along a line that is parallel to one of the axes or that makes a 45^{\circ} angle with them. We will assume that: 

  1. the angles between the directions of the ball before and after a collision with a side are equal, 
  2. the ball moves indefinitely long, it only stops when it falls into a pocket, 
  3. the ball can be considered as a point, it falls into a pocket if and only if its coordinates coincide with one of the pockets, 
  4. initially the ball is not in a pocket. 



Note that the ball can move along some side, in this case the ball will just fall into the pocket at the end of the side.

Your task is to determine whether the ball will fall into a pocket eventually, and if yes, which of the four pockets it will be.

Input

The only line contains 6 integers n, m, x, y, v_x, v_y (1 ≤ n, m ≤ 10^9, 0 ≤ x ≤ n; 0 ≤ y ≤ m; -1 ≤ v_x, v_y ≤ 1; (v_x, v_y) ≠ (0, 0)) — the width of the table, the length of the table, the x-coordinate of the initial position of the ball, the y-coordinate of the initial position of the ball, the x-component of its initial speed and the y-component of its initial speed, respectively. It is guaranteed that the ball is not initially in a pocket.

Output

Print the coordinates of the pocket the ball will fall into, or -1 if the ball will move indefinitely.

Examples

Input

4 3 2 2 -1 1


Output

0 0

Input

4 4 2 0 1 1


Output

-1

Input

10 10 10 1 -1 0


Output

-1

Note

The first sample: 

<image>

The second sample: 

<image>

In the third sample the ball will never change its y coordinate, so the ball will never fall into a pocket.

Solution (in PYTHON3):

Solution:
inp = input().split(' ')
inp = [int(x) for x in inp]

n, m, x, y, vx, vy = inp

def mcd(a, b):
    '''
    Función vista en clases para calcular el MCD entre
    2 números a y b
    '''
    if a == 0 and b == 0:
        print("ERROR")
    elif a == 0:
        return(b)
    elif b == 0:
        return(a)
    elif a >= b:
        return mcd(b, a % b)
    else:
        return mcd(a, b % a)

def mcm(a,b):
    return(int((a*b)/mcd(a,b)))

def floor(a):
    # Calcula el floor de un número, es decir, su parte entera
    return(int(a//1))

def inverso(a,n):
    '''
    Algoritmo visto en clases para calcular el inverso
    de un numero a en mod n
    '''
    if mcd(a, n) > 1:
        raise Exception('No existe inverso')
    else:
        s0, t0, s1, t1, r0, r1 = (1, 0, 0, 1, n, a)
    while r1 > 1:
        aux_s = s0 - floor(r0/r1)*s1
        s0 = s1
        s1 = aux_s
        aux_t = t0 - (floor(r0/r1) * t1)
        t0 = t1
        t1 = aux_t
        r0 = r1
        r1 = (s1 * n) + (t1 * a)
    if t1 < 0:
        t1 += n
    return(t1)

def euclides_extendido(a, n):
    '''
    Es parecido al algoritmo 'inverso', pero con una pequeña modificación
    para que retorne s y dist cuando r1 = mcd(a, n)
    '''
    s0, t0, s1, t1, r0, r1 = (1, 0, 0, 1, n, a)
    mcd_aux = mcd(a,n)
    while r1 > mcd_aux:
        aux_s = s0 - floor(r0/r1)*s1
        s0 = s1
        s1 = aux_s
        aux_t = t0 - (floor(r0/r1) * t1)
        t0 = t1
        t1 = aux_t
        r0 = r1
        r1 = (s1 * n) + (t1 * a)
    return(t1, s1)
        


# CASO BASE 1: borde del lado (izq o dcho) y tiro vertical (para arriba o abajo)
# En este caso la pelota ENTRA a una esquina
if (x == 0 or x == n) and vx == 0 and vy != 0:
    if (abs(vy)/vy) == 1: # Esquina de arriba
        print(x, m)
    else: # Esquina de abajo
        print(x, 0)

# CASO BASE 2: borde de arriba o abajo y tiro horizontal (izq o dcha)
# En este caso la pelota ENTRA a una esquina
elif (y == 0 or y == m) and vy == 0 and vx != 0:
    if (abs(vx)/vx) == 1: # Esquina derecha
        print(n, y)
    else: # Esquina izquierda
        print(0, y)

# CASO BASE 3: borde del lado (izq o dcho) y tiro horizontal (izq o dcha)
# En este caso la pelota NO ENTRA a una esquina
elif (x == 0 or x == n) and vx != 0 and vy == 0:
    print(-1)

# CASO BASE 4: borde de arriba o abajo y tiro vertical (arriba o abajo)
# En este caso la pelota NO ENTRA a una esquina
elif (y == 0 or y == m) and vy != 0 and vx == 0:
    print(-1)

# CASO ABSE 5: ningún borde, y tiro horizontal o vertical
# En este caso la pelota NO ENTRA a una esquina
elif (x != 0 and y != 0 and x != n and y != m) and ((vx != 0 and vy == 0) or (vy != 0 and vx == 0)):
    print(-1)

# CASO BASE 6: tiro no tiene velocidad en ningún sentido
# En este caso la pelota NO ENTRA a una esquina
elif (vx == 0 and vy == 0):
    print(-1)

# EL RESTO DE LOS CASOS DE AQUÍ EN ADELANTE SON TIROS DIAGONALES (45º),
# PARTIENDO DESDE CUALQUIER LUGAR (MENOS ESQUINAS)
# ES DECIR CON vx != 0 y vy != 0
elif vx != 0 and vy != 0:
    if vy > 0:
        a1 = m - y
    else:
        a1 = y
    if vx > 0:
        a2 = n - x
    else:
        a2 = x

    if mcd(n,m) == 1: # Si MCD(m,n) = 1 --> Utilizamos el teorema del resto chino
        # La fórmula de abajo la saque de: https://www.youtube.com/watch?v=qpmV5wlEfzs
        dist = (a1*n*inverso(n, m)+a2*m*inverso(m, n))%(n*m)

        reb_y = (dist-a1)/m  # Cantidad de rebotes en y
        reb_x = (dist-a2)/n  # Cantidad de rebotes en x
        if ((vy > 0) and (reb_y % 2 != 0)) or ((vy < 0) and (reb_y % 2 == 0)): # Esquina de abajo
            up_down = 0
        else: # Esquina de arriba
            up_down = m
        if ((vx > 0) and (reb_x % 2 != 0)) or ((vx < 0) and (reb_x % 2 == 0)): # Esquina izquierda
            right_left = 0
        else: # Esquina derecha
            right_left = n
        print(right_left, up_down)
        
    else:
        if (a1 - a2) % mcd(m, n) != 0: # Si MCD(m,n) no divide a (y-x) --> NO HAY SOLUCIÓN
            print(-1) 
        else: # MCD(m,n) divide a (y-x) --> Hay solución, pero m y n son coprimos 
            try:
                g = mcd(n,m)
                a1_aux, a2_aux, n_aux, m_aux = (-vx*x) % n, (-vy*y) % m, n, m
                if mcd(n//g,m) == 1:
                    n_aux = n // g
                else:
                    m_aux = m // g
                dist = (a1_aux*inverso(m_aux,n_aux)*m_aux + a2_aux*inverso(n_aux,m_aux)*n_aux) % (n_aux*m_aux)

                reb_y = (dist-a1)/m  # Cantidad de rebotes en y
                reb_x = (dist-a2)/n  # Cantidad de rebotes en x
                
                if ((vy > 0) and (reb_y % 2 != 0)) or ((vy < 0) and (reb_y % 2 == 0)): # Esquina de abajo
                    up_down = 0
                else: # Esquina de arriba
                    up_down = m
                if ((vx > 0) and (reb_x % 2 != 0)) or ((vx < 0) and (reb_x % 2 == 0)): # Esquina izquierda
                    right_left = 0
                else: # Esquina derecha
                    right_left = n
                print(right_left, up_down)
            except:
                print(-1)