Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.

But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.

Input

First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.

Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.

Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.

Output

Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.

Examples

Input

5
7 3 5 3 4
2 1 3 2 3


Output

4 7 3 5 3


Input

7
4 6 5 8 8 2 6
2 1 2 2 1 1 2


Output

2 6 4 5 8 8 6
#include <bits/stdc++.h>
using namespace std;
struct point2 {
  double x, y;
  long long val;
  point2() {}
  point2(double _x, double _y) { x = _x, y = _y; }
  point2 operator-(const point2 &ne) { return point2(x - ne.x, y - ne.y); }
  point2 operator+(const point2 &ne) { return point2(x + ne.x, y + ne.y); }
  point2 operator*(const double t) { return point2(x * t, y * t); }
  double operator*(const point2 &o) { return val * o.val; }
};
struct line2 {
  point2 a, b;
  line2() {}
  line2(point2 _a, point2 _b) {
    a = _a;
    b = _b;
  }
};
double dmult(point2 a, point2 b) { return a.x * b.x + a.y * b.y; }
double xmult(point2 a, point2 b) { return a.x * b.y - a.y * b.x; }
double xmult(point2 o, point2 a, point2 b) {
  return (a.x - o.x) * (b.y - o.y) - (b.x - o.x) * (a.y - o.y);
}
double xmult(double x1, double y1, double x2, double y2) {
  return x1 * y2 - x2 * y1;
}
double xmult(line2 x, line2 y) { return xmult(x.b - x.a, y.b - y.a); }
double length(point2 v) { return sqrt(v.x * v.x + v.y * v.y); }
double dist(point2 a, point2 b) { return length(a - b); }
double dist2(point2 a, point2 b) { return dmult(a - b, a - b); }
bool cmp(point2 &a, point2 &b) { return atan2(a.y, a.x) < atan2(b.y, b.x); }
double mysqrt(double x) { return max(0.0, sqrt(x)); }
int sgn(double x) {
  if (fabs(x) < 1e-6) return 0;
  if (x < 0)
    return -1;
  else
    return 1;
}
struct node {
  int id;
  int oldval;
  int newval;
};
bool cmp1(node &a, node &b) { return a.oldval < b.oldval; }
bool cmp2(node &a, node &b) { return a.id < b.id; }
bool cmp3(int &a, int &b) { return a > b; }
node a[200010];
int in[200010];
int main(void) {
  int n;
  cin >> n;
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &in[i]);
  }
  sort(in + 1, in + 1 + n, cmp3);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &a[i].oldval);
    a[i].id = i;
  }
  sort(a + 1, a + 1 + n, cmp1);
  for (int i = 1; i <= n; ++i) {
    a[i].newval = in[i];
  }
  sort(a + 1, a + 1 + n, cmp2);
  for (int i = 1; i <= n; ++i) {
    printf("%d ", a[i].newval);
  }
  cout << endl;
  return 0;
}
