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.util.*;
import java.io.*;

public class MyClass {
    public static void main(String args[]) throws IOException{
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      String s[] = br.readLine().trim().split(" ");
      int n  = Integer.parseInt(s[0]);
      int m  = Integer.parseInt(s[1]);
      s = br.readLine().trim().split(" ");
      int a[] = new int[n];
      int b[] = new int[m];
      for(int i=0; i<n; i++)
      {
          a[i] = Integer.parseInt(s[i]);
      }
      s = br.readLine().trim().split(" ");
      for(int i=0; i<m; i++)
      {
          b[i] = Integer.parseInt(s[i]);
      }
      
      sort(a, 0, a.length-1);
      
      StringBuffer buff = new StringBuffer();
      
      for(int i=0 ; i<m ; i++)
      {
          int ind = ceilIndex(a, b[i]) + 1;
          if(b[i] < a[0]) buff.append(0 + " ");
          else if(b[i] > a[n-1]) buff.append(n + " "); 
          else buff.append(ind + " ");
      }
      System.out.println(buff.toString());
      
      
    }
    
    static int ceilIndex(int arr[], int x)
    {
        if(arr.length == 1 || (arr[0] == x && arr[1] != x)) return 0;
        
        int i=1;
        while(i < arr.length && arr[i] <= x) {i = i*2;}
        
        int l=i/2, h=i<arr.length-1?i:arr.length-1;
        int ans=0;
        while(l<=h)
        {
            int mid = l + (h-l)/2;
            
            if(arr[mid] == x && (mid ==h || arr[mid] != arr[mid+1])) return mid;
            if(arr[mid] <= x) {ans = mid; l=mid+1;}
            else h=mid-1;
        }
        return ans;
    }
    
    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++; 
        } 
    } 
  
    // Main function that sorts arr[l..r] using 
    // merge() 
    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); 
        } 
    }
}