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

// Educational Codeforces Round 2
// Queries about less or equal elements
public class Problem_600_B {
    

    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        Problem_600_B solver = new Problem_600_B();
        solver.solve(1, new InputStreamReader(inputStream), out);
        out.close();
    }

    static class Pair implements Comparable<Pair> {
      int first;

      int second;

      Pair(int f, int s)
      {
        first = f;
        second = s;
      }

      public int compareTo(Pair o)
      {
        int r = first - o.first;

        if(r == 0)
          r = second - o.second;

        return r;
      }
    }
    
    static void siftdown(int[] h, int i, int n)
    {
      if(i >= n)
        return;
      while(true) {
        int c = i * 2 + 1;
        if(c >= n)
          break;
        if(c + 1 < n) {
          if(h[c + 1] > h[c])
            c++;
        }
        if(h[i] >= h[c])
          break;
        int t = h[c];
        h[c] = h[i];
        h[i] = t;
        i = c;
      }
    }

    static void heapsort(int[] h)
    {
      for(int j = h.length / 2; j >= 0; j--)
        siftdown(h, j, h.length);
      for(int j = h.length - 1; j > 0; j--) {
        int t = h[0];
        h[0] = h[j];
        h[j] = t;
        siftdown(h, 0, j);
      }
    }

    
    public void solve(int test, Reader input, PrintWriter out)
    {
        MyScanner in = new MyScanner(input);
        
        int n = in.nextInt();
        int m = in.nextInt();
        
        int[] a = in.nextIntArray(n);
        int[] b = in.nextIntArray(m);
        
        heapsort(a);
        
        int[] res = new int[m];
        
        Pair[] sorted = new Pair[m];
        for(int i = 0; i < m; i++)
          sorted[i] = new Pair(b[i], i);
        Arrays.sort(sorted);
        
        int ia = 0;
        int ib = 0;
        while(ib < m) {
          while(ia < n && a[ia] <= sorted[ib].first) ia++;
          res[sorted[ib].second] = ia;
          while(ib < m - 1 && sorted[ib].first == sorted[ib+1].first) {
            ib++;
            res[sorted[ib].second ]= ia;
          }
          ib++;
        }
        for(int i = 0; i < m; i++) {
          if(i > 0) out.print(" ");
          out.print(res[i]);
        }
        out.println();
    }

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner(Reader reader) {
            br = new BufferedReader(reader);
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        
        int[] nextIntArray(int n)
        {
            int[] r = new int[n];
            for(int i = 0; i < n; i++)
                r[i] = nextInt();
            return r;
        }

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

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

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
    //--------------------------------------------------------

}
