You are given two arrays of integers a and b. For each element of the second array bj you should find the number of elements in array a that are less than or equal to the value bj.

Input

The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the sizes of arrays a and b.

The second line contains n integers — the elements of array a ( - 109 ≤ ai ≤ 109).

The third line contains m integers — the elements of array b ( - 109 ≤ bj ≤ 109).

Output

Print m integers, separated by spaces: the j-th of which is equal to the number of such elements in array a that are less than or equal to the value bj.

Examples

Input

5 4
1 3 5 7 9
6 4 2 8


Output

3 2 1 4


Input

5 5
1 2 1 2 5
3 1 4 1 5


Output

4 2 4 2 5
import java.io.*;
import java.util.*;

public class C600B_Search_Queries {
    public static int[] a, b;
    public static void main(String[] args) throws IOException {
        InputStreamReader stream = new InputStreamReader(System.in);
        BufferedReader input = new BufferedReader(stream);

        StringTokenizer dataR = new StringTokenizer(input.readLine());
        int n = Integer.parseInt(dataR.nextToken());
        int m = Integer.parseInt(dataR.nextToken());

        StringTokenizer dataR1 = new StringTokenizer(input.readLine());
        a = new int[n];
        for (int i = 0; i < n; i++){
            a[i] = Integer.parseInt(dataR1.nextToken());
        }

        StringTokenizer dataR2 = new StringTokenizer(input.readLine());
        b = new int[m];
        for (int i = 0; i < m; i++){
            b[i] = Integer.parseInt(dataR2.nextToken());
        }

        sort(a, 0, a.length-1);
        //sort(b, 0, b.length-1);

        //int prev = 0;
        for (int i = 0; i < b.length; i++){
            int ind = binarySearch(b[i], 0, a.length-1);//find element in a that is just greater than/just less than
            System.out.print(ind + 1 + " ");
            //prev = ind;
        }
        
    }

    public static int binarySearch(int goal, int l, int r) {
        int mid = (l+r)/2;
        //if l & r are 1 apart, and goal is >= l, then return l
        if (r-l <= 1){//should never be <, just == but ok (try both ways!)
            if (goal >= a[l] && goal < a[r]){
                return l;
            } else if (goal >= a[r]) {
                return r;
            } else{
                return -1;
            }
        }

        //if goal > a[mid], do again with mid-r
        if (goal >= a[mid]) 
            return binarySearch(goal, mid, r);
        //if goal < a[mid], do again with l-mid
        if (goal < a[mid])
            return binarySearch(goal, l, mid);

        return -1;
    }

    public static void sort(int arr[], int l, int r) { 
        if (l < r) { 
            // Find the middle point 
            int m = (l+r)/2; 
  
            // Sort first and second halves 
            sort(arr, l, m); 
            sort(arr , m+1, r); 
  
            // Merge the sorted halves 
            merge(arr, l, m, r); 
        } 
    } 

    public static void merge(int arr[], int l, int m, int r) { 
        // Find sizes of two subarrays to be merged 
        int n1 = m - l + 1; 
        int n2 = r - m; 
  
        /* Create temp arrays */
        int L[] = new int [n1]; 
        int R[] = new int [n2]; 
  
        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i) 
            L[i] = arr[l + i]; 
        for (int j=0; j<n2; ++j) 
            R[j] = arr[m + 1+ j]; 
  
  
        /* Merge the temp arrays */
  
        // Initial indexes of first and second subarrays 
        int i = 0, j = 0; 
  
        // Initial index of merged subarry array 
        int k = l; 
        while (i < n1 && j < n2) { 
            if (L[i] <= R[j]) 
            { 
                arr[k] = L[i]; 
                i++; 
            } 
            else
            { 
                arr[k] = R[j]; 
                j++; 
            } 
            k++; 
        } 
  
        /* Copy remaining elements of L[] if any */
        while (i < n1) { 
            arr[k] = L[i]; 
            i++; 
            k++; 
        } 
  
        /* Copy remaining elements of R[] if any */
        while (j < n2) { 
            arr[k] = R[j]; 
            j++; 
            k++; 
        } 
    } 
}