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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.StringTokenizer;

public class App {
  
    public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      int n = sc.nextInt();
      int m = sc.nextInt();
      int[] nArray = new int[n];
      int[] mArray = new int[m];
      for (int i = 0 ; i < n ; i++){
        nArray[i] = sc.nextInt();
      }
      for (int i = 0 ; i < m ; i++){
        mArray[i] = sc.nextInt();
      }

      solve(nArray, mArray);
      sc.close();
    }

    private static void solve(int[] nArray, int[] mArray){
      mergeSort(nArray);
      Map<Integer, Integer> cache = new HashMap<>(mArray.length);
      for (int i = 0 ; i < mArray.length ; i ++){
        int pos = -1;
        if (cache.containsKey(mArray[i])){
          pos = cache.get(mArray[i]);
        }else{
          pos = findLessOrEqualPos(nArray, mArray[i]);
          cache.put(mArray[i], pos);
        }
        if (pos ==  -1){
          System.out.print(0 + " ");
        }else{
          System.out.print(pos + 1 +" ");
        }
      }
    }

    private static int findLessOrEqualPos(int[] array, int target){
      int l = 0, r = array.length - 1;
      int pos = -1;
      while(l <= r){
        pos = (l + r) / 2;
        if (target >= array[pos]){
          l = pos + 1;
        }else{
          r = pos - 1;
        }
      }

      if ( target < array[pos]){
        return pos - 1;
      }else{
        return pos;
      }
    }

    public static void mergeSort(int[] a) {
      int[] tmp = new int[a.length];
      mergeSort(a, tmp, 0, a.length - 1);
    }

    private static void mergeSort(int[] a, int[] tmp, int left, int right) {
        if (left < right) {
            int center = (left + right) / 2;
            mergeSort(a, tmp, left, center);
            mergeSort(a, tmp, center + 1, right);
            merge(a, tmp, left, center + 1, right);
        }
    }

    private static void merge(int[] a, int[] tmp, int left, int right, int rightEnd) {
        int leftEnd = right - 1;
        int k = left;
        int num = rightEnd - left + 1;

        while (left <= leftEnd && right <= rightEnd) {
            if (a[left] <= a[right]) {
                tmp[k++] = a[left++];
            } else {
                tmp[k++] = a[right++];
            }
        }

        while (left <= leftEnd) // Copy rest of first half
        {
            tmp[k++] = a[left++];
        }

        while (right <= rightEnd) // Copy rest of right half
        {
            tmp[k++] = a[right++];
        }

        // Copy tmp back
        for (int i = 0; i < num; i++, rightEnd--) {
            a[rightEnd] = tmp[rightEnd];
        }
    }

    static class InputReader {
      public BufferedReader reader;
      public StringTokenizer tokenizer;
   
      public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
      }
   
      public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
          try {
            tokenizer = new StringTokenizer(reader.readLine());
          } catch (IOException e) {
            throw new RuntimeException(e);
          }
        }
        return tokenizer.nextToken();
      }
   
      public int nextInt() {
        return Integer.parseInt(next());
      }
   
      public long nextLong() {
        return Long.parseLong(next());
      }
      
      public char nextChar() {
        return next().charAt(0);
      }
      
      public float nextFloat() {
        return Float.parseFloat(next());
      }
      
      public double nextDouble() {
        return Double.parseDouble(next());
      }
   
      public int[] nextIntArray(int size) {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
          try {
            tokenizer = new StringTokenizer(reader.readLine());
          } catch (IOException e) {
            throw new RuntimeException(e);
          }
        }
        int[] arr=new int[size];
        for(int i = 0; i < size; i++) 
          arr[i] = Integer.parseInt(tokenizer.nextToken());
        return arr;
      }
   
      public long[] nextLongArray(int size) {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
          try {
            tokenizer = new StringTokenizer(reader.readLine());
          } catch (IOException e) {
            throw new RuntimeException(e);
          }
        }
        long[] arr=new long[size];
        for(int i = 0; i < size; i++) 
          arr[i] = Long.parseLong(tokenizer.nextToken());
        return arr;
      }
      
      public float[] nextFloatArray(int size) {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
          try {
            tokenizer = new StringTokenizer(reader.readLine());
          } catch (IOException e) {
            throw new RuntimeException(e);
          }
        }
        float[] arr=new float[size];
        for(int i = 0; i < size; i++) 
          arr[i] = Float.parseFloat(tokenizer.nextToken());
        return arr;
      }
   
      public double[] nextDoubleArray(int size) {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
          try {
            tokenizer = new StringTokenizer(reader.readLine());
          } catch (IOException e) {
            throw new RuntimeException(e);
          }
        }
        double[] arr=new double[size];
        for(int i = 0; i < size; i++) 
          arr[i] = Double.parseDouble(tokenizer.nextToken());
        return arr;
      }
   
      public String[] nextStringArray(int size) throws IOException {
        String[] arr=new String[size];
        for(int i = 0; i < size; i++) 
          arr[i] = reader.readLine();
        return arr;
      }
   
      public char[] nextCharArray(int size) throws IOException {
        return reader.readLine().toCharArray();
      }
    }
   
    static class OutputWriter {
      public PrintWriter pw;
   
      public OutputWriter(OutputStream stream) {
        pw = new PrintWriter(stream);
      }
      
      public void println() {
        pw.println();
      }
   
      public void println(Object str) {
        pw.println(str);
      }
   
      public void print(Object str) {
        pw.print(str + " ");
      }
   
      public void close() {
        pw.close();
      }
   
      public void flush() {
        pw.flush();
      }
   
      public void printStringArray(String[] arr) {
        for(int i = 0; i < arr.length; i++)
          pw.println(arr[i]);
      }
   
      public void printIntArray(int[] arr) {
        for(int i = 0; i < arr.length; i++)
          pw.print(arr[i] + " ");
      }
   
      public void printLongArray(long[] arr) {
        for(int i = 0; i < arr.length; i++)
          pw.print(arr[i] + " ");
      }
   
      public void printCharArray(char[] arr) {
        for(int i = 0; i < arr.length; i++)
          pw.print(arr[i] + " ");
      }
   
      public void printFloatArray(float[] arr) {
        for(int i = 0; i < arr.length; i++)
          pw.print(arr[i] + " ");
      }
   
      public void printDoubleArray(double[] arr) {
        for(int i = 0; i < arr.length; i++)
          pw.print(arr[i] + " ");
      }
    }

}


