Problem: Given are three integers N, K, and S.

Find a sequence A_1, A_2, ..., A_N of N integers between 1 and 10^9 (inclusive) that satisfies the condition below. We can prove that, under the conditions in Constraints, such a sequence always exists.

* There are exactly K pairs (l, r) of integers such that 1 \leq l \leq r \leq N and A_l + A_{l + 1} + \cdots + A_r = S.

Constraints

* 1 \leq N \leq 10^5
* 0 \leq K \leq N
* 1 \leq S \leq 10^9
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N K S


Output

Print a sequence satisfying the condition, in the following format:


A_1 A_2 ... A_N

Output

Print a sequence satisfying the condition, in the following format:


A_1 A_2 ... A_N

Examples

Input

4 2 3


Output

1 2 3 4


Input

5 3 100


Output

50 50 50 30 70

Solution (in JAVA):

Solution:

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

public class Main {
    static final Scanner sc    = new Scanner(System.in);
    static final int     MOD   = (int) 1E9 + 7;
    static final long    INF_L = (long) 4E18;
    static final int     INF   = Integer.MAX_VALUE;
    
    public static void main(String[] args) {
        final int S_MAX = (int) 1e9;
        int N = nint();
        int K = nint();
        int S = nint();
        
        int[] ans = new int[N];
        if (S == S_MAX) {
            Arrays.fill(ans, 1);
            for (int i = 0; i < K; i++) {
                ans[i] = S;
            }
        } else {
            Arrays.fill(ans, S_MAX);
            for (int i = 0; i < K; i++) {
                ans[i] = S;
            }
        }
        PrintWriter out = new PrintWriter(System.out);
        for (int i: ans) {
            out.print(i);
            out.print(" ");
        }
        out.flush();
    }
    static class Point {
        long left;
        long right;
        public Point(long left, long right) {
            super();
            this.left = left;
            this.right = right;
        }
        @Override
        public String toString() {
            return "(" + left + ", " + right + ")";
        }
        long getLeft() {return left;}
    }
    
    @Deprecated
    static int nint() {
        return sc.nextInt();
    }

    @Deprecated
    static int[] nints(int N) {
        return nints(N, 0, 0);
    }

    @Deprecated
    private static int[] nints(int N, int padL, int padR) {
        int[] a = new int[padL + N + padR];
        for (int i = 0; i < N; i++)
            a[padL + i] = nint();
        return a;
    }

    static long nlong() {
        return sc.nextLong();
    }

    static long[] nlongs(int N) {
        return nlongs(N, 0, 0);
    }

    static long[] nlongs(int N, int padL, int padR) {
        long[] a = new long[padL + N + padR];
        for (int i = 0; i < N; i++)
            a[padL + i] = nlong();
        return a;
    }

    static double ndouble() {
        return sc.nextDouble();
    }

    static double[] ndoubles(int N) {
        return ndoubles(N, 0, 0);
    }

    static double[] ndoubles(int N, int padL, int padR) {
        double[] d = new double[N + padL + padR];
        for (int i = 0; i < N; i++) {
            d[padL + i] = ndouble();
        }
        return d;
    }

    static String nstr() {
        return sc.next();
    }

    static char[] nchars() {
        return sc.next().toCharArray();
    }

    static char[] nchars(int padL, int padR) {
        char[] temp = sc.next().toCharArray();
        char[] ret = new char[temp.length + padL + padR];
        System.arraycopy(temp, 0, ret, padL, temp.length);
        return ret;
    }

    static char[][] nchars2(int H, int W) {
        return nchars2(H, W, 0, 0);
    }

    static char[][] nchars2(int H, int W, int padLU, int padRD) {
        char[][] a2 = new char[H + padLU + padRD][W + padLU + padRD];
        for (int i = 0; i < H; i++)
            System.arraycopy(nchars(), 0, a2[padLU + i], padLU, W);
        return a2;
    }

    static long min(long... ls) {
        return Arrays.stream(ls).min().getAsLong();
    }

    static long max(long... ls) {
        return Arrays.stream(ls).max().getAsLong();
    }

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