import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class D_Round_501_Div3 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        long n = in.nextInt();
        long k = in.nextInt();
        long s = in.nextLong();
        long max = n - 1;
        long v = s / max;
        if (v * max < s) {
            v++;
        }
        if (v > k || k > s || n == 1) {
            out.println("NO");
        } else {
            out.println("YES");
            long step = s / k;
            long left = s % k;
            long cur = 1;
            for (int i = 0; i < k; i++) {
                long extra = 0;
                if (left > 0) {
                    left--;
                    extra = 1;
                }
                if (i % 2 == 0) {
                    cur += extra + step;
                    out.print(cur + " ");
                } else {
                    cur -= (extra + step);
                    out.print(cur + " ");
                }
            }

        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class D_Round_501_Div3 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        int k = in.nextInt();
        long s = in.nextLong();
        int max = n - 1;
        long v = s / max;
        if (v * max < s) {
            v++;
        }
        if (v > k || k > s ||  n == 1) {
            out.println("NO");
        } else {
            out.println("YES");
            long step = s / k;

            long left = s - (step*(k - 1));
            long cur = 1 + step;
            if(left > step){
                cur += left - step;
                left = step;
            }
            out.print(cur + " ");
            for(int i = 1; i < k - 1; i++){
                if(cur == 1){
                    cur += step;
                    out.print(cur + " ");
                }else{
                    cur -= step;
                    out.print(cur + " ");
                }
            }
            if(cur == 1){
                cur += left;
                out.print(cur);
            }else{
                cur -= left;
                out.print(cur);
            }
        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class D_Round_501_Div3 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        long n = in.nextInt();
        long k = in.nextInt();
        long s = in.nextLong();
        long max = n - 1;
        long v = s / max;
        if (v * max < s) {
            v++;
        }
        if (v > k || k > s ||  n == 1) {
            out.println("NO");
        } else {
            out.println("YES");
            long step = s / k;

            long left = s - (step*(k - 1L));
            long cur = 1 + step;
            long first = 1;
            if(left > step){
                cur += left - step;
                first += left - step;
                left = step;
            }
            out.print(cur + " ");
            for(int i = 1; i < k - 1; i++){
                if(cur == first){
                    cur += step;
                    out.print(cur + " ");
                }else{
                    cur -= step;
                    out.print(cur + " ");
                }
            }
            if(cur == first){
                cur += left;
                out.print(cur);
            }else{
                cur -= left;
                out.print(cur);
            }
        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class D_Round_501_Div3 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        int k = in.nextInt();
        long s = in.nextLong();
        int max = n - 1;
        long v = s / max;
        if (v * max < s) {
            v++;
        }
        if (v > k) {
            out.println("NO");
        } else {
            out.println("YES");
            long step = s / k;
            long left = s - (step*(k - 1));

            long cur = 1;
            for(int i = 0; i < k - 1; i++){
                if(cur == 1){
                    cur += step;
                    out.print(cur + " ");
                }else{
                    cur -= step;
                    out.print(cur + " ");
                }
            }
            if(cur == 1){
                cur += left;
                out.print(cur);
            }else{
                cur -= left;
                out.print(cur);
            }
        }
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

/**
 *
 * @author ANH
 */
public class JavaApplication4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long k = sc.nextInt();
        long s = sc.nextLong();
        long sumGone = 0;
        if ( k*(n-1) < s || k > s) {
            System.out.print("NO");
            return;
        }

        long numStep = n==2 ? 0 : (s - k) / (n - 2);
        System.out.println("YES");
        boolean inMax = false;
        long  currentPos = 1;
        sumGone = (n-1)*numStep;
        for (int i = 0; i < numStep; i++) {
            if (inMax) {
                System.out.print("1 ");currentPos = 1;

            } else {
                System.out.print(n+" "); currentPos = n;
            }
            inMax = !inMax;
        }
        if (numStep==k) {
            return;
        }

        boolean moveFoward = !inMax;

        sumGone+=k-(numStep+1);
        for (int i = 0; i < k-(numStep+1);i++) {
            if (inMax) {
                if (moveFoward) {
                    System.out.print(n+ " "); currentPos = n;
                } else {
                    System.out.print((n-1)+" "); currentPos = n-1;
                }

            } else {
                if (moveFoward) {
                    System.out.print("2 "); currentPos = 2;
                } else {
                    System.out.print("1 "); currentPos = 1;
                }
            }
            moveFoward = !moveFoward;
        }

        if (currentPos + s-sumGone <=n) {
            System.out.print(currentPos + s-sumGone);
        } else if (currentPos -(s-sumGone) >= 1) {
            System.out.print(currentPos -(s-sumGone));
        }

    }

}


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

/**
 *
 * @author ANH
 */
public class JavaApplication4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long k = sc.nextInt();
        long s = sc.nextLong();
        long sumGone = 0;
        long numStep = (s - k) / (n - 2);
        if (numStep > k || k*(n-1) < s || k > s) {
            System.out.print("NO");
            return;
        }
        System.out.println("YES");
        boolean inMax = false;
        long  currentPos = 1;
        sumGone = (n-1)*numStep;
        for (int i = 0; i < numStep; i++) {
            if (inMax) {
                System.out.print("1 ");currentPos = 1;

            } else {
                System.out.print(n+" "); currentPos = n;
            }
            inMax = !inMax;
        }
        if (numStep==k) {
            return;
        }

        boolean moveFoward = !inMax;

        sumGone+=k-(numStep+1);
        for (int i = 0; i < k-(numStep+1);i++) {
            if (inMax) {
                if (moveFoward) {
                    System.out.print(n+ " "); currentPos = n;
                } else {
                    System.out.print((n-1)+" "); currentPos = n-1;
                }

            } else {
                if (moveFoward) {
                    System.out.print("2 "); currentPos = 2;
                } else {
                    System.out.print("1 "); currentPos = 1;
                }
            }
            moveFoward = !moveFoward;
        }

        if (currentPos + s-sumGone <=n) {
            System.out.print(currentPos + s-sumGone);
        } else if (currentPos -(s-sumGone) >= 1) {
            System.out.print(currentPos -(s-sumGone));
        }

    }

}


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

/**
 *
 * @author ANH
 */
public class JavaApplication4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long s = sc.nextLong();
        long sumGone = 0;
        long numStep = (s - k) / (n - 2);

        if (numStep > k || k*(n-1) < s) {
            System.out.print("NO");
            return;
        }
        System.out.println("YES");
        boolean inMax = false;
        int  currentPos = 1;
        sumGone = (n-1)*numStep;
        for (int i = 0; i < numStep; i++) {
            if (inMax) {
                System.out.print("1 ");currentPos = 1;

            } else {
                System.out.print(n+" "); currentPos = n;
            }
            inMax = !inMax;
        }
        if (numStep==k) {
            return;
        }

        boolean moveFoward = !inMax;

        sumGone+=k-(numStep+1);
        for (int i = 0; i < k-(numStep+1);i++) {
            if (inMax) {
                if (moveFoward) {
                    System.out.print(n+ " "); currentPos = n;
                } else {
                    System.out.print((n-1)+" "); currentPos = n-1;
                }

            } else {
                if (moveFoward) {
                    System.out.print("2 "); currentPos = 2;
                } else {
                    System.out.print("1 "); currentPos = 1;
                }
            }
            moveFoward = !moveFoward;
        }

        if (currentPos + s-sumGone <=n) {
            System.out.print(currentPos + s-sumGone);
        } else if (currentPos -(s-sumGone) >= 1) {
            System.out.print(currentPos -(s-sumGone));
        }

    }

}


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

/**
 *
 * @author ANH
 */
public class JavaApplication4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long k = sc.nextInt();
        long s = sc.nextLong();
        long sumGone = 0;
        long numStep = (s - k) / (n - 2);
        System.out.println(k*(n-1));
        if (numStep > k || k*(n-1) < s || k > s) {
            System.out.print("NO");
            return;
        }
        System.out.println("YES");
        boolean inMax = false;
        long  currentPos = 1;
        sumGone = (n-1)*numStep;
        for (int i = 0; i < numStep; i++) {
            if (inMax) {
                System.out.print("1 ");currentPos = 1;

            } else {
                System.out.print(n+" "); currentPos = n;
            }
            inMax = !inMax;
        }
        if (numStep==k) {
            return;
        }

        boolean moveFoward = !inMax;

        sumGone+=k-(numStep+1);
        for (int i = 0; i < k-(numStep+1);i++) {
            if (inMax) {
                if (moveFoward) {
                    System.out.print(n+ " "); currentPos = n;
                } else {
                    System.out.print((n-1)+" "); currentPos = n-1;
                }

            } else {
                if (moveFoward) {
                    System.out.print("2 "); currentPos = 2;
                } else {
                    System.out.print("1 "); currentPos = 1;
                }
            }
            moveFoward = !moveFoward;
        }

        if (currentPos + s-sumGone <=n) {
            System.out.print(currentPos + s-sumGone);
        } else if (currentPos -(s-sumGone) >= 1) {
            System.out.print(currentPos -(s-sumGone));
        }

    }

}


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

/**
 *
 * @author ANH
 */
public class JavaApplication4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long s = sc.nextLong();
        long sumGone = 0;
        long numStep = (s - k) / (n - 2);

        if (numStep > k || k*(n-1) < s || k > s) {
            System.out.print("NO");
            return;
        }
        System.out.println("YES");
        boolean inMax = false;
        int  currentPos = 1;
        sumGone = (n-1)*numStep;
        for (int i = 0; i < numStep; i++) {
            if (inMax) {
                System.out.print("1 ");currentPos = 1;

            } else {
                System.out.print(n+" "); currentPos = n;
            }
            inMax = !inMax;
        }
        if (numStep==k) {
            return;
        }

        boolean moveFoward = !inMax;

        sumGone+=k-(numStep+1);
        for (int i = 0; i < k-(numStep+1);i++) {
            if (inMax) {
                if (moveFoward) {
                    System.out.print(n+ " "); currentPos = n;
                } else {
                    System.out.print((n-1)+" "); currentPos = n-1;
                }

            } else {
                if (moveFoward) {
                    System.out.print("2 "); currentPos = 2;
                } else {
                    System.out.print("1 "); currentPos = 1;
                }
            }
            moveFoward = !moveFoward;
        }

        if (currentPos + s-sumGone <=n) {
            System.out.print(currentPos + s-sumGone);
        } else if (currentPos -(s-sumGone) >= 1) {
            System.out.print(currentPos -(s-sumGone));
        }

    }

}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class codeforces
{
   static class Student{
       int x,y,z;
        Student(int x,int y,int z){
            this.x=x;
            this.y=y;
            this.z=z;
        }
    }
    static int prime[];
    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        int pos=0;
        prime= new int[n+1];
        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == 0)
            {
                // Update all multiples of p
                prime[p]=p;
                for(int i = p*p; i <= n; i += p)
                    prime[i] = p;
            }
        }
    }
static    class Sortbyroll implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student c, Student b)
    {
        return b.x - c.x;
    }
}
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;
        }
    }

    static class Edge{
        int a,b;
        Edge(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    static class Trie{
        HashMap<Character,Trie>map;
         int c;
        Trie(){
            map=new HashMap<>();
            //z=null;
            //o=null;
            c=0;
        }
    }
    //static long ans;
    static int parent[];
    static int rank[];
    static int b[][];
    static int bo[];
    static int ho[];
    static int seg[];
    //static int pos;
   // static long mod=1000000007;
    //static int dp[][];
    static HashMap<Integer,Integer>map;
    static PriorityQueue<Student>q=new PriorityQueue<>();
    //static Stack<Integer>st;
   // static ArrayList<Character>ans;
    static ArrayList<ArrayList<Integer>>adj;
    static int ans;
    static Trie root;
    static long fac[];
    static long mod=(long)(1000000007);
    static void solve()throws IOException{
        FastReader sc=new FastReader();
        long n,k,s;
        int i;
        n=sc.nextLong();
        k=sc.nextLong();
        s=sc.nextLong();
        if(k<=s&&(n-(long)1)*k>=s){
            System.out.println("YES");
            n=s/k+(long)1;
            s=s%k;
            StringBuilder sb=new StringBuilder();
            for(i=1;i<=(int)k;i++){
                if(i%2!=0){
                    if(s>=(long)2){
                        sb.append((n+(long)1)+" ");
                        s-=(long)2;
                    }
                    else if(s==(long)1){
                        if(k%(long)2!=0){
                            if(i==(int)k)
                                sb.append((n+(long)1)+" ");
                            s-=(long)1;
                        }
                        else{
                            if(i==(int)k-1){
                                sb.append((n+(long)1)+" ");
                                //s-=(long)1;
                            }
                        }
                    }
                    else
                        sb.append(n+" ");
                }
                else{
                    if(k%(long)2!=0||s!=1||i!=(int)k)
                    sb.append(1+" ");
                    else
                    {
                        sb.append(2+" ");
                        s-=(long)1;
                    }
                }
            }
            System.out.println(sb.toString());
        }
        else{
            System.out.println("NO");
        }
    }
    static void dfs(Trie root,int k){
        if(root==null)
            return;
        for(char i='A';i<='Z';i++){
            if(root.map.containsKey(i)){
                ans+=root.map.get(i).c/k;
                dfs(root.map.get(i),k);
            }
        }
    }
    static long nCr(long n, long r,
                                    long p)
    {
        return (fac[(int)n]* modInverse(fac[(int)r], p)
                % p * modInverse(fac[(int)(n-r)], p)
                                    % p) % p;
    }
    //static int prime[];
    //static int dp[];
    public static void main(String[] args){
        //long sum=0;
        try {
                codeforces.solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
       static long modInverse(long n, long p)
    {
        return power(n, p-(long)2);
    }
 /*static long power(long x, long y, long p)
{
    long res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y %(long)2!=0)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res%p;
 }*/
    public static long power(long x,long a) {
		if(a==0) return 1;
		if(a%2==1)return (x*1L*power(x,a-1))%mod;
		return (power((int)((x*1L*x)%mod),a/2))%mod;
	}
   static int find(int x)
    {
        // Finds the representative of the set
        // that x is an element of
        while(parent[x]!=x)
        {
            // if x is not the parent of itself
            // Then x is not the representative of
            // his set,
            x=parent[x];

            // so we recursively call Find on its parent
            // and move i's node directly under the
            // representative of this set
        }

        return x;
    }
    static void union(int x, int y)
    {
        // Find representatives of two sets
        int xRoot = find(x), yRoot = find(y);

        // Elements are in the same set, no need
        // to unite anything.
        if (xRoot == yRoot)
            return;

         // If x's rank is less than y's rank
        if (rank[xRoot] < rank[yRoot])

            // Then move x under y  so that depth
            // of tree remains less
            parent[xRoot] = yRoot;

        // Else if y's rank is less than x's rank
        else if (rank[yRoot] < rank[xRoot])

            // Then move y under x so that depth of
            // tree remains less
            parent[yRoot] = xRoot;

        else // if ranks are the same
        {
            // Then move y under x (doesn't matter
            // which one goes where)
            parent[yRoot] = xRoot;

            // And increment the the result tree's
            // rank by 1
            rank[xRoot] = rank[xRoot] + 1;
        }
    }
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class codeforces
{
   static class Student{
       int x,y,z;
        Student(int x,int y,int z){
            this.x=x;
            this.y=y;
            this.z=z;
        }
    }
    static int prime[];
    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        int pos=0;
        prime= new int[n+1];
        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == 0)
            {
                // Update all multiples of p
                prime[p]=p;
                for(int i = p*p; i <= n; i += p)
                    prime[i] = p;
            }
        }
    }
static    class Sortbyroll implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student c, Student b)
    {
        return b.x - c.x;
    }
}
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;
        }
    }

    static class Edge{
        int a,b;
        Edge(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    static class Trie{
        HashMap<Character,Trie>map;
         int c;
        Trie(){
            map=new HashMap<>();
            //z=null;
            //o=null;
            c=0;
        }
    }
    //static long ans;
    static int parent[];
    static int rank[];
    static int b[][];
    static int bo[];
    static int ho[];
    static int seg[];
    //static int pos;
   // static long mod=1000000007;
    //static int dp[][];
    static HashMap<Integer,Integer>map;
    static PriorityQueue<Student>q=new PriorityQueue<>();
    //static Stack<Integer>st;
   // static ArrayList<Character>ans;
    static ArrayList<ArrayList<Integer>>adj;
    static int ans;
    static Trie root;
    static long fac[];
    static long mod=(long)(1000000007);
    static void solve()throws IOException{
        FastReader sc=new FastReader();
        long n,k,s;
        int i;
        n=sc.nextLong();
        k=sc.nextLong();
        s=sc.nextLong();
        if(k<=s&&(n-(long)1)*k>=s){
            System.out.println("YES");
            n=s/k+(long)1;
            //System.out.println(n);
            s=s%k;
            StringBuilder sb=new StringBuilder();
            for(i=1;i<=(int)k;i++){
                if(i%2!=0){
                    if(s>=(long)2){
                        sb.append((n+(long)1)+" ");
                        s-=(long)2;
                    }
                    else if(i==k-1||i==k){
                        if(k%(long)2!=0&&s==1){
                            if(i==(int)k)
                                sb.append((n+(long)1)+" ");
                            s-=(long)1;
                        }
                        else
                            if(i==(int)k-1&&s==1){
                                sb.append((n+(long)1)+" ");
                                //s-=(long)1;
                            }
                        else
                            sb.append(n+" ");
                    }
                    else
                        sb.append(n+" ");
                    //System.out.println(s+" "+i);
                }
                else{
                    if(k%(long)2!=0||s!=1||i!=(int)k)
                    sb.append(1+" ");
                    else
                    {
                        sb.append(2+" ");
                        s-=(long)1;
                    }
                }
            }
            System.out.println(sb.toString());
        }
        else{
            System.out.println("NO");
        }
    }
    static void dfs(Trie root,int k){
        if(root==null)
            return;
        for(char i='A';i<='Z';i++){
            if(root.map.containsKey(i)){
                ans+=root.map.get(i).c/k;
                dfs(root.map.get(i),k);
            }
        }
    }
    static long nCr(long n, long r,
                                    long p)
    {
        return (fac[(int)n]* modInverse(fac[(int)r], p)
                % p * modInverse(fac[(int)(n-r)], p)
                                    % p) % p;
    }
    //static int prime[];
    //static int dp[];
    public static void main(String[] args){
        //long sum=0;
        try {
                codeforces.solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
       static long modInverse(long n, long p)
    {
        return power(n, p-(long)2);
    }
 /*static long power(long x, long y, long p)
{
    long res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y %(long)2!=0)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res%p;
 }*/
    public static long power(long x,long a) {
		if(a==0) return 1;
		if(a%2==1)return (x*1L*power(x,a-1))%mod;
		return (power((int)((x*1L*x)%mod),a/2))%mod;
	}
   static int find(int x)
    {
        // Finds the representative of the set
        // that x is an element of
        while(parent[x]!=x)
        {
            // if x is not the parent of itself
            // Then x is not the representative of
            // his set,
            x=parent[x];

            // so we recursively call Find on its parent
            // and move i's node directly under the
            // representative of this set
        }

        return x;
    }
    static void union(int x, int y)
    {
        // Find representatives of two sets
        int xRoot = find(x), yRoot = find(y);

        // Elements are in the same set, no need
        // to unite anything.
        if (xRoot == yRoot)
            return;

         // If x's rank is less than y's rank
        if (rank[xRoot] < rank[yRoot])

            // Then move x under y  so that depth
            // of tree remains less
            parent[xRoot] = yRoot;

        // Else if y's rank is less than x's rank
        else if (rank[yRoot] < rank[xRoot])

            // Then move y under x so that depth of
            // tree remains less
            parent[yRoot] = xRoot;

        else // if ranks are the same
        {
            // Then move y under x (doesn't matter
            // which one goes where)
            parent[yRoot] = xRoot;

            // And increment the the result tree's
            // rank by 1
            rank[xRoot] = rank[xRoot] + 1;
        }
    }
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class codeforces
{
   static class Student{
       int x,y,z;
        Student(int x,int y,int z){
            this.x=x;
            this.y=y;
            this.z=z;
        }
    }
    static int prime[];
    static void sieveOfEratosthenes(int n)
    {
        // Create a boolean array "prime[0..n]" and initialize
        // all entries it as true. A value in prime[i] will
        // finally be false if i is Not a prime, else true.
        int pos=0;
        prime= new int[n+1];
        for(int p = 2; p*p <=n; p++)
        {
            // If prime[p] is not changed, then it is a prime
            if(prime[p] == 0)
            {
                // Update all multiples of p
                prime[p]=p;
                for(int i = p*p; i <= n; i += p)
                    prime[i] = p;
            }
        }
    }
static    class Sortbyroll implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student c, Student b)
    {
        return b.x - c.x;
    }
}
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;
        }
    }

    static class Edge{
        int a,b;
        Edge(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    static class Trie{
        HashMap<Character,Trie>map;
         int c;
        Trie(){
            map=new HashMap<>();
            //z=null;
            //o=null;
            c=0;
        }
    }
    //static long ans;
    static int parent[];
    static int rank[];
    static int b[][];
    static int bo[];
    static int ho[];
    static int seg[];
    //static int pos;
   // static long mod=1000000007;
    //static int dp[][];
    static HashMap<Integer,Integer>map;
    static PriorityQueue<Student>q=new PriorityQueue<>();
    //static Stack<Integer>st;
   // static ArrayList<Character>ans;
    static ArrayList<ArrayList<Integer>>adj;
    static int ans;
    static Trie root;
    static long fac[];
    static long mod=(long)(1000000007);
    static void solve()throws IOException{
        FastReader sc=new FastReader();
        long n,k,s;
        int i;
        n=sc.nextLong();
        k=sc.nextLong();
        s=sc.nextLong();
        if(k<=s&&(n-(long)1)*k>=s){
            System.out.println("YES");
            n=s/k+(long)1;
            //System.out.println(n);
            s=s%k;
            StringBuilder sb=new StringBuilder();
            for(i=1;i<=(int)k;i++){
                if(i%2!=0){
                    if(s>=(long)2){
                        sb.append((n+(long)1)+" ");
                        s-=(long)2;
                    }
                    else if(s==(long)1&&i==k-1||i==k){
                        if(k%(long)2!=0){
                            if(i==(int)k)
                                sb.append((n+(long)1)+" ");
                            s-=(long)1;
                        }
                        else{
                            if(i==(int)k-1){
                                sb.append((n+(long)1)+" ");
                                //s-=(long)1;
                            }
                        }
                    }
                    else
                        sb.append(n+" ");
                    //System.out.println(s+" "+i);
                }
                else{
                    if(k%(long)2!=0||s!=1||i!=(int)k)
                    sb.append(1+" ");
                    else
                    {
                        sb.append(2+" ");
                        s-=(long)1;
                    }
                }
            }
            System.out.println(sb.toString());
        }
        else{
            System.out.println("NO");
        }
    }
    static void dfs(Trie root,int k){
        if(root==null)
            return;
        for(char i='A';i<='Z';i++){
            if(root.map.containsKey(i)){
                ans+=root.map.get(i).c/k;
                dfs(root.map.get(i),k);
            }
        }
    }
    static long nCr(long n, long r,
                                    long p)
    {
        return (fac[(int)n]* modInverse(fac[(int)r], p)
                % p * modInverse(fac[(int)(n-r)], p)
                                    % p) % p;
    }
    //static int prime[];
    //static int dp[];
    public static void main(String[] args){
        //long sum=0;
        try {
                codeforces.solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
    }
       static long modInverse(long n, long p)
    {
        return power(n, p-(long)2);
    }
 /*static long power(long x, long y, long p)
{
    long res = 1;      // Initialize result

    x = x % p;  // Update x if it is more than or
                // equal to p

    while (y > 0)
    {
        // If y is odd, multiply x with result
        if (y %(long)2!=0)
            res = (res*x) % p;

        // y must be even now
        y = y>>1; // y = y/2
        x = (x*x) % p;
    }
    return res%p;
 }*/
    public static long power(long x,long a) {
		if(a==0) return 1;
		if(a%2==1)return (x*1L*power(x,a-1))%mod;
		return (power((int)((x*1L*x)%mod),a/2))%mod;
	}
   static int find(int x)
    {
        // Finds the representative of the set
        // that x is an element of
        while(parent[x]!=x)
        {
            // if x is not the parent of itself
            // Then x is not the representative of
            // his set,
            x=parent[x];

            // so we recursively call Find on its parent
            // and move i's node directly under the
            // representative of this set
        }

        return x;
    }
    static void union(int x, int y)
    {
        // Find representatives of two sets
        int xRoot = find(x), yRoot = find(y);

        // Elements are in the same set, no need
        // to unite anything.
        if (xRoot == yRoot)
            return;

         // If x's rank is less than y's rank
        if (rank[xRoot] < rank[yRoot])

            // Then move x under y  so that depth
            // of tree remains less
            parent[xRoot] = yRoot;

        // Else if y's rank is less than x's rank
        else if (rank[yRoot] < rank[xRoot])

            // Then move y under x so that depth of
            // tree remains less
            parent[yRoot] = xRoot;

        else // if ranks are the same
        {
            // Then move y under x (doesn't matter
            // which one goes where)
            parent[yRoot] = xRoot;

            // And increment the the result tree's
            // rank by 1
            rank[xRoot] = rank[xRoot] + 1;
        }
    }
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
import java.math.BigInteger;
import java.util.regex.*;
public class Myclass {
		/*public static ArrayList a[]=new ArrayList[200001];
		static boolean visited[]=new boolean [200001];
		static long value[];
		static long maxi[];
		static long dp[]=new long[200001];
		static long ans;
		static void dfs(pair n,int p)
		{
			visited[n.x]=true;
			dp[n.x]=Math.max(dp[p]+n.y,n.y);
			if(dp[n.x]>value[n.x])
			{
				ans++;
				return;
			}

			for(int i=0;i<a[n.x].size();i++)
			{
				pair y=(pair) a[n.x].get(i);
				if(!visited[y.x])
				{
					dfs(y,n.x);
				}
			}
		}*/

		public static void main(String[] args)
		{
		    InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);
			long n=in.nextLong();
			long k=in.nextLong();
			long s=in.nextLong();
			Vector<Long>ans=new Vector<>();
			if(s<k || s>(n-1)*k)
			{
				pw.println("NO");
			}
			else
			{
				while(s>0)
				{
					long dis=Math.min(s, n-1);
					if(dis==n-1)
					{
						if(ans.size()==0)
						{
							s-=(n-1);
							ans.add(n);
							continue;
						}
						if(ans.get(ans.size()-1)==n)
							ans.add((long) 1);
						else
							ans.add(n);
						s-=(n-1);
						continue;
					}
					else
					{
						if(ans.get(ans.size()-1)==n)
						{
							ans.add(n-dis);
						}
						else
						{
							ans.add(1+dis);
						}
						s-=dis;
					}
				}
				int step=ans.size();
				Vector<Long>fi=new Vector<>();
				int idx=0;
				long last=1;
				while(step<k && idx<ans.size())
				{
					if(last!=ans.get(idx))
					{
						if(ans.get(idx)>last)
						{
							last++;
							fi.add(last);
						}
						else
						{
							last--;
							fi.add(last);
						}
						step++;
						if(last==ans.get(idx))
						{
							step--;
							idx++;
							last=ans.get(idx-1);
						}
					}

				}
				for(int i=idx;i<ans.size();i++)
					fi.add(ans.get(i));
				pw.println("YES");
				for(int i=0;i<fi.size();i++)
					pw.print(fi.get(i)+" ");
			}

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

		}

		static class InputReader
		{
		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}
		public int snext()
		{
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars)
			{
				curChar = 0;
				try
				{
					snumChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}
		static class tri implements Comparable<tri> {
			int p, c, l;

			tri(int p, int c, int l) {
				this.p = p;
				this.c = c;
				this.l = l;
			}

			public int compareTo(tri o) {
				return Integer.compare(l, o.l);
			}
		}

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

		public String nextLine()
		{
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(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;
		}

		private boolean isEndOfLine(int c)
		{
			return c == '\n' || c == '\r' || c == -1;
		}

		public interface SpaceCharFilter
	    {
			public boolean isSpaceChar(int ch);
		}
	}
		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;

		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}

		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}

		public static HashSet<Integer> primeFactorization(int n)
		{
			HashSet<Integer> a =new HashSet<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}

		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;

			isPrime[0] = false;
			isPrime[1] = false;

			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}

		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}

		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x%M*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result%M * x%M)%M;
		        x=(x%M * x%M)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static boolean isPrime(int n)
		{

		    if (n <= 1)  return false;
		    if (n <= 3)  return true;

		    if (n%2 == 0 || n%3 == 0)
		    	return false;

		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }

		    return true;
		}

		 public static long[] shuffle(long[] a, Random gen){
		        for(int i = 0, n = a.length;i < n;i++){
		            int ind = gen.nextInt(n-i)+i;
		            long d = a[i];
		            a[i] = a[ind];
		            a[ind] = d;
		        }
		        return a;
		    }
		static class pair implements Comparable<pair>
		{
			Integer x;
			Long y;
			pair(int a,long m)
			{
				this.x=a;
				this.y=m;
			}

		public boolean isEmpty() {
				// TODO Auto-generated method stub
				return false;
			}

		public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);

			return result;
			}

			public String toString()
			{
				return x+" "+y;
			}

			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}

			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}
		static  class triplet
		{
			Long x;
			Long y;
			Integer z;
			triplet(long x,long y,int z)
			{
				this.x=x;
				this.y=y;
				this.z=z;
			}
		}
		static class jodi
		{
			Integer x;
			Integer y;
			jodi(int x,int y)
			{
				this.x=x;
				this.y=y;
			}
		}
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
import java.math.BigInteger;
import java.util.regex.*;
public class Myclass {
		/*public static ArrayList a[]=new ArrayList[200001];
		static boolean visited[]=new boolean [200001];
		static long value[];
		static long maxi[];
		static long dp[]=new long[200001];
		static long ans;
		static void dfs(pair n,int p)
		{
			visited[n.x]=true;
			dp[n.x]=Math.max(dp[p]+n.y,n.y);
			if(dp[n.x]>value[n.x])
			{
				ans++;
				return;
			}

			for(int i=0;i<a[n.x].size();i++)
			{
				pair y=(pair) a[n.x].get(i);
				if(!visited[y.x])
				{
					dfs(y,n.x);
				}
			}
		}*/

		public static void main(String[] args)
		{
		    InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);
			long n=in.nextLong();
			long k=in.nextLong();
			long s=in.nextLong();
			Vector<Long>ans=new Vector<>();
			if(s<k || s>(n-1)*k)
			{
				pw.println("NO");
			}
			else
			{
				while(s>0)
				{
					long dis=Math.min(s, n-1);
					if(dis==n-1)
					{
						if(ans.size()==0)
						{
							s-=(n-1);
							ans.add(n);
							continue;
						}
						if(ans.get(ans.size()-1)==n)
							ans.add((long) 1);
						else
							ans.add(n);
						s-=(n-1);
						continue;
					}
					else
					{
						if(ans.size()==0)
						{
							ans.add(1+dis);
							s-=dis;
							continue;
						}
						if(ans.get(ans.size()-1)==n)
						{
							ans.add(n-dis);
						}
						else
						{
							ans.add(1+dis);
						}
						s-=dis;
					}
				}
				int step=ans.size();
				Vector<Long>fi=new Vector<>();
				int idx=0;
				long last=1;
				while(step<k && idx<ans.size())
				{
					if(last!=ans.get(idx))
					{
						if(ans.get(idx)>last)
						{
							last++;
							fi.add(last);
						}
						else
						{
							last--;
							fi.add(last);
						}
						step++;
						if(last==ans.get(idx))
						{
							step--;
							idx++;
							last=ans.get(idx-1);
						}
					}

				}
				for(int i=idx;i<ans.size();i++)
					fi.add(ans.get(i));
				pw.println("YES");
				for(int i=0;i<fi.size();i++)
					pw.print(fi.get(i)+" ");
			}

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

		}

		static class InputReader
		{
		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}
		public int snext()
		{
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars)
			{
				curChar = 0;
				try
				{
					snumChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}
		static class tri implements Comparable<tri> {
			int p, c, l;

			tri(int p, int c, int l) {
				this.p = p;
				this.c = c;
				this.l = l;
			}

			public int compareTo(tri o) {
				return Integer.compare(l, o.l);
			}
		}

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

		public String nextLine()
		{
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(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;
		}

		private boolean isEndOfLine(int c)
		{
			return c == '\n' || c == '\r' || c == -1;
		}

		public interface SpaceCharFilter
	    {
			public boolean isSpaceChar(int ch);
		}
	}
		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;

		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}

		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}

		public static HashSet<Integer> primeFactorization(int n)
		{
			HashSet<Integer> a =new HashSet<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}

		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;

			isPrime[0] = false;
			isPrime[1] = false;

			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}

		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}

		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x%M*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result%M * x%M)%M;
		        x=(x%M * x%M)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static boolean isPrime(int n)
		{

		    if (n <= 1)  return false;
		    if (n <= 3)  return true;

		    if (n%2 == 0 || n%3 == 0)
		    	return false;

		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }

		    return true;
		}

		 public static long[] shuffle(long[] a, Random gen){
		        for(int i = 0, n = a.length;i < n;i++){
		            int ind = gen.nextInt(n-i)+i;
		            long d = a[i];
		            a[i] = a[ind];
		            a[ind] = d;
		        }
		        return a;
		    }
		static class pair implements Comparable<pair>
		{
			Integer x;
			Long y;
			pair(int a,long m)
			{
				this.x=a;
				this.y=m;
			}

		public boolean isEmpty() {
				// TODO Auto-generated method stub
				return false;
			}

		public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);

			return result;
			}

			public String toString()
			{
				return x+" "+y;
			}

			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}

			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}
		static  class triplet
		{
			Long x;
			Long y;
			Integer z;
			triplet(long x,long y,int z)
			{
				this.x=x;
				this.y=y;
				this.z=z;
			}
		}
		static class jodi
		{
			Integer x;
			Integer y;
			jodi(int x,int y)
			{
				this.x=x;
				this.y=y;
			}
		}
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.lang.*;
import java.math.BigInteger;
import java.util.regex.*;
public class Myclass {
		/*public static ArrayList a[]=new ArrayList[200001];
		static boolean visited[]=new boolean [200001];
		static long value[];
		static long maxi[];
		static long dp[]=new long[200001];
		static long ans;
		static void dfs(pair n,int p)
		{
			visited[n.x]=true;
			dp[n.x]=Math.max(dp[p]+n.y,n.y);
			if(dp[n.x]>value[n.x])
			{
				ans++;
				return;
			}

			for(int i=0;i<a[n.x].size();i++)
			{
				pair y=(pair) a[n.x].get(i);
				if(!visited[y.x])
				{
					dfs(y,n.x);
				}
			}
		}*/

		public static void main(String[] args)
		{
		    InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);
			long n=in.nextLong();
			long k=in.nextLong();
			long s=in.nextLong();
			Vector<Long>ans=new Vector<>();
			if(s<k || s>(n-1)*k)
			{
				pw.println("NO");
			}
			else
			{
				while(s>0)
				{
					long dis=Math.min(s, n-1);
					if(dis==n-1)
					{
						if(ans.size()==0)
						{
							s-=(n-1);
							ans.add(n);
							continue;
						}
						if(ans.get(ans.size()-1)==n)
							ans.add((long) 1);
						else
							ans.add(n);
						s-=(n-1);
						continue;
					}
					else
					{
						if(ans.get(ans.size()-1)==n)
						{
							ans.add(n-dis);
						}
						else
						{
							ans.add(1+dis);
						}
						s-=dis;
					}
				}
				int step=ans.size();
				Vector<Long>fi=new Vector<>();
				int idx=0;
				long last=1;
				while(step<k)
				{
					if(last!=ans.get(idx))
					{
						if(ans.get(idx)>last)
						{
							last++;
							fi.add(last);
						}
						else
						{
							last--;
							fi.add(last);
						}
						step++;
					}
					else
					{
					//	pw.println(fi.toString());
						step--;
						idx++;
						last=ans.get(idx-1);
					}
				}
				for(int i=idx;i<ans.size();i++)
					fi.add(ans.get(i));
				pw.println("YES");
				for(int i=0;i<fi.size();i++)
					pw.print(fi.get(i)+" ");
			}

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

		}

		static class InputReader
		{
		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}
		public int snext()
		{
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars)
			{
				curChar = 0;
				try
				{
					snumChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

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

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

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

		public int[] nextIntArray(int n)
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
			{
				a[i] = nextInt();
			}
			return a;
		}
		static class tri implements Comparable<tri> {
			int p, c, l;

			tri(int p, int c, int l) {
				this.p = p;
				this.c = c;
				this.l = l;
			}

			public int compareTo(tri o) {
				return Integer.compare(l, o.l);
			}
		}

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

		public String nextLine()
		{
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = snext();
			} while (!isEndOfLine(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;
		}

		private boolean isEndOfLine(int c)
		{
			return c == '\n' || c == '\r' || c == -1;
		}

		public interface SpaceCharFilter
	    {
			public boolean isSpaceChar(int ch);
		}
	}
		public static long mod = 1000000007;
		public static int d;
		public static int p;
		public static int q;

		public static int[] suffle(int[] a,Random gen)
		{
			int n = a.length;
			for(int i=0;i<n;i++)
			{
				int ind = gen.nextInt(n-i)+i;
				int temp = a[ind];
				a[ind] = a[i];
				a[i] = temp;
			}
			return a;
		}

		public static void swap(int a, int b){
			int temp = a;
			a = b;
			b = temp;
		}

		public static HashSet<Integer> primeFactorization(int n)
		{
			HashSet<Integer> a =new HashSet<Integer>();
			for(int i=2;i*i<=n;i++)
			{
				while(n%i==0)
				{
					a.add(i);
					n/=i;
				}
			}
			if(n!=1)
				a.add(n);
			return a;
		}

		public static void sieve(boolean[] isPrime,int n)
		{
			for(int i=1;i<n;i++)
				isPrime[i] = true;

			isPrime[0] = false;
			isPrime[1] = false;

			for(int i=2;i*i<n;i++)
			{
				if(isPrime[i] == true)
				{
					for(int j=(2*i);j<n;j+=i)
						isPrime[j] = false;
				}
			}
		}

		public static int GCD(int a,int b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static void extendedEuclid(int A,int B)
		{
			if(B==0)
			{
				d = A;
				p = 1 ;
				q = 0;
			}
			else
			{
				extendedEuclid(B, A%B);
				int temp = p;
				p = q;
				q = temp - (A/B)*q;
			}
		}

		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int LCM(int a,int b)
		{
			return (a*b)/GCD(a,b);
		}

		public static int binaryExponentiation(int x,int n)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static long binaryExponentiation(long x,long n)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=result * x;
		        x=x*x;
		        n=n/2;
		    }
		    return result;
		}

		public static int modularExponentiation(int x,int n,int M)
		{
		    int result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x%M*x)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modularExponentiation(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result%M * x%M)%M;
		        x=(x%M * x%M)%M;
		        n=n/2;
		    }
		    return result;
		}

		public static long modInverse(int A,int M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static long modInverse(long A,long M)
		{
		    return modularExponentiation(A,M-2,M);
		}

		public static boolean isPrime(int n)
		{

		    if (n <= 1)  return false;
		    if (n <= 3)  return true;

		    if (n%2 == 0 || n%3 == 0)
		    	return false;

		    for (int i=5; i*i<=n; i=i+6)
		    {
		        if (n%i == 0 || n%(i+2) == 0)
		           return false;
		    }

		    return true;
		}

		 public static long[] shuffle(long[] a, Random gen){
		        for(int i = 0, n = a.length;i < n;i++){
		            int ind = gen.nextInt(n-i)+i;
		            long d = a[i];
		            a[i] = a[ind];
		            a[ind] = d;
		        }
		        return a;
		    }
		static class pair implements Comparable<pair>
		{
			Integer x;
			Long y;
			pair(int a,long m)
			{
				this.x=a;
				this.y=m;
			}

		public boolean isEmpty() {
				// TODO Auto-generated method stub
				return false;
			}

		public int compareTo(pair o) {
				int result = x.compareTo(o.x);
				if(result==0)
					result = y.compareTo(o.y);

			return result;
			}

			public String toString()
			{
				return x+" "+y;
			}

			public boolean equals(Object o)
			{
				if (o instanceof pair)
			    {
					pair p = (pair)o;
					return p.x == x && p.y == y ;
				}
				return false;
			}

			public int hashCode()
			{
				return new Long(x).hashCode()*31 + new Long(y).hashCode();
			}
		}
		static  class triplet
		{
			Long x;
			Long y;
			Integer z;
			triplet(long x,long y,int z)
			{
				this.x=x;
				this.y=y;
				this.z=z;
			}
		}
		static class jodi
		{
			Integer x;
			Integer y;
			jodi(int x,int y)
			{
				this.x=x;
				this.y=y;
			}
		}
}


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

public class Q3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long N = in.nextInt(), k = in.nextInt(), S = in.nextInt();

        if ((N - 1) * k < S) {
            out.println("NO");
        } else {

            StringBuilder sb=new StringBuilder();
            out.println("YES");
            long prv=1,val;
            while (k-- > 0) {

                val=S-k;
                val=Math.min(val,N-1);
                if(val==0){
                    if(prv==1){
                        sb.append(2+" ");
                        prv=2;
                    }else if(prv==N){
                        sb.append(N-1+" ");
                        prv=N-1;
                    }else{
                        sb.append(prv-1+" ");
                        prv=prv-1;
                    }
                }else{
                    if(prv==1){
                        sb.append((prv+val)+" ");
                        prv=prv+val;
                    }else{
                        sb.append((prv-val)+" ");
                        prv-=val;
                    }
                }
                S-=val;

            }

            out.println(sb);

        }
        out.close();
    }

    ///          PREFIX AND SUFFIX REMOVAL D PROBLEM
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        PrintWriter out = new PrintWriter(System.out);
//
//        int N = in.nextInt(), M = in.nextInt(), j = 0;
//        int arr[] = new int[N];
//        HashMap<String, Integer> map = new HashMap<>();
//
//        while (j<M) {
//            for (int i = 0; i < N; i++)
//                arr[i] = in.nextInt();
//            StringBuilder t = new StringBuilder();
//            for (int i = 0; i < N; i++) {
//                t=new StringBuilder();
//                for (int k = i; k < N; k++) {
//                    t.append(arr[k]); t.append("^");
//                    map.put(t.toString(), map.getOrDefault(t.toString(), 0) + 1);
//                }
//            }
//            j++;
//        }
//
//        long ans = 0;
//        for (String key : map.keySet()) {
//            if (map.get(key) == M)
//                ans++;
//        }
//        out.println(ans);
//
//        out.close();
//    }
}


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

public class Q3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long N = in.nextInt(), k = in.nextInt(), S = in.nextInt();

        if ((N - 1) * k < S   || (S<k)) {
            out.println("NO");
        } else {

            StringBuilder sb=new StringBuilder();
            out.println("YES");
            long prv=1,val;
            while (k-- > 0) {

                val=S-k;
                val=Math.min(val,N-1);
                if(val==0){
                    if(prv==1){
                        sb.append(2+" ");
                        prv=2;
                    }else if(prv==N){
                        sb.append(N-1+" ");
                        prv=N-1;
                    }else{
                        sb.append(prv-1+" ");
                        prv=prv-1;
                    }
                }else{
                    if(prv==1){
                        sb.append((prv+val)+" ");
                        prv=prv+val;
                    }else{
                        sb.append((prv-val)+" ");
                        prv-=val;
                    }
                }
                S-=val;

            }

            out.println(sb);

        }
        out.close();
    }

    ///          PREFIX AND SUFFIX REMOVAL D PROBLEM
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        PrintWriter out = new PrintWriter(System.out);
//
//        int N = in.nextInt(), M = in.nextInt(), j = 0;
//        int arr[] = new int[N];
//        HashMap<String, Integer> map = new HashMap<>();
//
//        while (j<M) {
//            for (int i = 0; i < N; i++)
//                arr[i] = in.nextInt();
//            StringBuilder t = new StringBuilder();
//            for (int i = 0; i < N; i++) {
//                t=new StringBuilder();
//                for (int k = i; k < N; k++) {
//                    t.append(arr[k]); t.append("^");
//                    map.put(t.toString(), map.getOrDefault(t.toString(), 0) + 1);
//                }
//            }
//            j++;
//        }
//
//        long ans = 0;
//        for (String key : map.keySet()) {
//            if (map.get(key) == M)
//                ans++;
//        }
//        out.println(ans);
//
//        out.close();
//    }
}


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

public class Q3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long N = in.nextInt(), k = in.nextInt(), S = in.nextLong();

        if ((N - 1 )* k < S || (S < k)) {
            out.println("NO");
        } else {
            StringBuilder sb = new StringBuilder();
            out.println("YES");
            long prv = 1, val;
            while (k-- > 0) {

                val = Math.min(S-k, N - 1);
                if (prv+val<=N) {
                    sb.append(prv+val + " ");
                    prv = prv+val;
                } else  {
                    sb.append(prv-val + " ");
                    prv = prv-val;
                }
                S -= val;
            }
            out.println(sb);
        }
        out.close();
    }

    ///          PREFIX AND SUFFIX REMOVAL D PROBLEM
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        PrintWriter out = new PrintWriter(System.out);
//
//        int N = in.nextInt(), M = in.nextInt(), j = 0;
//        int arr[] = new int[N];
//        HashMap<String, Integer> map = new HashMap<>();
//
//        while (j<M) {
//            for (int i = 0; i < N; i++)
//                arr[i] = in.nextInt();
//            StringBuilder t = new StringBuilder();
//            for (int i = 0; i < N; i++) {
//                t=new StringBuilder();
//                for (int k = i; k < N; k++) {
//                    t.append(arr[k]); t.append("^");
//                    map.put(t.toString(), map.getOrDefault(t.toString(), 0) + 1);
//                }
//            }
//            j++;
//        }
//
//        long ans = 0;
//        for (String key : map.keySet()) {
//            if (map.get(key) == M)
//                ans++;
//        }
//        out.println(ans);
//
//        out.close();
//    }
}


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

public class Q3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long N = in.nextInt(), k = in.nextInt(), S = in.nextLong();

        if ((N - 1) * k < S   || (S<k)) {
            out.println("NO");
        } else {

            StringBuilder sb=new StringBuilder();
            out.println("YES");
            long prv=1,val;
            while (k-- > 0) {

                val=S-k;
                val=Math.min(val,N-1);
                if(val==0){
                    if(prv==1){
                        sb.append(2+" ");
                        prv=2;
                    }else if(prv==N){
                        sb.append(N-1+" ");
                        prv=N-1;
                    }else{
                        sb.append(prv-1+" ");
                        prv=prv-1;
                    }
                }else{
                    if(prv==1){
                        sb.append((prv+val)+" ");
                        prv=prv+val;
                    }else{
                        sb.append((prv-val)+" ");
                        prv-=val;
                    }
                }
                S-=val;

            }

            out.println(sb);

        }
        out.close();
    }

    ///          PREFIX AND SUFFIX REMOVAL D PROBLEM
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        PrintWriter out = new PrintWriter(System.out);
//
//        int N = in.nextInt(), M = in.nextInt(), j = 0;
//        int arr[] = new int[N];
//        HashMap<String, Integer> map = new HashMap<>();
//
//        while (j<M) {
//            for (int i = 0; i < N; i++)
//                arr[i] = in.nextInt();
//            StringBuilder t = new StringBuilder();
//            for (int i = 0; i < N; i++) {
//                t=new StringBuilder();
//                for (int k = i; k < N; k++) {
//                    t.append(arr[k]); t.append("^");
//                    map.put(t.toString(), map.getOrDefault(t.toString(), 0) + 1);
//                }
//            }
//            j++;
//        }
//
//        long ans = 0;
//        for (String key : map.keySet()) {
//            if (map.get(key) == M)
//                ans++;
//        }
//        out.println(ans);
//
//        out.close();
//    }
}