Problem: There are n houses in a row. They are numbered from 1 to n in order from left to right. Initially you are in the house 1.

You have to perform k moves to other house. In one move you go from your current house to some other house. You can't stay where you are (i.e., in each move the new house differs from the current house). If you go from the house x to the house y, the total distance you walked increases by |x-y| units of distance, where |a| is the absolute value of a. It is possible to visit the same house multiple times (but you can't visit the same house in sequence).

Your goal is to walk exactly s units of distance in total.

If it is impossible, print "NO". Otherwise print "YES" and any of the ways to do that. Remember that you should do exactly k moves.

Input

The first line of the input contains three integers n, k, s (2 ≤ n ≤ 10^9, 1 ≤ k ≤ 2 ⋅ 10^5, 1 ≤ s ≤ 10^{18}) — the number of houses, the number of moves and the total distance you want to walk.

Output

If you cannot perform k moves with total walking distance equal to s, print "NO".

Otherwise print "YES" on the first line and then print exactly k integers h_i (1 ≤ h_i ≤ n) on the second line, where h_i is the house you visit on the i-th move.

For each j from 1 to k-1 the following condition should be satisfied: h_j ≠ h_{j + 1}. Also h_1 ≠ 1 should be satisfied.

Examples

Input

10 2 15


Output

YES
10 4 


Input

10 9 45


Output

YES
10 1 10 1 2 1 2 1 6 


Input

10 9 81


Output

YES
10 1 10 1 10 1 10 1 10 


Input

10 9 82


Output

NO

Solution (in JAVA):

Solution:
import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

import java.io.*;
import java.lang.reflect.Array;
import java.math.*;
import java.util.*;


// author @mdazmat9
public class codeforces{


    public static void main(String[] args) throws IOException {

        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int test = 1;
        for (int ind = 0; ind < test; ind++) {
            long n=sc.nextLong();
            long k=sc.nextLong();
            long s=sc.nextLong();
            long step=s/k;
            if(step==0 || step>=n)
                out.println("NO");
            else if(step==n-1 && s%k!=0){
                out.println("NO");
            }
            else {
                out.println("YES");
                if (s % k == 0) {

                    long h = 1;
                    for (int i = 0; i < k; i++) {
                        h += step;
                        if (h > n) {
                            h -= 2 * step;
                        }
                        out.print(h + " ");
                        s -= step;
                    }
                } else {
                    long first_step = s - (k - 1) * step;
                    if (first_step <= n - 1) {
                        long h = 1;
                        for (int i = 0; i < k; i++) {
                            if (i == 0) {
                                h += first_step;
                                if (h > n) {
                                    h -= 2 * s;
                                }
                                out.print(h + " ");
                                s -= first_step;
                            } else {
                                h += step;
                                if (h > n) {
                                    h -= 2 * step;
                                }
                                out.print(h + " ");
                                s -= step;
                            }
                        }
                    }
                    else {
                        long h = 1;
                        long extra=s-(k*step);
                        for (int i = 0; i < k; i++) {
                            if(extra>0){
                                h+=(step+1);
                                if(h>n)
                                    h-=2*(step+1);
                                out.print(h+" ");
                                extra--;
                            }
                            else {
                                h+=(step);
                                if(h>n)
                                    h-=2*(step);
                                out.print(h+" ");
                            }
                        }


                    }
                }
            }
        }
        out.flush();
    }

    static    class nodes{
        ArrayList<Integer> list=new ArrayList<>();
        int k;
    }


    static long pr(long n)
    {
        long temp = n, sum = 0, product = 1;
        while (temp != 0)
        {

            // Fetching each digit of
            // the number
            long d = temp % 10;
            temp /= 10;
            product *= d;

        }

        return product;
    }
    static class Node {
        int index;
        boolean removable;
        List<Node> children = new ArrayList<>();
        Node parent;

        Node(int index) {
            this.index = index;
        }

        boolean isGood() {
            if (parent == null || !removable) {
                return false;
            }
            for (Node c : children) {
                if (!c.removable) {
                    return false;
                }
            }
            return true;
        }

    }


    public static double logb( double a, double b )
    {
        return Math.log(a) / Math.log(b);
    }

    static long fast_pow(long a, long b) {
        if(b == 0)
            return 1L;

        long val = fast_pow(a, b / 2);

        if(b % 2 == 0)
            return val * val % mod;
        else
            return val * val % mod * a % mod;
    }
    static long mod = (long)1e9 + 7;
    static   void shuffle(int[] a) {
        int n = a.length;
        for(int i = 0; i < n; i++) {
            int r = i + (int) (Math.random() * (n - i));
            int tmp = a[i];
            a[i] = a[r];
            a[r] = tmp;
        }
    }
    static long gcd(long a , long b)
    {
        if(b == 0)
            return a;
        return gcd(b , a % b);
    }

}
class Scanner {
    public BufferedReader reader;
    public StringTokenizer st;

    public Scanner(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        st = null;
    }

    public String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                String line = reader.readLine();
                if (line == null) return null;
                st = new StringTokenizer(line);
            } catch (Exception e) {
                throw (new RuntimeException());
            }
        }
        return st.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

class OutputWriter {
    BufferedWriter writer;

    public OutputWriter(OutputStream stream) {
        writer = new BufferedWriter(new OutputStreamWriter(stream));
    }

    public void print(int i) throws IOException {
        writer.write(i);
    }

    public void print(String s) throws IOException {
        writer.write(s);
    }

    public void print(char[] c) throws IOException {
        writer.write(c);
    }

    public void close() throws IOException {
        writer.close();
    }

}
class Pair {
    int x;
    int y;

    // Constructor
    public Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}
class Compare {

    static void compare(Pair arr[], int n)
    {
        // Comparator to sort the pair according to second element
        Arrays.sort(arr, new Comparator<Pair>() {
            @Override public int compare(Pair p1, Pair p2)
            {
                return p1.x - p2.x;
            }
        });
    }
}

class Graph {

    int V;
    ArrayList<Integer>[] adjListArray;

    // constructor
    Graph(int V) {
        this.V = V;

        adjListArray = new ArrayList[V];

        for (int i = 0; i < V; i++) {
            adjListArray[i] = new ArrayList<>();
        }
    }

    // Adds an edge to an undirected graph
    void addEdge(int src, int dest) {

        adjListArray[src].add(dest);
        adjListArray[dest].add(src);
    }


    ArrayList<Integer> DFSUtil(int u, boolean visited[], int parent,ArrayList<Integer> list)
    {
        // Mark the current node as visited
        visited[u] = true;

        for (int i = 0; i < adjListArray[u].size(); i++) {
            int n = adjListArray[u].get(i);
            list.add(n);

            if (!visited[i]) {
                DFSUtil(n, visited, u,list);
            }
        }
        return list;

    }


    // The function to do DFS traversal. It uses recursive DFSUtil()
    void DFS(int r,int c) {
        // Mark all the vertices as not visited(set as
        // false by default in java)
        boolean visited[] = new boolean[V];
        ArrayList<Integer> list=new ArrayList<>();
        // Call the recursive helper function to print DFS traversal
        boolean bool=true;

    }


}