Vasya has got three integers n, m and k. He'd like to find three integer points (x_1, y_1), (x_2, y_2), (x_3, y_3), such that 0 ≤ x_1, x_2, x_3 ≤ n, 0 ≤ y_1, y_2, y_3 ≤ m and the area of the triangle formed by these points is equal to nm/k.

Help Vasya! Find such points (if it's possible). If there are multiple solutions, print any of them.

Input

The single line contains three integers n, m, k (1≤ n, m ≤ 10^9, 2 ≤ k ≤ 10^9).

Output

If there are no such points, print "NO".

Otherwise print "YES" in the first line. The next three lines should contain integers x_i, y_i — coordinates of the points, one point per line. If there are multiple solutions, print any of them.

You can print each letter in any case (upper or lower).

Examples

Input

4 3 3


Output

YES
1 0
2 3
4 1


Input

4 4 7


Output

NO

Note

In the first example area of the triangle should be equal to nm/k = 4. The triangle mentioned in the output is pictured below: 

<image>

In the second example there is no triangle with area nm/k = 16/7.
from collections import Counter as __Counter
import sys as __sys


def find_points_vasya_want(size_x, size_y, k):
    if 2*size_x*size_y % k != 0:
        raise ValueError("can't make such triangle")
    
    size_x_factors = __represent_as_prime_factors(size_x)
    size_y_factors = __represent_as_prime_factors(size_y)
    k_factors = __represent_as_prime_factors(k)
    
    x_factors = size_x_factors.copy()
    y_factors = size_y_factors.copy()
    # need to multiply x*y by 2/k
    # 2*x*y % k == 0
    
    if 2 in k_factors:
        __remove_one_prime_factor(k_factors, 2)
    else:
        max_k_factor = max(k_factors)
        if max_k_factor in x_factors:
            __remove_one_prime_factor(x_factors, max_k_factor)
            __add_one_prime_factor(x_factors, 2)
        else:
            __remove_one_prime_factor(y_factors, max_k_factor)
            __add_one_prime_factor(y_factors, 2)
        __remove_one_prime_factor(k_factors, max_k_factor)
    
    for x_factor in tuple(x_factors.keys()):
        if x_factor in k_factors:
            disappear_n = min(x_factors[x_factor], k_factors[x_factor])
            __remove_n_prime_factors(x_factors, x_factor, disappear_n)
            __remove_n_prime_factors(k_factors, x_factor, disappear_n)
    
    for y_factor in tuple(y_factors.keys()):
        if y_factor in k_factors:
            disappear_n = min(y_factors[y_factor], k_factors[y_factor])
            __remove_n_prime_factors(y_factors, y_factor, disappear_n)
            __remove_n_prime_factors(k_factors, y_factor, disappear_n)
    
    assert not k_factors
    x = __prime_factors_to_number(x_factors)
    y = __prime_factors_to_number(y_factors)
    return [
        (0, 0),
        (x, 0),
        (0, y)
    ]


def __represent_as_prime_factors(x):
    assert isinstance(x, int)
    assert x >= 1
    
    result = dict()
    factor_to_check = 2
    while factor_to_check ** 2 <= x:
        if x % factor_to_check == 0:
            result[factor_to_check] = __count_factor(x, factor_to_check)
            x //= factor_to_check ** result[factor_to_check]
        factor_to_check += 1
    if x != 1:
        result[x] = 1
    
    return __Counter(result)


def __prime_factors_to_number(x_factors):
    result = 1
    for factor, factor_count in x_factors.items():
        result *= factor ** factor_count
    return result


def __count_factor(x, factor):
    result = 0
    while x % factor == 0:
        x //= factor
        result += 1
    return result


def __add_one_prime_factor(x_factors, factor):
    if factor not in x_factors:
        x_factors[factor] = 0
    x_factors[factor] += 1


def __remove_one_prime_factor(x_factors, factor):
    __remove_n_prime_factors(x_factors, factor, 1)


def __remove_n_prime_factors(x_factors, factor, n):
    assert factor in x_factors and x_factors[factor] >= n
    x_factors[factor] -= n
    if x_factors[factor] == 0:
        del x_factors[factor]


def __main():
    n, m, k = __read_ints()
    try:
        points = find_points_vasya_want(n, m, k)
    except ValueError:
        print("NO")
    else:
        print("YES")
        for x, y in points:
            print(x, y)


def __read_line():
    result = __sys.stdin.readline()
    assert result[-1] == "\n"
    return result[:-1]


def __read_ints():
    return map(int, __read_line().split())


if __name__ == '__main__':
    __main()
