Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Transformation

Write a program which performs a sequence of commands to a given string $str$. The command is one of:

print a b: print from the a-th character to the b-th character of $str$

reverse a b: reverse from the a-th character to the b-th character of $str$

replace a b p: replace from the a-th character to the b-th character of $str$ with p

Note that the indices of $str$ start with 0.

Input

In the first line, a string $str$ is given. $str$ consists of lowercase letters. In the second line, the number of commands q is given. In the next q lines, each command is given in the above mentioned format.

Output

For each print command, print a string in a line.

Constraints

$1 \leq $ length of $str \leq 1000$

$1 \leq q \leq 100$

$0 \leq a \leq b < $ length of $str$

for replace command, $b - a + 1 = $ length of $p$

Sample Input 1

abcde
3
replace 1 3 xyz
reverse 0 2
print 1 4

Sample Output 1

xaze

Sample Input 2

xyz
3
print 0 2
replace 0 2 abc
print 0 2

Sample Output 2

xyz
abc

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ITP1_9_D
{
    class Program
    {
        static IEnumerable<string> ReadLines()
        {
            while (true)
            {
                yield return Console.ReadLine();
            }
        }


        static IEnumerable<string[]> ReadSplitWords(IEnumerable<string> strings, char splitChar)
        {
            foreach (var n in strings)
            {
                yield return n.Split(splitChar);
            }                
        }


        static void Print(string str, int startIndex, int endIndex)
        {
            for (var i = startIndex; i <= endIndex; ++i)
            {
                Console.Write(str[i]);
            }
            Console.WriteLine();
        }


        static string Reverse(string str, int startIndex, int endIndex)
        {
            var result = str.Substring(0, startIndex);
            for (var i = startIndex; i < str.Length; ++i)
            {
                if (i <= endIndex) 
                {
                    result += str[endIndex - (i - startIndex)];
                }
                else
                {
                    result += str[i];
                }
            }
            return result;
        }


        static string Replace(string str, int startIndex, int endIndex, string add)
        {
            var result = str.Substring(0, startIndex) + add;
            if ((endIndex + 1) < str.Length)
            {
                result += str.Substring(endIndex + 1);
            }
            return result;
        }


        static bool IsValidArgment(int strLength, int startIndex, int endIndex)
        {
            if (startIndex < 0 || strLength <= startIndex) return false;
            if (endIndex < 0 || strLength <= endIndex) return false;
            if (endIndex < startIndex) return false;
            return true;
        }


        static void Main(string[] args)
        {
            var word = Console.ReadLine();
            var count = int.Parse(Console.ReadLine());

            foreach (var n in ReadSplitWords(ReadLines(), ' ').Take(count))
            {
                var arg1 = int.Parse(n[1]);
                var arg2 = int.Parse(n[2]);
                var arg3 = n.Length < 4 ? null : n[3];

                if (IsValidArgment(word.Length, arg1, arg2) == false)
                {
                    continue;
                }

                switch (n[0]) 
                {
                    case "print": Print(word, arg1, arg2); break;
                    case "reverse": word = Reverse(word, arg1, arg2); break;
                    case "replace": word = Replace(word, arg1, arg2, arg3); break;
                }

            }
            
        }
    }
}