Problem: A group of n merry programmers celebrate Robert Floyd's birthday. Polucarpus has got an honourable task of pouring Ber-Cola to everybody. Pouring the same amount of Ber-Cola to everybody is really important. In other words, the drink's volume in each of the n mugs must be the same.

Polycarpus has already began the process and he partially emptied the Ber-Cola bottle. Now the first mug has a1 milliliters of the drink, the second one has a2 milliliters and so on. The bottle has b milliliters left and Polycarpus plans to pour them into the mugs so that the main equation was fulfilled.

Write a program that would determine what volume of the drink Polycarpus needs to add into each mug to ensure that the following two conditions were fulfilled simultaneously: 

  * there were b milliliters poured in total. That is, the bottle need to be emptied; 
  * after the process is over, the volumes of the drink in the mugs should be equal. 

Input

The first line contains a pair of integers n, b (2 ≤ n ≤ 100, 1 ≤ b ≤ 100), where n is the total number of friends in the group and b is the current volume of drink in the bottle. The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 100), where ai is the current volume of drink in the i-th mug.

Output

Print a single number "-1" (without the quotes), if there is no solution. Otherwise, print n float numbers c1, c2, ..., cn, where ci is the volume of the drink to add in the i-th mug. Print the numbers with no less than 6 digits after the decimal point, print each ci on a single line. Polycarpus proved that if a solution exists then it is unique.

Russian locale is installed by default on the testing computer. Make sure that your solution use the point to separate the integer part of a real number from the decimal, not a comma.

Examples

Input

5 50
1 2 3 4 5


Output

12.000000
11.000000
10.000000
9.000000
8.000000


Input

2 2
1 100


Output

-1

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main {

    FastScanner in;
    PrintWriter out;

    Main() {
        in = new FastScanner(IO_Type.CONSOLE).getScanner();
        out = new FastWriter(IO_Type.CONSOLE).getWriter();

        // in = new FastScanner(IO_Type.TEST, "test.txt").getScanner();
        // out = new FastWriter(IO_Type.TEST, "result.txt").getWriter();

        // in = new FastScanner(IO_Type.FILE, "input.txt").getScanner();
        // out = new FastWriter(IO_Type.TEST, "output.txt").getWriter();
    }

    public static void main(String[] args) {
        Main task = new Main();
        task.solveA();
        task.close();
    }

    public void close() {
        in.close();
        out.close();
    }

    public void solveA() {
        int n = in.nextInt();
        double l = in.nextInt();
        double[]tab = new double[n];
        
        double sum = l;
        
        for (int i = 0; i < tab.length; i++) {
            tab[i] = in.nextDouble();
            sum += tab[i];
        }
        double need = (double)sum / (double)n;
        
        ArrayList<Double>answer = new ArrayList<Double>();
        for (int  i = 0; i < n; i++) {
            double x = need - tab[i];
            if (sum < 0 || tab[i] > need) {
                System.out.println(-1);
                return;
            }
            else {
                sum -= x;
                answer.add(x);
            }
        }
        
        for (int i = 0; i < answer.size(); i++) {
            System.out.println(answer.get(i));
        }
        
    }
    
    public void solve() {
        int n = in.nextInt();
        int[]tab = new int[n];
        
        for (int i = 0; i < n; i++) {
            tab[i] = in.nextInt();
        }
        
        ArrayList<Integer>answer = new ArrayList<Integer>();
        int count = 0;
        int begin = 0;
        while(true) {
            int min = Integer.MAX_VALUE;
            int start = -1;
            int end = -1;
            for (int i = begin; i < tab.length; i++) {
                if (tab[i] != 0 && start == -1) {
                    start = i;
                    begin = start;
                    continue;
                }
                if (tab[i] == 0 && start != -1) {
                    end = i;
                    break;
                }
            }
            if (start == -1 && end == -1) break;
            if (end == -1) {
                end = tab.length;
            }
            for (int i = start; i < end; i++) {
                min = Math.min(min, tab[i]);
            }
            for (int i = start; i < end; i++) {
                tab[i] -= min;
            }
            count += min;
            for (int i = 0; i < min; i++) {
                answer.add(start + 1);
                answer.add(end);
            }
            
        }       
        
        out.println(count);
        for (int i = 0; i < answer.size(); i+=2) {
            out.println(answer.get(i) + " " + answer.get(i + 1));
        }
        
        
        
    }
}

class Algebra {
    /****
     * Number of co-prime numbers on [1, n]. Number a is Co-prime if gcd (a, n)
     * == 1 O (sqrt(n))
     ****/
    public static int phi(int n) {
        int result = n;
        for (int i = 2; i * i <= n; ++i) {
            if (n % i == 0) {
                while (n % i == 0) {
                    n /= i;
                }
                result -= result / i;
            }
        }
        if (n > 1) {
            result -= result / n;
        }
        return result;
    }

    /****
     * Raise number a to power of n. O (log n)
     ****/
    public static int binpow(int a, int n) {
        int res = 1;
        while (n != 0) {
            if ((n & 1) == 1)
                res *= a;
            a *= a;
            n >>= 1;
        }
        return res;
    }

    /****
     * Finding the greatest common divisor of two numbers. O (log min(a, b))
     ****/
    public static int gcd(int a, int b) {
        return (b != 0) ? gcd(b, a % b) : a;
    }

    /****
     * Finding the lowest common multiple of two numbers. O (log min(a, b))
     ****/
    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    /****
     * Eratosthenes Sieve of numbers - [0..n]. True - simple, False - not
     * simple. O (n log log n)
     ****/
    public static boolean[] sieveOfEratosthenes(int n) {
        boolean[] prime = new boolean[n + 1];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i <= n; ++i) {
            if (prime[i]) {
                if (i * 1L * i <= n) {
                    for (int j = i * i; j <= n; j += i) {
                        prime[j] = false;
                    }
                }
            }
        }
        return prime;
    }
}

class IO_Type {

    public static String CONSOLE = "console";
    public static String FILE = "file";
    public static String TEST = "test";

}

class FastScanner {

    BufferedReader br;
    StringTokenizer st;

    FastScanner getScanner() {
        return this;
    }

    FastScanner(String type) {
        if (type.equals("console")) {
            FastScanner(System.in);
        }
    }

    FastScanner(String type, String inFileName) {
        if (type.equals("file")) {
            File f = new File(inFileName);
            try {
                FastScanner(new FileInputStream(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        } else if (type.equals("test")) {
            File f = new File(inFileName);
            try {
                FastScanner(new FileInputStream(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    void FastScanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
    }

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                System.err.println(e);
                return "";
            }
        }
        return st.nextToken();
    }

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

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

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

    float nextFloat() {
        return Float.parseFloat(next());
    }

    BigInteger nextBigInt() {
        return new BigInteger(next());
    }

    void close() {
        try {
            br.close();
        } catch (IOException e) {
        }
    }
}

class FastWriter {

    PrintWriter pw;

    PrintWriter getWriter() {
        return pw;
    }

    FastWriter(String type) {
        FastWriter(type);
    }

    FastWriter(String type, String outFileName) {
        FastWriter(type, outFileName);
    }

    PrintWriter FastWriter(String type) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        }
        return pw;
    }

    PrintWriter FastWriter(String type, String outFileName) {
        if (type.equals("console")) {
            pw = new PrintWriter(System.out);
        } else if (type.equals("test")) {
            try {
                pw = new PrintWriter(new File(outFileName));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        } else if (type.equals("file")) {
            try {
                pw = new PrintWriter(new File(outFileName));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        return pw;
    }

}