import java.io.*;
import java.util.*;

/**
 * @author baito
 */
@SuppressWarnings("unchecked")
public class Main
{
    static StringBuilder sb = new StringBuilder();
    static FastScanner sc = new FastScanner(System.in);
    static int INF = 1234567890;
    static long LINF = 123456789123456789L;
    static long MINF = -123456789123456789L;
    static long MOD = 1000000007;
    static int[] y4 = {0, 1, 0, -1};
    static int[] x4 = {1, 0, -1, 0};
    static int[] y8 = {0, 1, 0, -1, -1, 1, 1, -1};
    static int[] x8 = {1, 0, -1, 0, 1, -1, 1, -1};
    static long[] Fa;//factorial
    static boolean[] isPrime;
    static int[] primes;
    static char[][] map;

    static long N, M, K;
    static long S;
    static int[] A;

    public static void main(String[] args)
    {
        //longを忘れるなオーバーフローするぞ
        N = sc.nextInt();
        K = sc.nextInt();
        S = sc.nextLong();
        if ((N - 1) * K < S)
        {
            System.out.println("NO");
            return;
        }
        long cou = binarysearch(0, K + 1);
        int vec = 1;
        int now = 1;
        for (int i = 0; i < cou; i++)
        {
            sb.append(now + (N - 1) * vec + " ");
            now += (N - 1) * vec;
            vec *= -1;
        }
        long ama = S - cou * (N - 1);
        long k = K - cou;
        if (k == 0)
        {
            System.out.println("YES");
            System.out.println(sb.toString());
            return;
        }
        long base = ama / k;
        long bigko = ama - base * k;
        for (int i = 0; i < bigko; i++)
        {
            sb.append(now + (base + 1) * vec + " ");
            now += (base + 1) * vec;
            vec *= -1;
        }
        for (int i = 0; i < k - bigko; i++)
        {
            sb.append(now + (base) * vec + " ");
            now += (base) * vec;
            vec *= -1;
        }
        System.out.println("YES");
        System.out.println(sb.toString());
    }

    public static boolean solve(long v)
    {
        return S - (N - 1) * v >= K - v;
    }

    //条件を満たす最大値、あるいは最小値を求める
    static long binarysearch(long ok, long ng)
    {
        //int ok = 0; //解が存在する
        //int ng = N; //解が存在しない
        while (Math.abs(ok - ng) > 1)
        {
            long mid;
            if (ok < 0 && ng > 0 || ok > 0 && ng < 0) mid = (ok + ng) / 2;
            else mid = ok + (ng - ok) / 2;

            if (solve(mid))
            {
                ok = mid;
            }
            else
            {
                ng = mid;
            }
        }
        return ok;
    }

    public static int upper0(int a)
    {
        if (a < 0) return 0;
        return a;
    }

    public static long upper0(long a)
    {
        if (a < 0) return 0;
        return a;
    }

    public static Integer[] toIntegerArray(int[] ar)
    {
        Integer[] res = new Integer[ar.length];
        for (int i = 0; i < ar.length; i++)
        {
            res[i] = ar[i];
        }
        return res;
    }

    //k個の次の組み合わせをビットで返す 大きさに上限はない 110110 -> 111001
    public static int nextCombSizeK(int comb, int k)
    {
        int x = comb & -comb; //最下位の1
        int y = comb + x; //連続した下の1を繰り上がらせる
        return ((comb & ~y) / x >> 1) | y;
    }

    public static int keta(long num)
    {
        int res = 0;
        while (num > 0)
        {
            num /= 10;
            res++;
        }
        return res;
    }

    public static long getHashKey(int a, int b)
    {
        return (long) a << 32 | b;
    }

    public static boolean isOutofIndex(int x, int y)
    {
        if (x < 0 || y < 0) return true;
        if (map[0].length <= x || map.length <= y) return true;
        return false;
    }

    public static void setPrimes()
    {
        int n = 100001;
        isPrime = new boolean[n];
        List<Integer> prs = new ArrayList<>();
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        for (int i = 2; i * i <= n; i++)
        {
            if (!isPrime[i]) continue;
            prs.add(i);
            for (int j = i * 2; j < n; j += i)
            {
                isPrime[j] = false;
            }
        }
        primes = new int[prs.size()];
        for (int i = 0; i < prs.size(); i++)
            primes[i] = prs.get(i);
    }

    public static void revSort(int[] a)
    {
        Arrays.sort(a);
        reverse(a);
    }

    public static void revSort(long[] a)
    {
        Arrays.sort(a);
        reverse(a);
    }

    public static int[][] copy(int[][] ar)
    {
        int[][] nr = new int[ar.length][ar[0].length];
        for (int i = 0; i < ar.length; i++)
            for (int j = 0; j < ar[0].length; j++)
                nr[i][j] = ar[i][j];
        return nr;
    }

    /**
     *
指定した値以上の先頭のインデクスを返す

     *
配列要素が０のときは、０が返る。

     *
     * @returnint ： 探索した値以上で、先頭になるインデクス
     * 値が無ければ、挿入できる最小のインデックス
     */
    public static int lowerBound(final int[] arr, final int value)
    {
        int low = 0;
        int high = arr.length;
        int mid;

        while (low < high)
        {
            mid = ((high - low) >>> 1) + low;    //(low + high) / 2 (オーバーフロー対策)
            if (arr[mid] < value)
            {
                low = mid + 1;
            }
            else
            {
                high = mid;
            }
        }
        return low;
    }

    /**
     *
指定した値より大きい先頭のインデクスを返す

     *
配列要素が０のときは、０が返る。

     *
     * @returnint ： 探索した値より上で、先頭になるインデクス
     * 値が無ければ、挿入できる最小のインデックス
     */
    public static int upperBound(final int[] arr, final int value)
    {
        int low = 0;
        int high = arr.length;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >>> 1) + low;    //(low + high) / 2 (オーバーフロー対策)
            if (arr[mid] <= value)
            {
                low = mid + 1;
            }
            else
            {
                high = mid;
            }
        }
        return low;
    }

    /**
     *
指定した値以上の先頭のインデクスを返す

     *
配列要素が０のときは、０が返る。

     *
     * @returnint ： 探索した値以上で、先頭になるインデクス
     * 値がなければ挿入できる最小のインデックス
     */
    public static long lowerBound(final long[] arr, final long value)
    {
        int low = 0;
        int high = arr.length;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >>> 1) + low;    //(low + high) / 2 (オーバーフロー対策)
            if (arr[mid] < value)
            {
                low = mid + 1;
            }
            else
            {
                high = mid;
            }
        }
        return low;
    }

    /**
     *
指定した値より大きい先頭のインデクスを返す

     *
配列要素が０のときは、０が返る。

     *
     * @returnint ： 探索した値より上で、先頭になるインデクス
     * 値がなければ挿入できる最小のインデックス
     */
    public static long upperBound(final long[] arr, final long value)
    {
        int low = 0;
        int high = arr.length;
        int mid;
        while (low < high)
        {
            mid = ((high - low) >>> 1) + low;    //(low + high) / 2 (オーバーフロー対策)
            if (arr[mid] <= value)
            {
                low = mid + 1;
            }
            else
            {
                high = mid;
            }
        }
        return low;
    }

    //次の順列に書き換える、最大値ならfalseを返す
    public static boolean nextPermutation(int A[])
    {
        int len = A.length;
        int pos = len - 2;
        for (; pos >= 0; pos--)
        {
            if (A[pos]  1)
        {
            int mid = (ok + ng) / 2;
            if (A[mid] > A[pos]) ok = mid;
            else ng = mid;

        }

        swap(A, pos, ok);
        reverse(A, pos + 1, len - 1);

        return true;
    }

    //次の順列に書き換える、最小値ならfalseを返す
    public static boolean prevPermutation(int A[])
    {
        int len = A.length;
        int pos = len - 2;
        for (; pos >= 0; pos--)
        {
            if (A[pos] > A[pos + 1]) break;
        }
        if (pos == -1) return false;

        //posより小さい最大の数を二分探索
        int ok = pos + 1;
        int ng = len;
        while (Math.abs(ng - ok) > 1)
        {
            int mid = (ok + ng) / 2;
            if (A[mid] < A[pos]) ok = mid;
            else ng = mid;

        }

        swap(A, pos, ok);
        reverse(A, pos + 1, len - 1);

        return true;
    }

    //↓nCrをmod計算するために必要。　***factorial(N)を呼ぶ必要がある***
    static long ncr(int n, int r)
    {
        if (n < r) return 0;
        else if (r == 0) return 1;

        factorial(n);
        return Fa[n] / (Fa[n - r] * Fa[r]);
    }

    static long ncr2(int a, int b)
    {
        if (b == 0) return 1;
        else if (a < b) return 0;
        long res = 1;
        for (int i = 0; i < b; i++)
        {
            res *= a - i;
            res /= i + 1;
        }
        return res;
    }

    static long ncrdp(int n, int r)
    {
        if (n < r) return 0;
        long[][] dp = new long[n + 1][r + 1];
        for (int ni = 0; ni < n + 1; ni++)
        {
            dp[ni][0] = dp[ni][ni] = 1;
            for (int ri = 1; ri < ni; ri++)
            {
                dp[ni][ri] = dp[ni - 1][ri - 1] + dp[ni - 1][ri];
            }
        }
        return dp[n][r];
    }

    static long modNcr(int n, int r)
    {
        if (n < r) return 0;
        long result = Fa[n];
        result = result * modInv(Fa[n - r]) % MOD;
        result = result * modInv(Fa[r]) % MOD;
        return result;
    }

    public static long modSum(long... lar)
    {
        long res = 0;
        for (long l : lar)
            res = (res + l % MOD) % MOD;
        if (res < 0) res += MOD;
        res %= MOD;
        return res;
    }

    public static long modDiff(long a, long b)
    {
        long res = a % MOD - b % MOD;
        if (res < 0) res += MOD;
        res %= MOD;
        return res;
    }

    public static long modMul(long... lar)
    {
        long res = 1;
        for (long l : lar)
            res = (res * l % MOD) % MOD;
        if (res < 0) res += MOD;
        res %= MOD;
        return res;
    }

    public static long modDiv(long a, long b)
    {
        long x = a % MOD;
        long y = b % MOD;
        long res = (x * modInv(y)) % MOD;
        return res;
    }

    static long modInv(long n)
    {
        return modPow(n, MOD - 2);
    }

    static void factorial(int n)
    {
        Fa = new long[n + 1];
        Fa[0] = Fa[1] = 1;
//        for (int i = 2; i <= n; i++)
//        {
//            Fa[i] = (Fa[i - 1] * i) % MOD;
//        }
        //
        for (int i = 2; i <= 100000; i++)
        {
            Fa[i] = (Fa[i - 1] * i) % MOD;
        }
        for (int i = 100001; i <= n; i++)
        {
            Fa[i] = (Fa[i - 1] * i) % MOD;
        }
    }

    static long modPow(long x, long n)
    {
        long res = 1L;
        while (n > 0)
        {
            if ((n & 1) == 1)
            {
                res = res * x % MOD;
            }
            x = x * x % MOD;
            n >>= 1;
        }
        return res;
    }

    //↑nCrをmod計算するために必要

    static int gcd(int n, int r)
    {
        return r == 0 ? n : gcd(r, n % r);
    }

    static long gcd(long n, long r)
    {
        return r == 0 ? n : gcd(r, n % r);
    }

    static <T> void swap(T[] x, int i, int j)
    {
        T t = x[i];
        x[i] = x[j];
        x[j] = t;
    }

    static void swap(int[] x, int i, int j)
    {
        int t = x[i];
        x[i] = x[j];
        x[j] = t;
    }

    public static void reverse(int[] x)
    {
        int l = 0;
        int r = x.length - 1;
        while (l < r)
        {
            int temp = x[l];
            x[l] = x[r];
            x[r] = temp;
            l++;
            r--;
        }
    }

    public static void reverse(long[] x)
    {
        int l = 0;
        int r = x.length - 1;
        while (l < r)
        {
            long temp = x[l];
            x[l] = x[r];
            x[r] = temp;
            l++;
            r--;
        }
    }

    public static void reverse(char[] x)
    {
        int l = 0;
        int r = x.length - 1;
        while (l < r)
        {
            char temp = x[l];
            x[l] = x[r];
            x[r] = temp;
            l++;
            r--;
        }
    }

    public static void reverse(int[] x, int s, int e)
    {
        int l = s;
        int r = e;
        while (l < r)
        {
            int temp = x[l];
            x[l] = x[r];
            x[r] = temp;
            l++;
            r--;
        }
    }

    static int length(int a)
    {
        int cou = 0;
        while (a != 0)
        {
            a /= 10;
            cou++;
        }
        return cou;
    }

    static int length(long a)
    {
        int cou = 0;
        while (a != 0)
        {
            a /= 10;
            cou++;
        }
        return cou;
    }

    static int cou(boolean[] a)
    {
        int res = 0;
        for (boolean b : a)
        {
            if (b) res++;
        }
        return res;
    }

    static int cou(String s, char c)
    {
        int res = 0;
        for (char ci : s.toCharArray())
        {
            if (ci == c) res++;
        }
        return res;
    }

    static int countC2(char[][] a, char c)
    {
        int co = 0;
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++)
                if (a[i][j] == c) co++;
        return co;
    }

    static int countI(int[] a, int key)
    {
        int co = 0;
        for (int i = 0; i < a.length; i++)
            if (a[i] == key) co++;
        return co;
    }

    static int countI(int[][] a, int key)
    {
        int co = 0;
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++)
                if (a[i][j] == key) co++;
        return co;
    }

    static void fill(int[][] a, int v)
    {
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++)
                a[i][j] = v;
    }

    static void fill(long[][] a, long v)
    {
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++)
                a[i][j] = v;
    }

    static void fill(int[][][] a, int v)
    {
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a[0].length; j++)
                for (int k = 0; k < a[0][0].length; k++)
                    a[i][j][k] = v;
    }

    static int max(int... a)
    {
        int res = Integer.MIN_VALUE;
        for (int i : a)
        {
            res = Math.max(res, i);
        }
        return res;
    }

    static long min(long... a)
    {
        long res = Long.MAX_VALUE;
        for (long i : a)
        {
            res = Math.min(res, i);
        }
        return res;
    }

    static int max(int[][] ar)
    {
        int res = Integer.MIN_VALUE;
        for (int i[] : ar)
            res = Math.max(res, max(i));
        return res;
    }

    static int min(int... a)
    {
        int res = Integer.MAX_VALUE;
        for (int i : a)
        {
            res = Math.min(res, i);
        }
        return res;
    }

    static int min(int[][] ar)
    {
        int res = Integer.MAX_VALUE;
        for (int i[] : ar)
            res = Math.min(res, min(i));
        return res;
    }

    static int sum(int[] a)
    {
        int cou = 0;
        for (int i : a)
            cou += i;
        return cou;
    }

    static int abs(int a)
    {
        return Math.abs(a);
    }

    static class FastScanner
    {

        private BufferedReader reader = null;
        private StringTokenizer tokenizer = null;

        public FastScanner(InputStream in)
        {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

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

        /*public String nextChar(){
            return (char)next()[0];
        }*/
        public String nextLine()
        {
            if (tokenizer == null || !tokenizer.hasMoreTokens())
            {
                try
                {
                    return reader.readLine();
                } catch (IOException e)
                {
                    throw new RuntimeException(e);
                }
            }

            return tokenizer.nextToken("\n");
        }

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

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

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

        public int[] nextIntArray(int n)
        {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }

        public int[] nextIntArrayOneIndex(int n)
        {
            int[] a = new int[n + 1];
            for (int i = 1; i < n + 1; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }

        public int[] nextIntArrayDec(int n)
        {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt() - 1;
            }
            return a;
        }

        public int[][] nextIntArray2(int h, int w)
        {
            int[][] a = new int[h][w];
            for (int hi = 0; hi < h; hi++)
            {
                for (int wi = 0; wi < w; wi++)
                {
                    a[hi][wi] = nextInt();
                }
            }
            return a;
        }

        public int[][] nextIntArray2Dec(int h, int w)
        {
            int[][] a = new int[h][w];
            for (int hi = 0; hi < h; hi++)
            {
                for (int wi = 0; wi < w; wi++)
                {
                    a[hi][wi] = nextInt() - 1;
                }
            }
            return a;
        }

        //複数の配列を受け取る
        public void nextIntArrays2ar(int[] a, int[] b)
        {
            for (int i = 0; i < a.length; i++)
            {
                a[i] = sc.nextInt();
                b[i] = sc.nextInt();
            }
        }

        public void nextIntArrays2arDec(int[] a, int[] b)
        {
            for (int i = 0; i < a.length; i++)
            {
                a[i] = sc.nextInt() - 1;
                b[i] = sc.nextInt() - 1;
            }
        }

        //複数の配列を受け取る
        public void nextIntArrays3ar(int[] a, int[] b, int[] c)
        {
            for (int i = 0; i < a.length; i++)
            {
                a[i] = sc.nextInt();
                b[i] = sc.nextInt();
                c[i] = sc.nextInt();
            }
        }

        //複数の配列を受け取る
        public void nextIntArrays3arDecLeft2(int[] a, int[] b, int[] c)
        {
            for (int i = 0; i < a.length; i++)
            {
                a[i] = sc.nextInt() - 1;
                b[i] = sc.nextInt() - 1;
                c[i] = sc.nextInt();
            }
        }

        public Integer[] nextIntegerArray(int n)
        {
            Integer[] a = new Integer[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextInt();
            }
            return a;
        }

        public char[] nextCharArray(int n)
        {
            char[] a = next().toCharArray();

            return a;
        }

        public char[][] nextCharArray2(int h, int w)
        {
            char[][] a = new char[h][w];
            for (int i = 0; i < h; i++)
            {
                a[i] = next().toCharArray();
            }
            return a;
        }

        //スペースが入っている場合
        public char[][] nextCharArray2s(int h, int w)
        {
            char[][] a = new char[h][w];
            for (int i = 0; i < h; i++)
            {
                a[i] = nextLine().replace(" ", "").toCharArray();
            }
            return a;
        }

        public char[][] nextWrapCharArray2(int h, int w, char c)
        {
            char[][] a = new char[h + 2][w + 2];
            //char c = '*';
            int i;
            for (i = 0; i < w + 2; i++)
                a[0][i] = c;
            for (i = 1; i < h + 1; i++)
            {
                a[i] = (c + next() + c).toCharArray();
            }
            for (i = 0; i < w + 2; i++)
                a[h + 1][i] = c;
            return a;
        }

        //スペースが入ってる時用
        public char[][] nextWrapCharArray2s(int h, int w, char c)
        {
            char[][] a = new char[h + 2][w + 2];
            //char c = '*';
            int i;
            for (i = 0; i < w + 2; i++)
                a[0][i] = c;
            for (i = 1; i < h + 1; i++)
            {
                a[i] = (c + nextLine().replace(" ", "") + c).toCharArray();
            }
            for (i = 0; i < w + 2; i++)
                a[h + 1][i] = c;
            return a;
        }

        public long[] nextLongArray(int n)
        {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = nextLong();
            }
            return a;
        }

        public long[][] nextLongArray2(int h, int w)
        {
            long[][] a = new long[h][w];
            for (int hi = 0; hi < h; hi++)
            {
                for (int wi = 0; wi < w; wi++)
                {
                    a[hi][wi] = nextLong();
                }
            }
            return a;
        }
    }
}


import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class WarmUp1 {

    public void solve(Scanner in, PrintWriter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        long s = in.nextLong();
        int currPos = 1;

        if ((n - 1) * k < s) {
            out.println("NO");
        } else {
            if (s != 1) {
                out.println("YES");
                while (k != 0) {
                    long currI = s / k + s % k;
                    s = s - currI;
                    k--;
                    if (currPos + currI > n) {
                        currPos -= currI;
                    } else {
                        currPos += currI;
                    }
                    out.println(currPos);
                }
            } else {
                out.println("NO");
            }
        }
    }

    public static void main(String[] args) {
        new WarmUp1().run();
    }

    public void run() {
        try (Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }
}


import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class WarmUp1 {

    public void solve(Scanner in, PrintWriter out) {
        long n = in.nextInt();
        long k = in.nextInt();
        long s = in.nextLong();
        int currPos = 1;

        if ((n - 1) * k < s) {
            out.println("NO");
        } else {
            if (s < k) {
                out.println("NO");
            } else {
                out.println("YES");
                while (k != 0) {
                    long currI = n - 1;
                    if (s - k + 1 < currI) {
                        currI = s - k + 1;
                    }
                    //out.println("currI: " + currI);
                    s = s - currI;
                    k--;
                    if (currPos + currI > n) {
                        currPos -= currI;
                    } else {
                        currPos += currI;
                    }
                    out.println(currPos);
                }
            }
        }
    }

    public static void main(String[] args) {
        new WarmUp1().run();
    }

    public void run() {
        try (Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }
}


import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class WarmUp1 {

    public void solve(Scanner in, PrintWriter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        long s = in.nextLong();
        int currPos = 1;

        if ((n - 1) * k < s) {
            out.println("NO");
        } else {
            out.println("YES");
            while (k != 0) {
                long currI = s / k + s % k;
                s = s - currI;
                k--;
                if (currPos + currI > n) {
                    currPos -= currI;
                } else {
                    currPos += currI;
                }
                out.println(currPos);
            }
        }
    }

    public static void main(String[] args) {
        new WarmUp1().run();
    }

    public void run() {
        try (Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }
}


import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class WarmUp1 {

    public void solve(Scanner in, PrintWriter out) {
        long n = in.nextInt();
        long k = in.nextInt();
        long s = in.nextLong();
        int currPos = 1;

        if ((n - 1) * k < s) {
            out.println("NO");
        } else {
            if (s < k) {
                out.println("NO");
            } else {
                out.println("YES");
                while (k != 0) {
                    long currI = s / k + s % k;
                    s = s - currI;
                    k--;
                    if (currPos + currI > n) {
                        currPos -= currI;
                    } else {
                        currPos += currI;
                    }
                    out.println(currPos);
                }
            }
        }
    }

    public static void main(String[] args) {
        new WarmUp1().run();
    }

    public void run() {
        try (Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }
}


import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class WarmUp1 {

    public void solve(Scanner in, PrintWriter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        long s = in.nextLong();
        int currPos = 1;

        if ((n - 1) * k < s) {
            out.println("NO");
        } else {
            while (k != 0) {
                long currI = s / k + s % k;
                s = s - currI;
                k--;
                if (currPos + currI > n) {
                    currPos -= currI;
                } else {
                    currPos += currI;
                }
                out.println(currPos);
            }
        }
    }

    public static void main(String[] args) {
        new WarmUp1().run();
    }

    public void run() {
        try (Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }
}


import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class WarmUp1 {

    public void solve(Scanner in, PrintWriter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        long s = in.nextLong();
        int currPos = 1;

        if ((n - 1) * k < s) {
            out.println("NO");
        } else {
            if (s < k) {
                out.println("NO");
            } else {
                out.println("YES");
                while (k != 0) {
                    long currI = s / k + s % k;
                    s = s - currI;
                    k--;
                    if (currPos + currI > n) {
                        currPos -= currI;
                    } else {
                        currPos += currI;
                    }
                    out.println(currPos);
                }
            }
        }
    }

    public static void main(String[] args) {
        new WarmUp1().run();
    }

    public void run() {
        try (Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out)) {
            solve(in, out);
        }
    }
}


//package solution;

import java.io.*;
import java.util.*;

public final class Solution {
    BufferedReader br;
    StringTokenizer stk;

    public static void main(String[] args) throws Exception {
        new Solution().run();
    }

    {
        stk = null;
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    long mod = 1000_000_000 + 7;
    StringBuilder res = new StringBuilder(1000005);

    void run() throws Exception {
        long n = ni();
        int k = ni();
        long s = nl();

        if(s < k || s > (n - 1) * k) {
            res.append("NO");
        } else {
            long[] arr = new long[k + 1];
            arr[0] = 1;
            long sum = 0;
            for(int i = 1; i <= k; i++) {
                arr[i] = n - 1;
                sum += arr[i];
                if(sum >= s) {
                    if(sum == s && i == k) {
                        break;
                    } else {
                        arr[i] = 0;
                        sum -= n - 1;
                        for(int j = i; j <= k; j++) {
                            arr[j] = 1;
                            sum++;
                        }
                        break;
                    }
                }
            }
            if(sum < s) {
                arr[k] += s - sum;
            } else if(sum == s) {
                //do nothing
            } else {
                for(int i = 1; i <= k; i++) {
                    if(arr[i] != n - 1) {
                        arr[i - 1] -= sum - s;
                        break;
                    }
                }
            }
            for(int i = 1; i <= k; i++) {
                if(i % 2 == 0) {
                    arr[i] = -arr[i];
                }
                arr[i] += arr[i - 1];
            }
            //System.out.println(Arrays.toString(arr));

            res.append("YES\n");
            for(int i = 1; i <= k; i++) {
                res.append(arr[i]).append(" ");
            }
            res.deleteCharAt(res.length() - 1);
        }
        System.out.println(res);
    }

    //Reader & Writer
    String nextToken() throws Exception {
        if (stk == null || !stk.hasMoreTokens()) {
            stk = new StringTokenizer(br.readLine(), " ");
        }
        return stk.nextToken();
    }

    String nt() throws Exception {
        return nextToken();
    }

    int ni() throws Exception {
        return Integer.parseInt(nextToken());
    }

    long nl() throws Exception {
        return Long.parseLong(nextToken());
    }
}


//package solution;

import java.io.*;
import java.util.*;

public final class Solution {
    BufferedReader br;
    StringTokenizer stk;

    public static void main(String[] args) throws Exception {
        new Solution().run();
    }

    {
        stk = null;
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    long mod = 1000_000_000 + 7;
    StringBuilder res = new StringBuilder(1000005);

    void run() throws Exception {
        long n = ni();
        int k = ni();
        long s = nl();

        if(s < k || s > (n - 1) * k) {
            res.append("NO");
        } else {
            long[] arr = new long[k + 1];
            arr[0] = 1;
            long sum = 0;
            for(int i = 1; i <= k; i++) {
                arr[i] = n - 1;
                sum += arr[i];
                if(sum >= s) {
                    if(sum == s && i == k) {
                        break;
                    } else {
                        arr[i] = 0;
                        sum -= n - 1;
                        for(int j = i; j <= k; j++) {
                            arr[j] = 1;
                            sum++;
                        }
                        break;
                    }
                }
            }
            if(sum < s) {
                //System.out.println("##");
                arr[k] += s - sum;
            } else if(sum == s) {
                //do nothing
            } else {
                //System.out.println("**");
                for(int i = 1; i <= k; i++) {
                    if(arr[i] != n - 1) {
                        arr[i - 1] -= sum - s;
                        break;
                    }
                }
            }
            for(int i = 1; i <= k; i++) {
                if(i % 2 == 0) {
                    arr[i] = -arr[i];
                }
                arr[i] += arr[i - 1];
            }
            //System.out.println(Arrays.toString(arr));

            if(arr[k] == 0) {
                arr[k] += 2 * arr[k - 1];
            }

            res.append("YES\n");
            for(int i = 1; i <= k; i++) {
                res.append(arr[i]).append(" ");
            }
            res.deleteCharAt(res.length() - 1);
        }
        System.out.println(res);
    }

    //Reader & Writer
    String nextToken() throws Exception {
        if (stk == null || !stk.hasMoreTokens()) {
            stk = new StringTokenizer(br.readLine(), " ");
        }
        return stk.nextToken();
    }

    String nt() throws Exception {
        return nextToken();
    }

    int ni() throws Exception {
        return Integer.parseInt(nextToken());
    }

    long nl() throws Exception {
        return Long.parseLong(nextToken());
    }
}


//package solution;

import java.io.*;
import java.util.*;

public final class Solution {
    BufferedReader br;
    StringTokenizer stk;

    public static void main(String[] args) throws Exception {
        new Solution().run();
    }

    {
        stk = null;
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    long mod = 1000_000_000 + 7;
    StringBuilder res = new StringBuilder(1000005);

    void run() throws Exception {
        long n = ni();
        int k = ni();
        long s = nl();

        if(s < k || s > (n - 1) * k) {
            res.append("NO");
        } else {
            long[] arr = new long[k + 1];
            arr[0] = 1;
            long sum = 0;
            for(int i = 1; i <= k; i++) {
                arr[i] = n - 1;
                sum += arr[i];
                if(sum >= s) {
                    if(sum == s && i == k) {
                        break;
                    } else {
                        arr[i] = 0;
                        sum -= n - 1;
                        for(int j = i; j <= k; j++) {
                            arr[j] = 1;
                            sum++;
                        }
                        break;
                    }
                }
            }
            if(sum < s) {
                //System.out.println("##");
                arr[k] += s - sum;
            } else if(sum == s) {
                //do nothing
            } else {
                //System.out.println("**");
                for(int i = 1; i <= k; i++) {
                    if(arr[i] != n - 1) {
                        arr[i - 1] -= sum - s;
                        break;
                    }
                }
            }
            for(int i = 1; i <= k; i++) {
                if(i % 2 == 0) {
                    arr[i] = -arr[i];
                }
                arr[i] += arr[i - 1];
                if(arr[i] < 1) {
                    long diff = Math.abs(arr[i] - arr[i - 1]);
                    arr[i] = arr[i - 1] + diff;
                }
                if(arr[i] > n) {
                    long diff = Math.abs(arr[i] - arr[i - 1]);
                    arr[i] = arr[i - 1] - diff;
                }
            }
            //System.out.println(Arrays.toString(arr));

            if(arr[k] == 0) {
                arr[k] += 2 * arr[k - 1];
            }

            res.append("YES\n");
            for(int i = 1; i <= k; i++) {
                res.append(arr[i]).append(" ");
            }
            res.deleteCharAt(res.length() - 1);
        }
        System.out.println(res);
    }

    //Reader & Writer
    String nextToken() throws Exception {
        if (stk == null || !stk.hasMoreTokens()) {
            stk = new StringTokenizer(br.readLine(), " ");
        }
        return stk.nextToken();
    }

    String nt() throws Exception {
        return nextToken();
    }

    int ni() throws Exception {
        return Integer.parseInt(nextToken());
    }

    long nl() throws Exception {
        return Long.parseLong(nextToken());
    }
}


//package solution;

import java.io.*;
import java.util.*;

public final class Solution {
    BufferedReader br;
    StringTokenizer stk;

    public static void main(String[] args) throws Exception {
        new Solution().run();
    }

    {
        stk = null;
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    long mod = 1000_000_000 + 7;
    StringBuilder res = new StringBuilder(1000005);

    void run() throws Exception {
        long n = ni();
        long k = ni();
        long s = nl();

        if(s < k || s > (n - 1) * k) {
            System.out.println("NO");
            return;
        }

        long[] a = new long[(int)k + 1];
        Arrays.fill(a, 1);
        s -= k;
        for(int i = 1; i <= k; i++) {
            if(s < (n - 1)) {
                a[i] += s;
                break;
            } else {
                a[i] += (n - 2);
                s -= (n - 2);
            }
        }

        //System.out.println(Arrays.toString(a));

        for(int i = 1; i <= k; i++) {
            long value = a[i];
            if(i % 2 == 0) {
                value = -value;
            }
            if(a[i - 1] + value >= 1 && a[i - 1] + value <= n) {
                a[i] = a[i - 1] + value;
            } else {
                a[i] = a[i - 1] - value;
            }
        }

        res.append("YES\n");
        for(int i = 1; i <= k; i++) {
            res.append(a[i]).append(" ");
        }
        System.out.println(res.deleteCharAt(res.length() - 1));
    }

    //Reader & Writer
    String nextToken() throws Exception {
        if (stk == null || !stk.hasMoreTokens()) {
            stk = new StringTokenizer(br.readLine(), " ");
        }
        return stk.nextToken();
    }

    String nt() throws Exception {
        return nextToken();
    }

    int ni() throws Exception {
        return Integer.parseInt(nextToken());
    }

    long nl() throws Exception {
        return Long.parseLong(nextToken());
    }
}


import java.io.*;
import java.util.*;

public class D
{

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		long n = sc.nextLong();
		long k = sc.nextLong();
		long s = sc.nextLong();

		long dist = (s / k);
		long mod = s % k;
		if((mod > 0 && dist + 1 > n - 1) || dist > n - 1 || s < k) pw.println("NO");
		else
		{
			pw.println("YES");
			long cur = 1;
			boolean flag = true;
			while(k-->0)
			{
				long tmp = dist;
				if(mod-->0)
					tmp++;

				if(flag) cur = cur + tmp;
				else cur = cur - tmp;
				pw.print(cur + " ");
				flag = !flag;
			}
		}

		pw.flush();
		pw.close();
	}

	static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}

    }
}


import java.io.*;
import java.util.*;

public class D
{

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		long n = sc.nextLong();
		long k = sc.nextLong();
		long s = sc.nextLong();

		long dist = (s / k);
		if((dist + (s % k)) > n - 1 || s < k) pw.println("NO");
		else
		{
			pw.println("YES");
			long end = 1 + dist + (s % k);
			pw.print(end + " ");
			k--;

			long start = end - dist;
			boolean flag = true;
			while(k-->0)
			{
				pw.print((flag ? start : end) + " ");
				flag = !flag;
			}
		}

		pw.flush();
		pw.close();
	}

	static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}

    }
}


import java.io.*;
import java.util.*;

public class D
{

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		long n = sc.nextLong();
		long k = sc.nextLong();
		long s = sc.nextLong();

		long dist = (s / k);
		if((dist + (s % k)) > n - 1) pw.println("NO");
		else
		{
			pw.println("YES");
			long end = 1 + dist + (s % k);
			pw.print(end + " ");
			k--;

			long start = end - dist;
			boolean flag = true;
			while(k-->0)
			{
				pw.print((flag ? start : end) + " ");
				flag = !flag;
			}
		}

		pw.flush();
		pw.close();
	}

	static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}

    }
}


import java.io.*;
import java.util.*;

public class D
{

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		long n = sc.nextLong();
		long k = sc.nextLong();
		long s = sc.nextLong();

		long dist = (s / k);
		long mod = s % k;
		if((mod > 0 && dist + 1 > n - 1) || s < k) pw.println("NO");
		else
		{
			pw.println("YES");
			long cur = 1;
			boolean flag = true;
			while(k-->0)
			{
				long tmp = dist;
				if(mod > 0)
				{
					tmp++;
					mod--;
				}

				if(flag) cur = cur + tmp;
				else cur = cur - tmp;
				pw.print(cur + " ");
				flag = !flag;
			}
		}

		pw.flush();
		pw.close();
	}

	static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}

    }
}


import java.io.*;
import java.util.*;

public class D
{

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		long n = sc.nextLong();
		long k = sc.nextLong();
		long s = sc.nextLong();

		long dist = (s / k);
		long mod = s % k;
		if((mod > 0 && dist + 1 > n - 1) || s < k) pw.println("NO");
		else
		{
			pw.println("YES");
			long cur = 1;
			boolean flag = true;
			while(k-->0)
			{
				long tmp = dist;
				if(mod-->0)
					tmp++;

				if(flag) cur = cur + tmp;
				else cur = cur - tmp;
				pw.print(cur + " ");
				flag = !flag;
			}
		}

		pw.flush();
		pw.close();
	}

	static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public double nextDouble() throws IOException
        {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if(x.charAt(0) == '-')
            {
                neg = true;
                start++;
            }
            for(int i = start; i < x.length(); i++)
                if(x.charAt(i) == '.')
                {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                }
                else
                {
                    sb.append(x.charAt(i));
                    if(dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg?-1:1);
        }

        public boolean ready() throws IOException {return br.ready();}

    }
}


import java.util.*;
import java.io.*;

public class Main
{
	public static void main(String[] args)
	{
		FastReader reader = new FastReader();
		PrintWriter writer = new PrintWriter(System.out);

		long n = reader.nextLong();
		long k = reader.nextLong();
		long s = reader.nextLong();

		if (k*(n-1) < s || k > s)
			writer.print("NO");
		else
		{
			writer.println("YES");
			long cur = 1;

			while (k > 0)
			{
				long trav = Math.min(n-1, s-k+1);

				if (cur + trav <= n)
					cur += trav;
				else
					cur -= trav;

				writer.print(cur + " ");
				k--;
				s -= trav;
			}
		}

		writer.println();
		writer.close();
	}

	static class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

		public FastReader()
		{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next()
		{
			while (st == null || !st.hasMoreElements())
			{
				try
				{
					st = new StringTokenizer(br.readLine());
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
	}
}


import java.util.*;
import java.io.*;

public class Main
{
	public static void main(String[] args)
	{
		FastReader reader = new FastReader();
		PrintWriter writer = new PrintWriter(System.out);

		long n = reader.nextLong();
		long k = reader.nextLong();
		long s = reader.nextLong();

		if (k*(n-1) < s)
			writer.print("NO");
		else
		{
			writer.println("YES");
			long t = s/k + 1;

			if (s%k != 0)
				t++;

			for (int i=0; i<k-1; i++)
			{
				if (i%2 == 0)
					writer.print(t + " ");
				else
					writer.print(1 + " ");
			}

			long dist = s - (t-1)*(k-1);

			if (k%2 == 0)
				writer.print((t-dist));
			else
				writer.print((1+dist));
		}

		writer.println();
		writer.close();
	}

	static class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

		public FastReader()
		{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next()
		{
			while (st == null || !st.hasMoreElements())
			{
				try
				{
					st = new StringTokenizer(br.readLine());
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
	}
}


import java.util.*;
import java.io.*;

public class Main
{
	public static void main(String[] args)
	{
		FastReader reader = new FastReader();
		PrintWriter writer = new PrintWriter(System.out);

		long n = reader.nextLong();
		long k = reader.nextLong();
		long s = reader.nextLong();

		if (k*(n-1) < s || k > s)
			writer.print("NO");
		else
		{
			writer.println("YES");
			long t = s/k + 1;

			if (s%k != 0)
				t++;

			for (int i=0; i<k-1; i++)
			{
				if (i%2 == 0)
					writer.print(t + " ");
				else
					writer.print(1 + " ");
			}

			long dist = s - (t-1)*(k-1);

			if (k%2 == 0)
				writer.print((t-dist));
			else
				writer.print((1+dist));
		}

		writer.println();
		writer.close();
	}

	static class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

		public FastReader()
		{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next()
		{
			while (st == null || !st.hasMoreElements())
			{
				try
				{
					st = new StringTokenizer(br.readLine());
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
	}
}


//Walking Between Houses
import java.io.*;
import java.util.*;

public class D501{

   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));

      StringTokenizer st = new StringTokenizer(f.readLine());

      int n = Integer.parseInt(st.nextToken());
      int m = Integer.parseInt(st.nextToken());
      int d = Integer.parseInt(st.nextToken());

      if((n-1)*m < d || d <= m){
         System.out.println("NO");
         System.exit(0);
      }

      System.out.println("YES");

      int cur = 1;

      while(m>0){
         int i = Math.min(n-1,d-m+1);
         cur = step(cur,i);
         m-=1;
         d-=i;
         System.out.print(cur + " ");
      }

   }
   public static int step(int c, int x){
      return c - x > 0 ? c-x : c+x;
   }
}


//Walking Between Houses
import java.io.*;
import java.util.*;

public class D501{

   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));

      StringTokenizer st = new StringTokenizer(f.readLine());

      int n = Integer.parseInt(st.nextToken());
      int m = Integer.parseInt(st.nextToken());
      int d = Integer.parseInt(st.nextToken());

      if((n-1)*m < d || d < m){
         System.out.println("NO");
         System.exit(0);
      }

      System.out.println("YES");

      int cur = 1;

      while(m>0){
         int i = Math.min(n-1,d-m+1);
         cur = step(cur,i);
         m-=1;
         d-=i;
         System.out.print(cur + " ");
      }

   }
   public static int step(int c, int x){
      return c - x > 0 ? c-x : c+x;
   }
}


//Walking Between Houses
import java.io.*;
import java.util.*;

public class D501{

   public static void main(String[] args)throws IOException{
      BufferedReader f = new BufferedReader(new InputStreamReader(System.in));

      StringTokenizer st = new StringTokenizer(f.readLine());

      long n = Long.parseLong(st.nextToken());
      long m = Long.parseLong(st.nextToken());
      long d = Long.parseLong(st.nextToken());

      if((n-1)*m < d || d < m){
         System.out.println("NO");
         System.exit(0);
      }

      System.out.println("YES");

      long cur = 1L;

      while(m>0){
         long i = Math.min(n-1,d-m+1);
         cur = step(cur,i);
         m-=1;
         d-=i;
         System.out.print(cur + " ");
      }

   }
   public static long step(long c, long x){
      return c - x > 0 ? c-x : c+x;
   }
}


import java.util.*;
public class susbus{
   public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      long n= sc.nextLong();
      long k= sc.nextLong();
      long s=  sc.nextLong();
      //move at least 1, at most n-1 each move
      long j = (n-1)*k;
//      System.out.println(j);
//      System.out.println(j-s);
      if(k>s || j<s) {
         System.out.println("NO");
         return;
      }
      System.out.println("YES");
      int numMove=0;
      while(s-(numMove+1)*(n-1)>k-(numMove+1)) {
         numMove++;
      }
      s = s-(numMove)*(n-1);
      k = k-numMove;
//       System.out.println(numMove);
      for(int i=0;i<numMove;i++){
         if(i%2==0) {
            System.out.print(n + " ");
         }
         else {
            System.out.print(1 + " ");
         }
      }
//       System.out.println(s);
      long add = (int) s+1-k;
      s-=add;
//      System.out.println(s);
      long left = 0;
      if(numMove%2==1){
         System.out.print(n-add + " ");
         left=n-add;
      }
      else {
         System.out.print(1+add + " ");
         left=1+add;
      }
//      System.out.print("whatever is left is "  + left);
      int state = 0;
      while(s>0){
         if(state%2==0) System.out.print(left+1 + " ");
         else System.out.print(left + " ");
         state++;
         s--;
      }
   }

}


import java.util.*;
public class susbus{
   public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int n= sc.nextInt();
      int k= sc.nextInt();
      long s=  sc.nextLong();
      //move at least 1, at most n-1 each move
      if(k>s || (n-1)*k<s) {
         System.out.println("NO");
         return;
      }
      System.out.println("YES");
      int numMove=0;
      while(s-(numMove+1)*(n-1)>k-(numMove+1)) {
         numMove++;
      }
      s = s-(numMove)*(n-1);
      k = k-numMove;
//       System.out.println(numMove);
      for(int i=0;i<numMove;i++){
         if(i%2==0) {
            System.out.print(n + " ");
         }
         else {
            System.out.print(1 + " ");
         }
      }
//       System.out.println(s);
      int add = (int) s+1-k;
      s-=add;
//      System.out.println(s);
      int left = 0;
      if(numMove%2==1){
         System.out.print(n-add + " ");
         left=n-add;
      }
      else {
         System.out.print(1+add + " ");
         left=1+add;
      }
//      System.out.print("whatever is left is "  + left);
      int state = 0;
      while(s>0){
         if(state%2==0) System.out.print(left+1 + " ");
         else System.out.print(left + " ");
         state++;
         s--;
      }
   }
}


import java.util.*;
public class susbus{
   public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      long n= sc.nextLong();
      long k= sc.nextLong();
      long s=  sc.nextLong();
      //move at least 1, at most n-1 each move
      long j = (n-1)*k;
//      System.out.println(j);
//      System.out.println(j-s);
      if(k>s || j<s) {
         System.out.println("NO");
         return;
      }
      System.out.println("YES");
      int numMove=0;
      while(s-(numMove+1)*(n-1)>k-(numMove+1)) {
         numMove++;
      }
      s = s-(numMove)*(n-1);
      k = k-numMove;
//       System.out.println(numMove);
      for(int i=0;i<numMove;i++){
         if(i%2==0) {
            System.out.print(n + " ");
         }
         else {
            System.out.print(1 + " ");
         }
      }
//       System.out.println(s);
      long add = (int) s+1-k;
      s-=add;
//      System.out.println(s);
      long left = 0;
      if(numMove%2==1){
         System.out.print(n-add + " ");
         left=n-add;
      }
      else {
         System.out.print(1+add + " ");
         left=1+add;
      }
//      System.out.print("whatever is left is "  + left);
      int state = 0;
      while(s>0){
    	 if(left<n) {
         if(state%2==0) System.out.print(left+1 + " ");
         else System.out.print(left + " ");
         state++;
         s--;
    	 }
    	 else {
    		 if(state%2==0) System.out.print(left-1 + " ");
             else System.out.print(left + " ");
             state++;
             s--;
    	 }
      }
   }
}


package CodeForces;

import java.io.*;
import java.util.*;

public class Problem_1015D {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		int n=sc.nextInt();long k=sc.nextLong(),s=sc.nextLong();
		if(k>s || (n-1)*k<s)
		{
			System.out.println("NO");
			return;
		}
		pw.println("YES");
		long div=(long) Math.ceil(s*1d/k);
		long rem=Math.abs(div-(s%k));
//		System.err.println(rem);
		long cur=1;
		if(rem==0)
		{
			while(k-->0)
			{
				cur=cur+div<=n?cur+div:cur-div;
				pw.print(cur+" ");
			}
		}
		else
		{
			while(k-->1)
			{
				cur=cur+div<=n?cur+div:cur-div;
				pw.print(cur+" ");
			}
			cur=cur+rem<=n?cur+rem:cur-rem;
			pw.print(cur);
		}
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() throws IOException {
			return br.readLine();
		}

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}


// package CodeForces;

import java.io.*;
import java.util.*;

public class Problem_1015D {
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		int n=sc.nextInt();long k=sc.nextLong(),s=sc.nextLong();
		if(k>s || (n-1)*k<s)
		{
			System.out.println("NO");
			return;
		}
		pw.println("YES");
		long div=(long) Math.ceil(s*1d/k);
		long rem=Math.abs(div-(s%k));
//		System.err.println(rem);
		long cur=1;
		if(rem==0)
		{
			while(k-->0)
			{
				cur=cur+div<=n?cur+div:cur-div;
				pw.print(cur+" ");
			}
		}
		else
		{
			while(k-->1)
			{
				cur=cur+div<=n?cur+div:cur-div;
				pw.print(cur+" ");
			}
			cur=cur+rem<=n?cur+rem:cur-rem;
			pw.print(cur);
		}
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() throws IOException {
			return br.readLine();
		}

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}


package CodeForces;

import java.io.*;
import java.util.*;

public class Problem_1015D {
	static int step(int cur, int d)
	{
		if(cur+d>n)
			return cur-d;
		return cur+d;
	}
	static int n;
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		n=sc.nextInt();long k=sc.nextLong(),s=sc.nextLong();
		if(k>s || (n-1)*k<s)
		{
			System.out.println("NO");
			return;
		}
		pw.println("YES");
		int cur=1;
		while(k>0)
		{
			int d=(int) Math.min(n-1, s-k+1);
			cur=step(cur,d);
			pw.print(cur+" ");
//			System.err.println(d);
			s-=d;
			k--;
		}
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() throws IOException {
			return br.readLine();
		}

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}


// package CodeForces;

import java.io.*;
import java.util.*;

public class Problem_1015D {
	static int step(int cur, int d)
	{
		if(cur+d>n)
			return cur-d;
		return cur+d;
	}
	static int n;
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);
		n=sc.nextInt();long k=sc.nextLong(),s=sc.nextLong();
		if(k>s || (n-1)*k<s)
		{
			System.out.println("NO");
			return;
		}
		pw.println("YES");
		int cur=1;
		while(k>0)
		{
			int d=(int) Math.min(n-1, s-k+1);
			cur=step(cur,d);
			pw.print(cur+" ");
//			System.err.println(d);
			s-=d;
			k--;
		}
		pw.close();
	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() throws IOException {
			return br.readLine();
		}

		boolean hasnext() throws IOException {
			return br.ready();
		}

	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D_Houses {

    public static void main(String[] args) {
        // read input data
        MyScanner sc = new MyScanner();
        int numHouses = sc.nextInt();
        int numSteps = sc.nextInt();
        long distance = sc.nextLong();

        // check if it possible to solve the issue
        int maxPossibleDist = (numHouses - 1) * numSteps;
        if (maxPossibleDist < distance) {
            System.out.println("NO");
            return;
        }

        int recommendedDist = (int) Math.ceil((double)distance / numSteps);
        int lastStepSign = 1; // +1 - if from left to right, -1 - another case

        List<Integer> path = new ArrayList<>();
        int curHouseNum = 1;
        int stepDist = 0;
        if (recommendedDist <= numHouses - 1) {
            stepDist = recommendedDist;
        } else {
            stepDist = numHouses - 1;
        }

        while (distance > recommendedDist) {
            distance -= stepDist;
            int targetHouseNum = curHouseNum + lastStepSign * stepDist;
            path.add(targetHouseNum);
            lastStepSign = -lastStepSign;
            curHouseNum = targetHouseNum;
        }

        if (distance != 0){
            path.add((int) (curHouseNum + lastStepSign * distance));
        }

        System.out.println("YES");
        path.stream().forEach(x -> System.out.print(x + " "));

    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D_Houses {

    public static void main(String[] args) {
        // read input data
        MyScanner sc = new MyScanner();
        int numHouses = sc.nextInt();
        int numSteps = sc.nextInt();
        long distance = sc.nextLong();

        // check if it possible to solve the issue
        int maxPossibleDist = (numHouses - 1) * numSteps;
        if (maxPossibleDist < distance) {
            System.out.println("NO");
            return;
        }

        int recommendedDist = (int) Math.ceil((double)distance / numSteps);
        int lastStepSign = 1; // +1 - if from left to right, -1 - another case

        List<Integer> path = new ArrayList<>();
        int curHouseNum = 1;
        int stepDist = 0;
        if (recommendedDist <= numHouses - 1) {
            stepDist = recommendedDist;
        } else {
            stepDist = numHouses - 1;
        }

        while (distance > recommendedDist) {
            distance -= stepDist;
            int targetHouseNum = curHouseNum + lastStepSign * stepDist;
            path.add(targetHouseNum);
            lastStepSign = -lastStepSign;
            curHouseNum = targetHouseNum;
        }

        if (distance != 0){
            path.add((int) (curHouseNum + lastStepSign * distance));
        }

        System.out.println("YES");
        System.out.println(path);

    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D_Houses {

    public static void main(String[] args) {
        // read input data
        MyScanner sc = new MyScanner();
        int numHouses = sc.nextInt();
        int numSteps = sc.nextInt();
        long distance = sc.nextLong();

        // check if it possible to solve the issue
        long maxPossibleDist = (long)(numHouses - 1) * numSteps;
        if (maxPossibleDist < distance || distance < numSteps) {
            System.out.println("NO");
            return;
        }

        int recommendedDist = (int) Math.ceil((double)distance / numSteps);
        //int recommendedDist = (int) distance / numSteps;
        int lastStepSign = 1; // +1 - if from left to right, -1 - another case

        List<Integer> path = new ArrayList<>();
        int curHouseNum = 1;
        int stepDist = 0;
        if (recommendedDist <= numHouses - 1) {
            stepDist = recommendedDist;
        } else {
            stepDist = numHouses - 1;
        }

        while (distance > recommendedDist) {
            distance -= stepDist;
            int targetHouseNum = curHouseNum + lastStepSign * stepDist;
            numSteps--;
            path.add(targetHouseNum);
            lastStepSign = -lastStepSign;
            curHouseNum = targetHouseNum;

            recommendedDist = (int) Math.ceil((double)distance / numSteps);
            stepDist = recommendedDist;
        }

        if (distance != 0){
            path.add((int) (curHouseNum + lastStepSign * distance));
        }

        System.out.println("YES");
        path.stream().forEach(x -> System.out.print(x + " "));

    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D_Houses {

    public static void main(String[] args) {
        // read input data
        MyScanner sc = new MyScanner();
        int numHouses = sc.nextInt();
        int numSteps = sc.nextInt();
        long distance = sc.nextLong();

        // check if it possible to solve the issue
        int maxPossibleDist = (numHouses - 1) * numSteps;
        if (maxPossibleDist < distance || distance < numSteps) {
            System.out.println("NO");
            return;
        }

        int recommendedDist = (int) Math.ceil((double)distance / numSteps);
        //int recommendedDist = (int) distance / numSteps;
        int lastStepSign = 1; // +1 - if from left to right, -1 - another case

        List<Integer> path = new ArrayList<>();
        int curHouseNum = 1;
        int stepDist = 0;
        if (recommendedDist <= numHouses - 1) {
            stepDist = recommendedDist;
        } else {
            stepDist = numHouses - 1;
        }

        while (distance > recommendedDist) {
            distance -= stepDist;
            int targetHouseNum = curHouseNum + lastStepSign * stepDist;
            numSteps--;
            path.add(targetHouseNum);
            lastStepSign = -lastStepSign;
            curHouseNum = targetHouseNum;

            recommendedDist = (int) Math.ceil((double)distance / numSteps);
            stepDist = recommendedDist;
        }

        if (distance != 0){
            path.add((int) (curHouseNum + lastStepSign * distance));
        }

        System.out.println("YES");
        path.stream().forEach(x -> System.out.print(x + " "));

    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D_Houses {

    public static void main(String[] args) {
        // read input data
        MyScanner sc = new MyScanner();
        int numHouses = sc.nextInt();
        int numSteps = sc.nextInt();
        long distance = sc.nextLong();

        // check if it possible to solve the issue
        int maxPossibleDist = (numHouses - 1) * numSteps;
        if (maxPossibleDist < distance || distance < numSteps) {
            System.out.println("NO");
            return;
        }

        int recommendedDist = (int) Math.ceil((double)distance / numSteps);
        int lastStepSign = 1; // +1 - if from left to right, -1 - another case

        List<Integer> path = new ArrayList<>();
        int curHouseNum = 1;
        int stepDist = 0;
        if (recommendedDist <= numHouses - 1) {
            stepDist = recommendedDist;
        } else {
            stepDist = numHouses - 1;
        }

        while (distance > recommendedDist) {
            distance -= stepDist;
            int targetHouseNum = curHouseNum + lastStepSign * stepDist;
            path.add(targetHouseNum);
            lastStepSign = -lastStepSign;
            curHouseNum = targetHouseNum;
        }

        if (distance != 0){
            path.add((int) (curHouseNum + lastStepSign * distance));
        }

        System.out.println("YES");
        path.stream().forEach(x -> System.out.print(x + " "));

    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}


import java.io.*;
import java.util.InputMismatchException;

public class A {

    public static void main(String args[]) throws Exception {
        long n = scn.nextLong();
        long k = scn.nextLong();
        long s = scn.nextLong();
        if((n-1)*k < s || k>s){
            out.println("NO");
        }else{
            out.println("YES");
            long prev = 1;
            while (s>(n-1) && (s-(n-1))>k){
                if(prev == 1){
                    out.print(n+" ");
                    prev = n;
                }else{
                    out.print(1+" ");
                    prev = 1;
                }
                s -= (n-1);
                k--;
            }
            long next, p = prev;
            if(prev == 1) next = 2;
            else next = (n-1);
            while (k>1){
                if(prev == p){
                    out.print(next+" ");
                    prev = next;
                }else{
                    out.print(p+" ");
                    prev = p;
                }
                s--;
                k--;
            }
            out.println((prev+s <= n)?(prev+s):(prev-s));
        }
        out.close();
    }

    static class Pair implements Comparable<Pair> {
        int x, y;
        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public String toString() {
            return this.x + " [" + this.y + "]";
        }
        @Override
        public int compareTo(Pair o) {
            return Integer.compare(this.x, o.x);
        }
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Pair) {
                Pair o = (Pair) obj;
                return this.y == o.y;
            }
            return false;
        }
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static InputReader scn = new InputReader(System.in);
    public static PrintWriter out = new PrintWriter(System.out);
}


import java.io.*;
import java.util.InputMismatchException;

public class A {

    public static void main(String args[]) throws Exception {
        long n = scn.nextLong();
        long k = scn.nextLong();
        long s = scn.nextLong();
        if((n-1)*k < s || k>s){
            out.println("NO");
        }else{
            out.println("YES");
            long prev = 1;
            while (s>(n-1) && (s-(n-1))>k-1){
                if(prev == 1){
                    out.print(n+" ");
                    prev = n;
                }else{
                    out.print(1+" ");
                    prev = 1;
                }
                s -= (n-1);
                k--;
            }
            long next, p = prev;
            if(prev == 1) next = 2;
            else next = (n-1);
            while (k>1){
                if(prev == p){
                    out.print(next+" ");
                    prev = next;
                }else{
                    out.print(p+" ");
                    prev = p;
                }
                s--;
                k--;
            }
            out.println((prev+s <= n)?(prev+s):(prev-s));
        }
        out.close();
    }

    static class Pair implements Comparable<Pair> {
        int x, y;
        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public String toString() {
            return this.x + " [" + this.y + "]";
        }
        @Override
        public int compareTo(Pair o) {
            return Integer.compare(this.x, o.x);
        }
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Pair) {
                Pair o = (Pair) obj;
                return this.y == o.y;
            }
            return false;
        }
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static InputReader scn = new InputReader(System.in);
    public static PrintWriter out = new PrintWriter(System.out);
}


import java.io.*;
import java.util.InputMismatchException;

public class A {

    public static void main(String args[]) throws Exception {
        long n = scn.nextLong();
        long k = scn.nextLong();
        long s = scn.nextLong();
        if((n-1)*k < s || k>s){
            out.println("NO");
        }else{
            out.println("YES");
            long prev = 1;
            while (s>(n-1) && (s-(n-1))>=k-1){
                if(prev == 1){
                    out.print(n+" ");
                    prev = n;
                }else{
                    out.print(1+" ");
                    prev = 1;
                }
                s -= (n-1);
                k--;
            }
            long next, p = prev;
            if(prev == 1) next = 2;
            else next = (n-1);
            while (k>1){
                if(prev == p){
                    out.print(next+" ");
                    prev = next;
                }else{
                    out.print(p+" ");
                    prev = p;
                }
                s--;
                k--;
            }
            out.println((prev+s <= n)?(prev+s):(prev-s));
        }
        out.close();
    }

    static class Pair implements Comparable<Pair> {
        int x, y;
        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
        @Override
        public String toString() {
            return this.x + " [" + this.y + "]";
        }
        @Override
        public int compareTo(Pair o) {
            return Integer.compare(this.x, o.x);
        }
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Pair) {
                Pair o = (Pair) obj;
                return this.y == o.y;
            }
            return false;
        }
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1)
                throw new InputMismatchException();

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }
            while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }

    public static InputReader scn = new InputReader(System.in);
    public static PrintWriter out = new PrintWriter(System.out);
}


import java.util.*;
public class A{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		long n = scan.nextInt();
		int k = scan.nextInt();
		long s = scan.nextInt();
		if(s/k > n-1)
		{
			System.out.println("NO");
			return;
		}
		long rem = s - k*(s/k);
		long min = s/k;
		while(rem > k)
		{
			rem = rem - k;
			min++;
		}
		if(min > n-1)
		{
			System.out.println("NO");
			return;
		}
		long arr[] = new long[k];
		Arrays.fill(arr,min);
		int i = 0;
		while(i < k)
		{
			long a = Math.min(rem,n-1-min);
			rem-=a;
			arr[i]+=a;
			if(rem == 0)
				break;
			i++;
		}
		if(rem > 0)
		{
			System.out.println("NO");
			return;
		}
		long start = 1;
		//System.out.println(Arrays.toString(arr));
		System.out.println("YES");
		for(i = 0;i < k;i++)
		{
			if(start + arr[i] <=n)
				{
					System.out.print((start + arr[i])+" ");
					start = start + arr[i];
				}
			else if (start - arr[i] >= 0)
			{
				System.out.print((start - arr[i])+" ");
				start = start - arr[i];
			}
		}
		System.out.println();

	}
	public void sort(int arr[])
	{
		int n = arr.length;
		Integer A[] = new Integer[n];
		for(int i = 0;i < n;i++)
			A[i] = arr[i];
		Arrays.sort(A);
	}
}