Problem:
Score : 400 points

Problem Statement

Takahashi has a string S consisting of lowercase English letters.

Starting with this string, he will produce a new one in the procedure given as follows.

The procedure consists of Q operations. In Operation i (1 \leq i \leq Q), an integer T_i is provided, which means the following:

If T_i = 1: reverse the string S.

If T_i = 2: An integer F_i and a lowercase English letter C_i are additionally provided.

If F_i = 1 : Add C_i to the beginning of the string S.

If F_i = 2 : Add C_i to the end of the string S.

Help Takahashi by finding the final string that results from the procedure.

Constraints

1 \leq |S| \leq 10^5

S consists of lowercase English letters.

1 \leq Q \leq 2 \times 10^5

T_i = 1 or 2.

F_i = 1 or 2, if provided.

C_i is a lowercase English letter, if provided.

Input

Input is given from Standard Input in the following format:

S
Q
Query_1
:
Query_Q

In the 3-rd through the (Q+2)-th lines, Query_i is one of the following:

1

which means T_i = 1, and:

2 F_i C_i

which means T_i = 2.

Output

Print the resulting string.

Sample Input 1

a
4
2 1 p
1
2 2 c
1

Sample Output 1

cpa

There will be Q = 4 operations. Initially, S is a.

Operation 1: Add p at the beginning of S. S becomes pa.

Operation 2: Reverse S. S becomes ap.

Operation 3: Add c at the end of S. S becomes apc.

Operation 4: Reverse S. S becomes cpa.

Thus, the resulting string is cpa.

Sample Input 2

a
6
2 2 a
2 1 b
1
2 2 c
1
1

Sample Output 2

aabc

There will be Q = 6 operations. Initially, S is a.

Operation 1: S becomes aa.

Operation 2: S becomes baa.

Operation 3: S becomes aab.

Operation 4: S becomes aabc.

Operation 5: S becomes cbaa.

Operation 6: S becomes aabc.

Thus, the resulting string is aabc.

Sample Input 3

y
1
2 1 x

Sample Output 3

xy

Solution in Go (1.6) (judge verdict: Accepted)

package main

import (
  "bufio"
  "bytes"
  "fmt"
  "io"
  "io/ioutil"
  "os"
  "sort"
  "strconv"
  "strings"
  "unsafe"
)

const (
  InputSize = 500000 // 10^5
)

func getReader() *bufio.Reader {
  return bufio.NewReaderSize(os.Stdin, InputSize)
}

func readAllFromStdin() *bufio.Reader {
  rdr := bufio.NewReader(os.Stdin)
  buf, _ := ioutil.ReadAll(rdr)
  return bufio.NewReader(bytes.NewReader(buf))
}


func readLine(rdr *bufio.Reader) string {
  buf :=[]byte{}
  for {
    l, p, e := rdr.ReadLine()
    if e != nil && e != io.EOF {
      break
    }
    buf = append(buf, l...)
    if !p || e == io.EOF {
      break
    }
  }
  return string(buf)
}

func getStringArray(rdr *bufio.Reader) []string {
  return strings.Split(readLine(rdr), " ")
}


func nextLineValue(rdr *bufio.Reader) int {
  v, _ := strconv.Atoi(readLine(rdr))
  return v
}

func nextLineValues(rdr *bufio.Reader) []int {
  return getIntArray(readLine(rdr))
}

func getInt(s string) int {
  v, _ := strconv.Atoi(s)
  return v
}

func getIntArray(s string) []int {
  var v []int
  valstr := strings.Split(s, " ")
  for _, c := range valstr {
    va, _ := strconv.Atoi(c)
    v = append(v, va)
  }
  return v
}

func digitTotal(v int) int {
  total := 0
  d := strings.Split(strconv.Itoa(v), "")
  for _, c := range d {
    dv, _ := strconv.Atoi(c)
    total += dv
  }
  return total
}

func sortDesc(v *[]int) {
  sort.Sort(sort.Reverse(sort.IntSlice(*v)))
}

func removeDupIntSlice(values *[]int) []int {
  m := make(map[int]bool)
  uniq := []int{}
  for _, v := range *values {
    if !m[v] {
      uniq = append(uniq, v)
      m[v] = true
    }
  }
  return uniq
}

func removeDupStringSlice(values *[]string) []string {
  m := make(map[string]bool)
  uniq := []string{}
  for _, v := range *values {
    if !m[v] {
      uniq = append(uniq, v)
      m[v] = true
    }
  }
  return uniq
}

func countUniqIntInSlice(values *[]int) map[int]int {
  uniq := make(map[int]int)
  for _, v := range *values {
    if _, ok := uniq[v]; !ok {
      uniq[v] = 1
    } else {
      uniq[v] += 1
    }
  }
  return uniq
}

func countUniqStringInSlice(values *[]string) map[string]int {
  uniq := make(map[string]int)
  for _, v := range *values {
    if _, ok := uniq[v]; !ok {
      uniq[v] = 1
    } else {
      uniq[v] += 1
    }
  }
  return uniq
}


func reverseString(s string) string {
  ss := stringToByte(s)
  for i, j := 0, len(ss)-1; i < j; i, j = i+1, j-1 {
    ss[i], ss[j] = ss[j], ss[i]
  }
  return byteToString(&ss)
}

func reverseBytes(b bytes.Buffer) []byte {
  ss := b.Bytes()
  for i, j := 0, len(ss)-1; i < j; i, j = i+1, j-1 {
    ss[i], ss[j] = ss[j], ss[i]
  }
  return ss
}

func byteToString(b *[]byte) string {
  return *(*string)(unsafe.Pointer(b))
}

func stringToByte(s string) []byte {
  return *(*[]byte)(unsafe.Pointer(&s))
}

func getStringBuffer(s string) bytes.Buffer {
  var b bytes.Buffer
  b.Write(stringToByte(s))
  return b
}

func addStringToBuffer(s string, buf *bytes.Buffer) {
  buf.Write(stringToByte(s))
}


func main() {
  bufReader := readAllFromStdin() // getReader()
  startString := readLine(bufReader)
  q := nextLineValue(bufReader)

  directionFlag := true
  bufHead := new(bytes.Buffer)
  bufTail := new(bytes.Buffer)

  for i:=0; i<q; i++ {
    input := getStringArray(bufReader)
    if input[0] == "1" {
     directionFlag = !directionFlag
     continue
    }
    placeHead := true
    if input[1] == "1" {
     placeHead = directionFlag
    } else {
     placeHead = !directionFlag
    }
    if placeHead {
     addStringToBuffer(input[2], bufHead)
    } else {
     addStringToBuffer(input[2], bufTail)
    }
  }

  if directionFlag {
   sH := reverseString(bufHead.String())
   fmt.Printf("%s%s%s\n", sH, startString, bufTail.String())
  } else {
   sT := reverseString(bufTail.String())
   fmt.Printf("%s%s%s\n", sT, reverseString(startString), bufHead.String())
  }
}