Problem: Students love to celebrate their holidays. Especially if the holiday is the day of the end of exams!

Despite the fact that Igor K., unlike his groupmates, failed to pass a programming test, he decided to invite them to go to a cafe so that each of them could drink a bottle of... fresh cow milk. Having entered the cafe, the m friends found n different kinds of milk on the menu, that's why they ordered n bottles — one bottle of each kind. We know that the volume of milk in each bottle equals w.

When the bottles were brought in, they decided to pour all the milk evenly among the m cups, so that each got a cup. As a punishment for not passing the test Igor was appointed the person to pour the milk. He protested that he was afraid to mix something up and suggested to distribute the drink so that the milk from each bottle was in no more than two different cups. His friends agreed but they suddenly faced the following problem — and what is actually the way to do it?

Help them and write the program that will help to distribute the milk among the cups and drink it as quickly as possible!

Note that due to Igor K.'s perfectly accurate eye and unswerving hands, he can pour any fractional amount of milk from any bottle to any cup.

Input

The only input data file contains three integers n, w and m (1 ≤ n ≤ 50, 100 ≤ w ≤ 1000, 2 ≤ m ≤ 50), where n stands for the number of ordered bottles, w stands for the volume of each of them and m stands for the number of friends in the company.

Output

Print on the first line "YES" if it is possible to pour the milk so that the milk from each bottle was in no more than two different cups. If there's no solution, print "NO".

If there is a solution, then print m more lines, where the i-th of them describes the content of the i-th student's cup. The line should consist of one or more pairs that would look like "b v". Each such pair means that v (v > 0) units of milk were poured into the i-th cup from bottle b (1 ≤ b ≤ n). All numbers b on each line should be different.

If there are several variants to solve the problem, print any of them. Print the real numbers with no less than 6 digits after the decimal point.

Examples

Input

2 500 3


Output

YES
1 333.333333
2 333.333333
2 166.666667 1 166.666667


Input

4 100 5


Output

YES
3 20.000000 4 60.000000
1 80.000000
4 40.000000 2 40.000000
3 80.000000
2 60.000000 1 20.000000


Input

4 100 7


Output

NO


Input

5 500 2


Output

YES
4 250.000000 5 500.000000 2 500.000000
3 500.000000 1 500.000000 4 250.000000

Solution (in JAVA):

Solution:
import java.math.*;
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class CF76B {
    public static void main(String[] args) throws IOException {
        int n = nextInt(), w = nextInt(), m = nextInt();
        double T = n * w;
        double C = T * 1.0 / m;
        double eps = 1e-9;
        
        ArrayList<Integer>[] Bs = null;
        ArrayList<Double>[] Vs = null;
        for (int inOne = 0; inOne <= n; inOne++) {
            double[] left = new double[m];
            ArrayList<Integer>[] bs = new ArrayList[m];
            ArrayList<Double>[] vs = new ArrayList[m];
            for (int i = 0; i < m; i++) {
                bs[i] = new ArrayList<Integer>();
                vs[i] = new ArrayList<Double>();
            }
            fill(left, C);
            int b = 0;
            for (int j = 0; b < inOne && j < m; b++) {
                if (left[j] >= w) {
                    left[j] -= w;
                    bs[j].add(b + 1);
                    vs[j].add((double) w);
                } else {
                    j++;
                    b--;
                }
            }
            if (b < inOne) {
                continue;
            }
            boolean can = true;
            int inTwo = n - inOne;
            
            for (int t = 0; t < inTwo; t++) {
                double toStore = w;
                int i = -1, j = -1;
                for (int k = 0; k < m; k++) {
                    if (j < 0 || left[j] < left[k])
                        j = k;
                }
                for (int k = 0; k < m; k++) {
                    if (k != j && left[k] > eps && (i < 0 || (left[i] > left[k] && left[j] + left[k] + eps >= toStore)))
                        i = k;
                }
                if (i >= 0 && j >= 0 && i != j && left[i] + left[j] + eps >= toStore) {
                    double parta = left[i];
                    double partb = left[j];

                    left[i] -= min(parta, toStore);
                    toStore -= abs(parta - left[i]);
                    
                    left[j] -= min(partb, toStore);
                    toStore -= abs(partb - left[j]);
                    
                    assert toStore <= eps;
                    
                    bs[i].add(t + inOne + 1);
                    vs[i].add(abs(parta - left[i]));
                    
                    bs[j].add(t + inOne + 1);
                    vs[j].add(abs(partb - left[j]));
                }
                
                if (toStore > eps) {
                    can = false;
                    break;
                }
            }
            
            if (can) {
                Bs = bs;
                Vs = vs;
            }
        }
        if (Bs == null) {
            System.out.println("NO");
        } else {
            System.out.println("YES");
            for (int i = 0; i < Vs.length; i++) {
                for (int j = 0; j < Vs[i].size(); j++) {
                    System.out.print(Bs[i].get(j) + " " + Vs[i].get(j) + " ");
                }
                System.out.println();
            }
        }
    }

    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st = new StringTokenizer("");

    static String next() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    static void DBG(Object... objects) {
        System.err.println(deepToString(objects));
    }

    static int RAND(int from, int to) {
        return (int) (random() * (to - from + 1)) + from;
    }

}