You've got an array a, consisting of n integers. The array elements are indexed from 1 to n. Let's determine a two step operation like that:

  1. First we build by the array a an array s of partial sums, consisting of n elements. Element number i (1 ≤ i ≤ n) of array s equals <image>. The operation x mod y means that we take the remainder of the division of number x by number y. 
  2. Then we write the contents of the array s to the array a. Element number i (1 ≤ i ≤ n) of the array s becomes the i-th element of the array a (ai = si). 



You task is to find array a after exactly k described operations are applied.

Input

The first line contains two space-separated integers n and k (1 ≤ n ≤ 2000, 0 ≤ k ≤ 109). The next line contains n space-separated integers a1, a2, ..., an — elements of the array a (0 ≤ ai ≤ 109).

Output

Print n integers — elements of the array a after the operations are applied to it. Print the elements in the order of increasing of their indexes in the array a. Separate the printed numbers by spaces.

Examples

Input

3 1
1 2 3


Output

1 3 6


Input

5 0
3 14 15 92 6


Output

3 14 15 92 6
import java.io.*;
import java.util.*;

public class B {

    BufferedReader br;
    PrintWriter out;
    StringTokenizer st;
    boolean eof;

    void solve() throws IOException {
        char[] s = nextToken().toCharArray();
        char[] t = nextToken().toCharArray();
        
        // find the leftmost occurence of t
        int[] posL = new int[t.length];     
        int j = 0;
        
        for (int i = 0; i < s.length && j < t.length; i++) {
            if (s[i] == t[j])
                posL[j++] = i; 
        }
        
        
        if (j != t.length) {
            out.println("No");
            return;
        }
        
        // find the rightmost occurence of t
        int[] posR = new int[t.length];
        j = t.length - 1;
        for (int i = s.length - 1; i >= 0 && j >= 0; i--) {
            if (s[i] == t[j])
                posR[j--] = i;
        }
        
        if (j != -1) {
            out.println("No");
            return;
        }
        
//      System.err.println(Arrays.toString(posL));
//      System.err.println(Arrays.toString(posR));
        
        ArrayList<Integer>[] posS = new ArrayList[26];
        ArrayList<Integer>[] posT = new ArrayList[26];
        
        for (int i = 0; i < 26; i++) {
            posS[i] = new ArrayList<Integer>();
            posT[i] = new ArrayList<Integer>();
        }
        
        for (int i = 0; i < s.length; i++) {
            int ind = s[i] - 'a';
            posS[ind].add(i);
        }
        
        for (int i = 0; i < t.length; i++) {
            int ind = t[i] - 'a';
            posT[ind].add(i);
        }
        
        for (int let = 0; let < 26; let++) {
            
            int[] sum = new int[s.length];
            
            for (int tj : posT[let]) {
                int lowVal = tj == 0 ? 0 : posL[tj - 1] + 1;
                int highVal = tj == t.length - 1 ? s.length - 1 : posR[tj + 1] - 1;
                
                sum[lowVal]++;
                if (highVal + 1 < s.length)
                    sum[highVal + 1]--;
                
                if (lowVal > highVal)
                    throw new AssertionError();
            }
            
            for (int i = 1; i < s.length; i++)
                sum[i] += sum[i - 1];
            
            for (int pos : posS[let])
                if (sum[pos] == 0) {
                    out.println("No");
                    return;
                }

            
        }
        
        out.println("Yes");
    }

    void inp() throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new B().inp();
    }

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

    String nextString() {
        try {
            return br.readLine();
        } catch (IOException e) {
            eof = true;
            return null;
        }
    }

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

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

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