// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC push_options
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #include<bits/stdc++.h>
// #include <xmmintrin.h>
// #include <immintrin.h>
// using namespace::std;
// __attribute__((constructor))void init(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/priority_queue.hpp>
// #include<ext/pb_ds/tag_and_trait.hpp>
// // #include <boost/multiprecision/cpp_dec_float.hpp>
// // #include <boost/multiprecision/cpp_int.hpp>
// // namespace mp = boost::multiprecision;
// // typedef mp::number<mp::cpp_dec_float<0>> cdouble;
// // typedef mp::cpp_int cint;
// template<typename T>using pbds=__gnu_pbds::tree<T,__gnu_pbds::null_type,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// template<typename T>using pbds_map=__gnu_pbds::tree<T,T,less<T>,__gnu_pbds::rb_tree_tag,__gnu_pbds::tree_order_statistics_node_update>;
// template<typename T,typename E>using hash_map=__gnu_pbds::gp_hash_table<T,E>;
// template<typename T>using pqueue =__gnu_pbds::priority_queue<T, greater<T>,__gnu_pbds::rc_binomial_heap_tag>;
// typedef long long lint;
// #define INF (1LL<<60)
// #define IINF (1<<30)
// //#define EPS (1e-10)
// #define endl '\n'
// //#define MOD 1000000007LL
// #define MOD 998244353LL
// typedef vector<lint> vec;
// typedef vector<vector<lint>> mat;
// typedef vector<vector<vector<lint>>> mat3;
// typedef vector<string> svec;
// typedef vector<vector<string>> smat;
// template<typename T>inline void numout(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i<INF/2?i:"INF";f=1;}cout<<endl;}
// template<typename T>inline void numout2(T t){for(auto i:t)numout(i);}
// template<typename T>inline void output(T t){bool f=0;for(auto i:t){cout<<(f?" ":"")<<i;f=1;}cout<<endl;}
// template<typename T>inline void output2(T t){for(auto i:t)output(i);}
// template<typename T>inline void _output(T t){bool f=0;for(lint i=0;i<t.size();i++){cout<<f?"":" "<<t[i];f=1;}cout<<endl;}
// template<typename T>inline void _output2(T t){for(lint i=0;i<t.size();i++)output(t[i]);}
// #define rep(i,n) for(lint i=0;i<lint(n);++i)
// #define repi(i,a,b) for(lint i=lint(a);i<(lint)(b);++i)
// #define rrep(i,n) for(lint i=lint(n)-1;i>=0;--i)
// #define rrepi(i,a,b) for(lint i=lint(b)-1;i>=lint(a);--i)
// #define irep(i) for(lint i=0;;++i)
// #define all(n) begin(n),end(n)
// #define dist(a,b,c,d) sqrt(pow(a-c,2)+pow(b-d,2))
// inline lint gcd(lint A,lint B){return B?gcd(B,A%B):A;}
// inline lint lcm(lint A,lint B){return A/gcd(A,B)*B;}
// // inline cint cgcd(cint A,cint B){return B?cgcd(B,A%B):A;}
// // inline cint clcm(cint A,cint B){return A/cgcd(A,B)*B;}
// inline bool chmin(auto& s,const auto& t){bool res=s>t;s=min(s,t);return res;}
// inline bool chmax(auto& s,const auto& t){bool res=s<t;s=max(s,t);return res;}
// const vector<lint> dx={1,0,-1,0,1,1,-1,-1};
// const vector<lint> dy={0,1,0,-1,1,-1,1,-1};
// #define SUM(v) accumulate(all(v),0LL)
// auto call=[](auto f,auto... args){return f(f,args...);};

// template<typename T>
// struct complex_t{
//     T x,y;
//     using C=complex_t;
//     constexpr complex_t(T x=T(),T y=T()):x(x),y(y){}
//     constexpr inline C operator +(C rhs)const noexcept{return C(*this)+=rhs;}
//     constexpr inline C operator -(C rhs)const noexcept{return C(*this)-=rhs;}
//     constexpr inline C operator *(C rhs)const noexcept{return C(*this)*=rhs;}
//     constexpr inline C operator /(C rhs)const noexcept{return C(*this)/=rhs;}
//     constexpr inline C& operator +=(C rhs){x+=rhs.x;y+=rhs.y;return *this;};
//     constexpr inline C& operator -=(C rhs){x-=rhs.x;y-=rhs.y;return *this;};
//     constexpr inline C& operator *=(C rhs){return *this={x*rhs.x-y*rhs.y,x*rhs.y+y*rhs.x};};
//     constexpr inline C& operator /=(C rhs){return *this*=rhs.inv();};
//     constexpr inline void inv(){*this={x/norm(*this),-y/norm(*this)};}
//     constexpr inline T norm(){return x*x+y*y;}
//     constexpr inline T abs(){return sqrt(norm(*this));}
// };

// template<typename T>
// struct point:complex_t<T>{
//     using complex_t<T>::complex_t;
//     using C=point;
//     constexpr static T EPS=1e-8;
//     constexpr inline bool operator ==(C rhs){
//         return (this->x-rhs.x)*(this->x-rhs.x)+(this->y-rhs.y)*(this->y-rhs.y)<=EPS;
//     }
//     constexpr inline bool operator !=(C rhs){
//         return !(*this==rhs);
//     }
//     //偏角ソート
//     constexpr inline bool operator <(C rhs){
//         return this->quad()==rhs.quad()?cross(rhs)>0:quad()<rhs.quad();
//     }
//     //偏角をPI/2で割った商+1/要するに象限を返す
//     int quad(){
//         if(this->x>=0&&this->y>=0)return 1;
//         if(this->x<=0&&this->y>=0)return 2;
//         if(this->x<=0&&this->y<=0)return 3;
//         if(this->x>=0&&this->y<=0)return 4;
//         assert(0);
//         return -1;
//     }
//     // 90*i度回転
//     void rot(int i){
//         for(int j=0;j<i;j++){
//             (*this)=C(this->y,-this->x);
//         }
//     }
//     T distance(C rhs){return abs(this->x-rhs.x,this->y-rhs.y);}
//     T dot(C rhs){return (this->x*rhs.x)+(this->y*rhs.y);}
//     T cross(C rhs){return (this->x*rhs.y)-(this->y*rhs.x);}
//     T angle(){
//         return atan2(this->y,this->x);
//     }
// };

// int main(){
//     lint n;
//     cin>>n;
//     vector<point<lint>>v(n);
//     rep(i,n)cin>>v[i].x>>v[i].y;
//     rep(i,n)v[i].rot(2);
//     sort(all(v));
//     rep(i,n){
//         v[i].rot(2);
//         cout<<v[i].x<<" "<<v[i].y<<" "<<endl;
//     }
// }

#include<bits/stdc++.h>
using namespace::std;
int main(){
    string s;
    cin>>s;
    int n;
    cin>>n;
    bool b=0;
    while(n--){
        int x;
        cin>>x;
        if(x==1)b^=1;
        else {
            int i;string c;
            cin>>i>>c;
            if((i==1)^b)s=c+move(s);
            else s+=c;
        }
    }
    if(b)reverse(s.begin(),s.end());
    cout<<s<<endl;
}

Measured memory_bytes: 900