//g++ -std=gnu++14 a.cpp
// ./compile_run.sh

#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
#include <random>
#include <math.h>
#include <stdio.h>

using namespace std;

#define ll long long
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define revrep(i, n) for(ll i = (n)-1; i >=0; i--)
#define P pair<ll,ll>
#define pb push_back
ll MOD = 1e9 + 7;
int INF = 1 << 30;
ll INFL = 1LL << 60;
ll MODP = 998244353;
//const ll M = MOD;


template<typename __T__>
int len(vector<__T__> x){
  return int(x.size());
}

template<typename __T__>
void vecout(vector<__T__> x){
  rep(i, len(x)) cout << x[i] << " ";
  cout << endl;
}



ll lmax(ll x,ll y){
  if(x < y) return y;
  else return x;
}

ll lmin(ll x, ll y){
  if(x > y)return y;
  else return x;
}

ll gen(ll x,ll y){
  if(y == 0)return 1;
  if(y == 1)return x%MOD;
  if(y%2 == 1){
    return ((x%MOD)*gen(x,y-1)%MOD)%MOD;
  }else{
    ll res = gen(x,y/2)%MOD;
    return ((res%MOD)*(res%MOD))%MOD;
  }
}

ll Factorial(ll x,ll y){ //xのy乗
  if(y == 1) return x;
  if(y == 0) return 1;
  if(y%2 == 0){
    ll res = Factorial(x,y/2);
    return res*res;
  }else{
    return x*Factorial(x,y-1);
  }

}

ll gcd(ll x, ll y){
  if(x < y) swap(x,y);
  if(y == 0) return x;
  return gcd(y,x%y);
}

ll lcm(ll x,ll y){
  ll s = gcd(x,y);
  x /= s;
  y /= s;
  return x*y*s;
}


int main() {
  ll n;
  cin >> n;
  string s;
  cin >> s;
  vector<ll> a(n),b(n);
  rep(i,2*n){
    ll c = s.at(i) - 'A';
    if(i < n) a[i] = c;
    else b[i-n] = c;
  }

  ll q;
  cin >> q;
  rep(i,q){
    ll x,y,z;
    cin >> x >> y >> z;
    y--;
    z--;
    if(x == 1){
      ll na,nb;

      if(y < n) na = a[y];
      else na = b[y-n];

      if(z < n) nb = a[z];
      else nb = b[z-n];


      if(y < n) a[y] = nb;
      else b[y-n] = nb;

      if(z < n) a[z] = na;
      else b[z-n] = na;

    }else{
      swap(a,b);
    }
  }
  string ans = "";
  rep(i,2*n){
    char add;
    if(i < n) add = 'A'+a[i];
    else add = 'A'+b[i-n];
    ans += add;
  }
  cout << ans << endl;

}

//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
template<typename T> using PQ = priority_queue<T>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);++i)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;--i)
#define ENDL '\n'
typedef pair<int,int> Pi;
typedef pair<ll,ll> PL;
constexpr ll mod = 1000000007; // 998244353;
constexpr ll INF = 1000000099;
constexpr ll LINF = (ll)(1e18 +99);
const ld PI = acos((ld)-1);
constexpr ll dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
template<typename T,typename U> inline bool chmin(T& t, const U& u){if(t>u){t=u;return 1;}return 0;}
template<typename T,typename U> inline bool chmax(T& t, const U& u){if(t<u){t=u;return 1;}return 0;}
template<typename T> inline T gcd(T a,T b){return b?gcd(b,a%b):a;}
inline void Yes() { cout << "Yes" << ENDL; }
inline void No() { cout << "No" << ENDL; }
inline void YES() { cout << "YES" << ENDL; }
inline void NO() { cout << "NO" << ENDL; }

template<typename T,typename Y> inline T mpow(T a, Y n) {
  T res = 1;
  for(;n;n>>=1) {
    if (n & 1) res = res * a;
    a = a * a;
  }
  return res;
}

template <typename T>
vector<T> finddivisor(T x) {  //整数xの約数(xを含む)
  vector<T> divisor;
  for(T i = 1; (i * i) <= x; i++) {
    if(x % i == 0) {
      divisor.push_back(i);
      if(i * i != x) { divisor.push_back(x / i);}
    }
  }
  sort(divisor.begin(), divisor.end());
  return divisor;
}

template <typename T> V<T> prefix_sum(const V<T>& v) {
  int n = v.size();
  V<T> ret(n + 1);
  rep(i, 0, n) ret[i + 1] = ret[i] + v[i];
  return ret;
}

template<typename T>
istream& operator >> (istream& is, vector<T>& vec){
  for(auto&& x: vec) is >> x;
  return is;
}

template<typename T,typename Y>
ostream& operator<<(ostream& os,const pair<T,Y>& p){
  return os<<"{"<<p.fs<<","<<p.sc<<"}";
}

template<typename T> ostream& operator<<(ostream& os,const V<T>& v){
  os<<"{";
  for(auto e:v)os<<e<<",";
  return os<<"}";
}

template<typename ...Args>
void debug(Args&... args){
  for(auto const& x:{args...}){
    cerr<<x<<' ';
  }
  cerr<<ENDL;
}



signed main(){
  cin.tie(0);cerr.tie(0);ios::sync_with_stdio(false);
  cout<<fixed<<setprecision(20);
  ll n,m;cin>>n>>m;
  V<int> a(m),b(m);
  map<Pi,int> id;
  V<int> dir(m,0);//1 ->
  rep(i,0,m){
    cin>>a[i]>>b[i];
    --a[i];--b[i];
    id[{a[i],b[i]}]=id[{b[i],a[i]}]=i;
  }
  V<ll> c(n);cin>>c;

  VV<int> e(n);
  rep(i,0,m){
    int x=a[i],y=b[i];
    if(c[x]>c[y])dir[i]=1;
    else if(c[x]<c[y])dir[i]=2;
    else{
      e[x].eb(y);
      e[y].eb(x);
    }
  }

  V<bool> used(n,false);
  auto dfs=[&](auto self,int now)->void{
    for(auto&& to:e[now]){
      if(dir[id[{now,to}]])continue;

      if(now==a[id[{now,to}]])dir[id[{now,to}]]=1;
      else dir[id[{now,to}]]=2;

      if(used[to])continue;
      used[to]=true;
      self(self,to);
    }
  };
  
  rep(i,0,n)if(!used[i]){
    used[i]=true;
    dfs(dfs,i);
  }

  rep(i,0,m){
    assert(dir[i]);
    if(dir[i]==1)cout<<"->"<<ENDL;
    else cout<<"<-"<<ENDL;
  }
}
//(・_・)(・_・)(・_・)(・_・)
//CHECK overflow,what to output?
//any other simpler approach?