Problem: Vasya the Great Magician and Conjurer loves all kinds of miracles and wizardry. In one wave of a magic wand he can turn an object into something else. But, as you all know, there is no better magic in the Universe than the magic of numbers. That's why Vasya adores math and spends a lot of time turning some numbers into some other ones.

This morning he has n cards with integers lined up in front of him. Each integer is not less than 1, but not greater than l. When Vasya waves his magic wand, two rightmost cards vanish from the line and a new card magically appears in their place. It contains the difference between the left and the right numbers on the two vanished cards. Vasya was very interested to know what would happen next, and so he waved with his magic wand on and on, until the table had a single card left.

Suppose that Vasya originally had the following cards: 4, 1, 1, 3 (listed from left to right). Then after the first wave the line would be: 4, 1, -2, and after the second one: 4, 3, and after the third one the table would have a single card with number 1.

Please note that in spite of the fact that initially all the numbers on the cards were not less than 1 and not greater than l, the numbers on the appearing cards can be anything, no restrictions are imposed on them.

It is now evening. Vasya is very tired and wants to return everything back, but does not remember which cards he had in the morning. He only remembers that there were n cards, they contained integers from 1 to l, and after all magical actions he was left with a single card containing number d.

Help Vasya to recover the initial set of cards with numbers.

Input

The single line contains three space-separated integers: n (2 ≤ n ≤ 100) — the initial number of cards on the table, d (|d| ≤ 104) — the number on the card that was left on the table after all the magical actions, and l (1 ≤ l ≤ 100) — the limits for the initial integers.

Output

If Vasya is mistaken, that is, if there doesn't exist a set that meets the requirements given in the statement, then print a single number -1, otherwise print the sought set containing n integers from 1 to l. Separate the integers by spaces. Print the integers in the order, in which they were written on the cards from left to right. If there are several suitable sets of numbers, you can print any of them.

Examples

Input

3 3 2


Output

2 1 2 

Input

5 -4 3


Output

-1


Input

5 -4 4


Output

2 4 1 4 1 

Solution (in JAVA):

Solution:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.io.InputStream;
import java.io.PrintStream;



/**
 * Solution class structure!
 * 
 * This should be easy. Modify the static solution() method to make your solution, and modify the
 * run() method to translate console input into inputs for your solution
 * 
 */
public class Solution implements Runnable {
    
    /**
     * <u>DONT MODIFY</u><br>
     * 
     * Program entry point. This will instantiate and execute the solution.
     * 
     * @param args
     */
    public static void main(final String[] args) {
        
        final Solution solution = new Solution(System.in, System.out);
        solution.run();
    }
    
    /**
     * <b>THE SOLUTION TO THE PROBLEM!</b><br>
     * 
     * This is a function that turns a bunch of inputs into an output
     * 
     * @return The answer in some form of collection of integers
     */
    public static Collection<Integer> solution(final int n, final int d, final int l) {
        
        final int p;
        final int q;
        final int k;
        final Integer[] result = new Integer[n];
        
        if (d > 0) {
            
            // Even case
            if (n % 2 == 0) {
                
                // Check bounds
                if (d >  (n / 2) * l - (n / 2) || d < (n / 2) - (n / 2) * l) {
                    return null;
                }
                
                k = (int) ((n * l - 2 * d) / 2 - (n / 2) * Math.floor((n * l - 2 * d) / n));
                
                p = (int) Math.ceil((n * l - 2 * d) / (double) n);
                q = (int) Math.floor((n * l - 2 * d) / (double) n);
                //System.out.printf("k=%d, p=%d q=%d\n", k, p, q);
            } else {
                
                if (d < l) {
                    result[0] = d;
                    for (int i = 1; i < result.length; i++) {
                        result[i] = 1;
                    }
                    
                    return Arrays.asList(result);
                }
                
                // Check bounds
                if (d >  ((n + 1) / 2) * l - ((n - 1) / 2) || d < ((n + 1) / 2) - ((n - 1) / 2) * l) {
                    return null;
                }
                
                k = (int) (((n + 1) * l - 2 * d) / 2 - ((n - 1) / 2) * Math.floor(((n + 1) * l - 2 * d) / (n - 1)));
                
                p = (int) Math.ceil(((n + 1) * l - 2 * d) / (double) (n - 1));
                q = (int) Math.floor(((n + 1) * l - 2 * d) / (double) (n - 1));
            }
            
            // Fill the array and output
            for (int i = 0; i < n; i += 2) {
                result[i] = l;
            }
            for (int i = 1; i < n; i += 2) {
                if (i < 2 * k + 1) {
                    result[i] = p;
                } else {
                    result[i] = q;
                }
            }
            
            return Arrays.asList(result);
            
        } else {
            
            // Here, d is negative
            
            // Even case
            if (n % 2 == 0) {
                
                // Check bounds
                if (d >  (n / 2) * l - (n / 2) || d < (n / 2) - (n / 2) * l) {
                    return null;
                }
                
                k = (n * l + 2 * d) / 2 - (n / 2) * (int) Math.floor((n * l + 2 * d) / n);
                
                q = (int) Math.floor((n * l + 2 * d) / (double) n);
                p = (int) Math.ceil((n * l + 2 * d) / (double) n);
                
            } else {
                
                // Check bounds
                if (d >  ((n + 1) / 2) * l - ((n - 1) / 2) || d < ((n + 1) / 2) - ((n - 1) / 2) * l) {
                    return null;
                }
                
                k = ((n - 1) * l + 2 * d) / 2 - ((n + 1) / 2) * (int) Math.floor(((n - 1) * l + 2 * d) / (n + 1));
                
                q = (int) Math.floor(((n - 1) * l + 2 * d) / (double) (n + 1));
                p = (int) Math.ceil(((n - 1) * l + 2 * d) / (double) (n + 1));
            }
            
            // Fill the array and output
            for (int i = 0; i < n; i += 2) {
                if (i <= 2 * k - 2) {
                    result[i] = p;
                } else {
                    result[i] = q;
                }
            }
            for (int i = 1; i < n; i += 2) {
                result[i] = l;
            }
            
            return Arrays.asList(result);
        }
    }
    
    /**
     * <u>DONT MODIFY</u><br>
     * 
     * Writes data to an output stream
     *
     * @param output
     *            The stream to receive the output
     * @param data
     *            The data (in an iterable form) to be output
     */
    private static void outputData(final PrintStream output, final Iterable<Integer> data) {
        
        final Iterator<Integer> iterator = data.iterator();
        
        if (iterator.hasNext()) {
            output.print(iterator.next().intValue());
        }
        
        while (iterator.hasNext()) {
            output.print(" ");
            output.print(iterator.next().intValue());
        }
        
        output.flush();
    }
    
    /**
     * <u>DONT MODIFY</u><br>
     * 
     * Takes an input stream and translates it into a usable data structure for the solution
     *
     * @param input
     *            The InputStream to be translated
     * @return A list of the form list.get(line).get(index)
     */
    private static List<List<Integer>> translateArguments(final InputStream input) {
        
        final List<List<Integer>> result = new ArrayList<>();
        
        try (final Scanner scan = new Scanner(input)) {
            
            // Loop through the lines in the input
            for (int lineCount = 0; scan.hasNextLine(); lineCount++) {
                
                result.add(new ArrayList<>());
                
                // Split the input line up
                final String[] line = scan.nextLine().split(" ");
                
                // Put the numbers from in input into a data structure
                for (int i = 0; i < line.length; i++) {
                    final int number = Integer.parseInt(line[i]);
                    result.get(lineCount).add(number);
                }
            }
            
        }
        
        return result;
    }
    
    
    private final InputStream consoleIn;
    private final PrintStream consoleOut;
    
    
    /**
     * <u>DONT MODIFY</u><br>
     * 
     * Creates a new solution instance with the specified console streams for unit testing
     * 
     * @param consoleIn
     * @param consoleOut
     */
    public Solution(final InputStream consoleIn, final PrintStream consoleOut) {
        this.consoleIn = consoleIn;
        this.consoleOut = consoleOut;
    }
    
    /**
     * Run the solution using the specified inputs and outputs described in the constructor
     */
    @Override
    public void run() {
        
        final List<List<Integer>> args = translateArguments(consoleIn);
        
        //TODO Change the modify which arguments go where in passing to the solution
        Collection<Integer> solution = solution(args.get(0).get(0), args.get(0).get(1), args.get(0).get(2));
        if (solution == null) {
            solution = new ArrayList<>();
            solution.add(-1);
        }
        
        outputData(consoleOut, solution);
    }
}