#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <charconv>
#include <climits>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <exception>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <iterator>
#include <locale>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>

using namespace std;

const long long MOD = 998244353;

using ld = long double;
using ll = long long;
using ull = unsigned long long;

template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;

template <class T, class U> inline bool chmin(T &a, const U &b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T, class U> inline bool chmax(T &a, const U &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}

template <class T> auto min(const T &a) { *min_elemenet(all(a)); }
template <class T> auto max(const T &a) { *max_elemenet(all(a)); }

// const ll MOD = 1e9 + 7;
const ll INF = 1 << 30;
const ll INFLL = 1LL << 60;
const ld EPS = 1e-9;

const ll dx[] = {0, 1, 0, -1, 1, -1, 1, -1};
const ll dy[] = {1, 0, -1, 0, 1, -1, -1, 1};

struct mint {
  ull a;

  constexpr mint(const ull x = 0) noexcept : a(x % MOD) {}
  constexpr mint operator+(const mint rhs) const noexcept {
    return mint(*this) += rhs;
  }
  constexpr mint operator-(const mint rhs) const noexcept {
    return mint(*this) -= rhs;
  }
  constexpr mint operator*(const mint rhs) const noexcept {
    return mint(*this) *= rhs;
  }
  constexpr mint operator/(const mint rhs) const noexcept {
    return mint(*this) /= rhs;
  }
  constexpr mint &operator+=(const mint rhs) noexcept {
    a += rhs.a;
    if (a >= MOD)
      a -= MOD;
    return *this;
  }
  constexpr mint &operator-=(const mint rhs) noexcept {
    if (a < rhs.a)
      a += MOD;
    a -= rhs.a;
    return *this;
  }
  constexpr mint &operator*=(const mint rhs) noexcept {
    a = a * rhs.a % MOD;
    return *this;
  }
  constexpr mint &operator/=(mint rhs) noexcept {
    ull exp = MOD - 2;
    while (exp) {
      if (exp % 2)
        *this *= rhs;
      rhs *= rhs;
      exp /= 2;
    }
    return *this;
  }
  constexpr mint pow(const mint &a, ull n) noexcept {
    if (n <= 0)
      return 1;
    auto t = pow(a, n / 2);
    t = t * t;
    if (n & 1)
      t = t * a;
    return t;
  }
};

long long modpow(long long a, long long n, long long m = MOD) {
  if (n <= 0)
    return 1LL;
  if (n % 2LL)
    return a * modpow(a, n - 1) % MOD;
  long long t = modpow(a, n / 2);
  return t % MOD * t % MOD;
}

struct Combination {
  const int MAX = 2e5 + 5;
  vector<long long> fact, invfact;

  Combination() {
    fact.resize(MAX);
    invfact.resize(MAX);

    fact[0] = 1;

    for (int i = 1; i < MAX; ++i) {
      fact[i] = fact[i - 1] * i % MOD;
    }

    invfact[MAX - 1] = modpow(fact[MAX - 1], MOD - 2);

    for (int i = MAX - 1; i > 0; --i) {
      invfact[i - 1] = invfact[i] * i % MOD;
    }
  }

  long long nCr(int n, int r) {
    long long a = fact[n];
    long long b = invfact[r] * invfact[n - r] % MOD;

    return a * b % MOD;
  }
};

struct RollingHash {
  int n;
  vector<ull> HS;
  vector<ull> mp;

  const ull b = 3491;

  RollingHash(string &S) {
    n = S.size();
    mp.assign(n, 0);
    HS.assign(n + 1, 0);

    for (int i = 0; i < n; ++i) {
      mp[i] = modpow(b, i);
    }

    for (int i = 0; i < n; ++i) {
      HS[i + 1] = HS[i] + mp[n - i - 1] * (S[i] - '0') % MOD;
      HS[i + 1] %= MOD;
    }
  }

  int getHash(int l, int r) {
    if (r > n)
      return -1;
    return (HS[r] - HS[l] + MOD) % MOD;
  }
  int getHash(string &T) {
    if (T.size() > n)
      return -1;
    int m = T.size();
    int ret = 0;

    for (int i = 0; i < m; ++i) {
      ret += mp[m - i - 1] * (T[i] - '0') % MOD;
      ret %= MOD;
    }

    return ret;
  }

  bool isSubstr(string &T) {
    int m = T.size();
    if (m > n)
      return false;

    int ht = getHash(T);
    vector<int> u;

    for (int i = n - m; i >= 0; --i) {
      int hs = getHash(i, i + m);
      if (hs == ht)
        u.push_back(i);

      ht *= b;
      ht %= MOD;
    }

    for (int i = 0; i < u.size(); ++i) {
      cout << u[u.size() - i - 1] << endl;
    }

    return false;
  }
};

template <class T> vector<int> ZAlgorithm(vector<T> arr) {
  int n = arr.size();

  vector<int> z(n, 0);
  z[0] = n;
  int l = 0, r = 0;

  for (int i = 1; i < n; ++i) {
    int j = i;
    r = max(r, i);

    if (z[i - l] + i < r) {
      z[i] = z[i - l];
      continue;
    }

    while (r < n && arr[r] == arr[r - i])
      ++r;

    z[i] = r - i;
    l = i;
  }

  return z;
}

template <typename T> struct RMQ {
  const T INF = 0;
  int n;         // 葉の数
  vector<T> dat; // 完全二分木の配列

  RMQ(int n_) : n(), dat(n_ * 4, INF) { // 葉の数は 2^x の形
    int x = 1;
    while (n_ > x) {
      x *= 2;
    }
    n = x;
  }

  void update(int i, T x) {
    i += n - 1;
    dat[i] = x;
    while (i > 0) {
      i = (i - 1) / 2; // parent
      dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
    }
  }

  // the minimum element of [a,b)
  T query(int a, int b) { return query_sub(a, b, 0, 0, n); }
  T query_sub(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l) {
      return INF;
    } else if (a <= l && r <= b) {
      return dat[k];
    } else {
      T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
      T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
      return max(vl, vr);
    }
  }
};

bool isPrime(long long x) {
  assert(x >= 0);

  for (long long i = 2; i <= sqrt(x); ++i) {
    if (x % i == 0)
      return false;
  }

  return true;
}

vector<int> dijkstra(vector<vector<int>> &G, int s) {
  int n = G.size();

  vector<int> dp(n, 1e9);
  dp[s] = 0;

  pqg<pair<int, int>> que;
  que.push({0, s});

  while (!que.empty()) {
    auto [d, v] = que.top();
    que.pop();

    if (dp[v] != d)
      continue;

    for (int &to : G[v]) {
      if (chmin(dp[to], d + 1)) {
        que.push({dp[to], to});
      }
    }
  }

  return dp;
}

template <class T> using pq = priority_queue<T>;

bool checkCycle(int v, int p, vector<vector<int>> &G, vector<int> &seen,
                vector<int> &finished) {
  bool ret = false;
  seen[v] = true;
  for (int to : G[v]) {
    if (to == p)
      continue;
    if (finished[to])
      continue;
    if (seen[to] && !finished[to]) {
      return true;
    }
    ret |= checkCycle(to, v, G, seen, finished);
  }

  finished[v] = true;
  return ret;
}

template <typename T> struct BIT {
  int n;            // 要素数
  vector<T> bit[2]; // データの格納先
  BIT(int n_) { init(n_); }
  void init(int n_) {
    n = n_ + 1;
    for (int p = 0; p < 2; p++)
      bit[p].assign(n, 0);
  }
  void add_sub(int p, int i, T x) {
    for (int idx = i; idx < n; idx += (idx & -idx)) {
      bit[p][idx] += x;
    }
  }
  void add(int l, int r, T x) { // [l,r) に加算
    add_sub(0, l, -x * (l - 1));
    add_sub(0, r, x * (r - 1));
    add_sub(1, l, x);
    add_sub(1, r, -x);
  }
  T sum_sub(int p, int i) {
    T s(0);
    for (int idx = i; idx > 0; idx -= (idx & -idx)) {
      s += bit[p][idx];
    }
    return s;
  }
  T sum(int i) { return sum_sub(0, i) + sum_sub(1, i) * i; }
  T query(int l, int r) { return sum(r - 1) - sum(l - 1); }
};

template <class T> struct Sum2D {
  int n, m;
  vector<vector<int>> sum;

  Sum2D(vector<vector<T>> s) {
    n = s.size();
    m = s[0].size();
    sum.assign(n + 1, vector<int>(m + 1, 0));

    for (int i = 1; i <= n; ++i) {
      for (int j = 1; j <= m; ++j) {
        sum[i][j] =
            sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + s[i - 1][j - 1];
      }
    }
  }

  int getSum(int sx, int sy, int gx, int gy) {
    return sum[gx][gy] - sum[gx][sy] - sum[sx][gy] + sum[sx][sy];
  }
};

long long bitCount(long long n, int b) {
  long long m = n / (1LL << (b + 1));
  long long mod = n % (1LL << (b + 1));

  return m * (1LL << b) + max(0LL, mod - (1LL << b) + 1);
}

struct UnionFind {
  int n;
  vector<int> parent, siz;

  UnionFind(int n) : n(n) {
    parent.resize(n);
    siz.resize(n);

    for (int i = 0; i < n; ++i) {
      parent[i] = i;
      siz[i] = 1;
    }
  }

  int root(int x) {
    if (parent[x] == x)
      return x;
    return parent[x] = root(parent[x]);
  }

  bool unite(int x, int y) {
    x = root(x);
    y = root(y);

    if (x == y)
      return false;

    if (siz[x] < siz[y])
      swap(x, y);
    parent[y] = x;
    siz[x] += siz[y];

    return true;
  }

  int same(int x, int y) { return root(x) == root(y); }

  int size(int x) { return siz[root(x)]; }
};

#define all(v) begin(v), end(v)

using ld = long double;
using ll = long long;
using ull = unsigned long long;

template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;

int main(void) {
  int n;
  cin >> n;

  string s;
  cin >> s;

  string t = s;
  for (int i = 0; i < n; ++i) {
    int p;
    cin >> p;

    t[i] = s[p - 1];
  }

  cout << t << endl;
  return 0;
}