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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Random;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.io.OutputStreamWriter;
import java.util.NoSuchElementException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.List;
import java.io.Writer;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Feng Jiajie
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    TaskB solver = new TaskB();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskB {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      int n = in.readInt();
      int m = in.readInt();
      int[] a = IOUtils.readIntArray(in, n);
      Random random = new Random(System.currentTimeMillis());

      class P implements Comparable {
        P(int a, int b) {
          first = a;
          second = b;
        }

        public int first;
        public int second;

        public int compareTo(Object o) {
          return first - ((P) o).first;
        }
      }
      List<P> pairs = new ArrayList<>(m);
      for (int i = 0; i < m; i++) {
        pairs.add(new P(in.readInt(), i));
      }
      Collections.sort(pairs);
      ArrayUtils.sort(a);
      int[] ans = new int[m];
      int cnt = 0;
      for (P pair : pairs) {
        while (cnt < n) {
          if (pair.first < a[cnt]) {
            ans[pair.second] = cnt;
            break;
          } else {
            cnt++;
          }
        }
        if (cnt == n) {
          ans[pair.second] = cnt;
        }
      }
      out.printLine(ans);
    }

  }


  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (numChars == -1)
        throw new InputMismatchException();
      if (curChar >= numChars) {
        curChar = 0;
        try {
          numChars = stream.read(buf);
        } catch (IOException e) {
          throw new InputMismatchException();
        }
        if (numChars <= 0)
          return -1;
      }
      return buf[curChar++];
    }

    public int readInt() {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      int res = 0;
      do {
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));
      return res * sgn;
    }

    public boolean isSpaceChar(int c) {
      if (filter != null)
        return filter.isSpaceChar(c);
      return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
      public boolean isSpaceChar(int ch);

    }

  }


  static class Sorter {
    private static final int INSERTION_THRESHOLD = 16;

    private Sorter() {
    }

    public static void sort(IntList list, IntComparator comparator) {
      quickSort(list, 0, list.size() - 1,
          (Integer.bitCount(Integer.highestOneBit(list.size()) - 1) * 5) >> 1, comparator);
    }

    private static void quickSort(IntList list, int from, int to, int remaining,
        IntComparator comparator) {
      if (to - from < INSERTION_THRESHOLD) {
        insertionSort(list, from, to, comparator);
        return;
      }
      if (remaining == 0) {
        heapSort(list, from, to, comparator);
        return;
      }
      remaining--;
      int pivotIndex = (from + to) >> 1;
      int pivot = list.get(pivotIndex);
      list.swap(pivotIndex, to);
      int storeIndex = from;
      int equalIndex = to;
      for (int i = from; i < equalIndex; i++) {
        int value = comparator.compare(list.get(i), pivot);
        if (value < 0) {
          list.swap(storeIndex++, i);
        } else if (value == 0) {
          list.swap(--equalIndex, i--);
        }
      }
      quickSort(list, from, storeIndex - 1, remaining, comparator);
      for (int i = equalIndex; i <= to; i++) {
        list.swap(storeIndex++, i);
      }
      quickSort(list, storeIndex, to, remaining, comparator);
    }

    private static void heapSort(IntList list, int from, int to, IntComparator comparator) {
      for (int i = (to + from - 1) >> 1; i >= from; i--) {
        siftDown(list, i, to, comparator, from);
      }
      for (int i = to; i > from; i--) {
        list.swap(from, i);
        siftDown(list, from, i - 1, comparator, from);
      }
    }

    private static void siftDown(IntList list, int start, int end, IntComparator comparator,
        int delta) {
      int value = list.get(start);
      while (true) {
        int child = ((start - delta) << 1) + 1 + delta;
        if (child > end) {
          return;
        }
        int childValue = list.get(child);
        if (child + 1 <= end) {
          int otherValue = list.get(child + 1);
          if (comparator.compare(otherValue, childValue) > 0) {
            child++;
            childValue = otherValue;
          }
        }
        if (comparator.compare(value, childValue) >= 0) {
          return;
        }
        list.swap(start, child);
        start = child;
      }
    }

    private static void insertionSort(IntList list, int from, int to, IntComparator comparator) {
      for (int i = from + 1; i <= to; i++) {
        int value = list.get(i);
        for (int j = i - 1; j >= from; j--) {
          if (comparator.compare(list.get(j), value) <= 0) {
            break;
          }
          list.swap(j, j + 1);
        }
      }
    }

  }


  static abstract class IntAbstractStream implements IntStream {

    public String toString() {
      StringBuilder builder = new StringBuilder();
      boolean first = true;
      for (IntIterator it = intIterator(); it.isValid(); it.advance()) {
        if (first) {
          first = false;
        } else {
          builder.append(' ');
        }
        builder.append(it.value());
      }
      return builder.toString();
    }


    public boolean equals(Object o) {
      if (!(o instanceof IntStream)) {
        return false;
      }
      IntStream c = (IntStream) o;
      IntIterator it = intIterator();
      IntIterator jt = c.intIterator();
      while (it.isValid() && jt.isValid()) {
        if (it.value() != jt.value()) {
          return false;
        }
        it.advance();
        jt.advance();
      }
      return !it.isValid() && !jt.isValid();
    }


    public int hashCode() {
      int result = 0;
      for (IntIterator it = intIterator(); it.isValid(); it.advance()) {
        result *= 31;
        result += it.value();
      }
      return result;
    }

  }


  static class IOUtils {
    public static int[] readIntArray(InputReader in, int size) {
      int[] array = new int[size];
      for (int i = 0; i < size; i++)
        array[i] = in.readInt();
      return array;
    }

  }


  static class ArrayUtils {
    public static int[] sort(int[] array) {
      return sort(array, IntComparator.DEFAULT);
    }

    public static int[] sort(int[] array, IntComparator comparator) {
      return sort(array, 0, array.length, comparator);
    }

    public static int[] sort(int[] array, int from, int to, IntComparator comparator) {
      if (from == 0 && to == array.length)
        new IntArray(array).sort(comparator);
      else
        new IntArray(array).subList(from, to).sort(comparator);
      return array;
    }

  }


  static class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(int[] array) {
      for (int i = 0; i < array.length; i++) {
        if (i != 0)
          writer.print(' ');
        writer.print(array[i]);
      }
    }

    public void printLine(int[] array) {
      print(array);
      writer.println();
    }

    public void close() {
      writer.close();
    }

  }


  static interface IntReversableCollection extends IntCollection {
  }


  static interface IntList extends IntReversableCollection {
    public abstract int get(int index);

    public abstract void set(int index, int value);

    public abstract void addAt(int index, int value);

    public abstract void removeAt(int index);

    default public void swap(int first, int second) {
      if (first == second) {
        return;
      }
      int temp = get(first);
      set(first, get(second));
      set(second, temp);
    }

    default public IntIterator intIterator() {
      return new IntIterator() {
        private int at;
        private boolean removed;

        public int value() {
          if (removed) {
            throw new IllegalStateException();
          }
          return get(at);
        }

        public boolean advance() {
          at++;
          removed = false;
          return isValid();
        }

        public boolean isValid() {
          return !removed && at < size();
        }

        public void remove() {
          removeAt(at);
          at--;
          removed = true;
        }
      };
    }


    default public void add(int value) {
      addAt(size(), value);
    }

    default public IntList sort(IntComparator comparator) {
      Sorter.sort(this, comparator);
      return this;
    }

    default public IntList subList(final int from, final int to) {
      return new IntList() {
        private final int shift;
        private final int size;

        {
          if (from < 0 || from > to || to > IntList.this.size()) {
            throw new IndexOutOfBoundsException(
                "from = " + from + ", to = " + to + ", size = " + size());
          }
          shift = from;
          size = to - from;
        }

        public int size() {
          return size;
        }

        public int get(int at) {
          if (at < 0 || at >= size) {
            throw new IndexOutOfBoundsException("at = " + at + ", size = " + size());
          }
          return IntList.this.get(at + shift);
        }

        public void addAt(int index, int value) {
          throw new UnsupportedOperationException();
        }

        public void removeAt(int index) {
          throw new UnsupportedOperationException();
        }

        public void set(int at, int value) {
          if (at < 0 || at >= size) {
            throw new IndexOutOfBoundsException("at = " + at + ", size = " + size());
          }
          IntList.this.set(at + shift, value);
        }

        public IntList compute() {
          return new IntArrayList(this);
        }
      };
    }

  }


  static interface IntComparator {
    public static final IntComparator DEFAULT = (first, second) -> {
      if (first < second) {
        return -1;
      }
      if (first > second) {
        return 1;
      }
      return 0;
    };

    public int compare(int first, int second);

  }


  static interface IntCollection extends IntStream {
    public int size();

    default public void add(int value) {
      throw new UnsupportedOperationException();
    }

    default public IntCollection addAll(IntStream values) {
      for (IntIterator it = values.intIterator(); it.isValid(); it.advance()) {
        add(it.value());
      }
      return this;
    }

  }


  static class IntArray extends IntAbstractStream implements IntList {
    private int[] data;

    public IntArray(int[] arr) {
      data = arr;
    }

    public int size() {
      return data.length;
    }

    public int get(int at) {
      return data[at];
    }

    public void addAt(int index, int value) {
      throw new UnsupportedOperationException();
    }

    public void removeAt(int index) {
      throw new UnsupportedOperationException();
    }

    public void set(int index, int value) {
      data[index] = value;
    }

  }


  static class IntArrayList extends IntAbstractStream implements IntList {
    private int size;
    private int[] data;

    public IntArrayList() {
      this(3);
    }

    public IntArrayList(int capacity) {
      data = new int[capacity];
    }

    public IntArrayList(IntCollection c) {
      this(c.size());
      addAll(c);
    }

    public IntArrayList(IntStream c) {
      this();
      if (c instanceof IntCollection) {
        ensureCapacity(((IntCollection) c).size());
      }
      addAll(c);
    }

    public IntArrayList(IntArrayList c) {
      size = c.size();
      data = c.data.clone();
    }

    public IntArrayList(int[] arr) {
      size = arr.length;
      data = arr.clone();
    }

    public int size() {
      return size;
    }

    public int get(int at) {
      if (at >= size) {
        throw new IndexOutOfBoundsException("at = " + at + ", size = " + size);
      }
      return data[at];
    }

    private void ensureCapacity(int capacity) {
      if (data.length >= capacity) {
        return;
      }
      capacity = Math.max(2 * data.length, capacity);
      data = Arrays.copyOf(data, capacity);
    }

    public void addAt(int index, int value) {
      ensureCapacity(size + 1);
      if (index > size || index < 0) {
        throw new IndexOutOfBoundsException("at = " + index + ", size = " + size);
      }
      if (index != size) {
        System.arraycopy(data, index, data, index + 1, size - index);
      }
      data[index] = value;
      size++;
    }

    public void removeAt(int index) {
      if (index >= size || index < 0) {
        throw new IndexOutOfBoundsException("at = " + index + ", size = " + size);
      }
      if (index != size - 1) {
        System.arraycopy(data, index + 1, data, index, size - index - 1);
      }
      size--;
    }

    public void set(int index, int value) {
      if (index >= size) {
        throw new IndexOutOfBoundsException("at = " + index + ", size = " + size);
      }
      data[index] = value;
    }

  }


  static interface IntIterator {
    public int value() throws NoSuchElementException;

    public boolean advance();

    public boolean isValid();

  }


  static interface IntStream extends Iterable<Integer>, Comparable<IntStream> {
    public IntIterator intIterator();

    default public Iterator<Integer> iterator() {
      return new Iterator<Integer>() {
        private IntIterator it = intIterator();

        public boolean hasNext() {
          return it.isValid();
        }

        public Integer next() {
          int result = it.value();
          it.advance();
          return result;
        }
      };
    }

    default public int compareTo(IntStream c) {
      IntIterator it = intIterator();
      IntIterator jt = c.intIterator();
      while (it.isValid() && jt.isValid()) {
        int i = it.value();
        int j = jt.value();
        if (i < j) {
          return -1;
        } else if (i > j) {
          return 1;
        }
        it.advance();
        jt.advance();
      }
      if (it.isValid()) {
        return 1;
      }
      if (jt.isValid()) {
        return -1;
      }
      return 0;
    }

  }
}
