# from __future__ import print_function
import sys

class StdLongString:
    
# class variables

# methods

    def __init__(self,length,maxLen):
        if length == 0:
            self.snippet=[0]
            self.originalIndex=[-maxLen]
            self.ch=['']
        else:
            self.snippet=[0, length]
            self.originalIndex=[0, -maxLen]
            self.ch=['','']

#   return LongString structure as a printable string

    def __str__(self):
        s="{:d}, '{:s}', {:d}".format(self.snippet[0],self.ch[0],self.originalIndex[0])
        for i in range(1,len(self.snippet)):
            s=s + "\n{:d}, '{:s}', {:d}".format(self.snippet[i],self.ch[i],self.originalIndex[i])
        return s

#   display detailed character-by-character contents of LongString

    def expand(self):
        for k in range(len(self.snippet) - 1):
            c=self.ch[k]
            oi=self.originalIndex[k]
            for p in range(self.snippet[k],self.snippet[k + 1]):
                if c == '':
                    print("{:d} [{:d}]".format(p,oi))
                    oi += 1
                else:
                    print("{:d} '{:s}'".format(p,c))

#   return longest snippet [index, character, original index, length] starting at index n

    def snippetAt(self,n):
        k=[i for i,v in enumerate(self.snippet) if v <= n][-1]
        p=self.snippet[k]
        if p == n:
            return [n,self.ch[k],self.originalIndex[k],self.snippet[k + 1] - p]
        else:
            return [n,self.ch[k],self.originalIndex[k] + n - p,self.snippet[k + 1] - n]

    def length(self):
        return self.snippet[-1]

    def isEqual(self,ls2):
        l1=self.length()
        l2=ls2.length()
        if l1 == l2:
            p=0
            while p < l1:
                s1=self.snippetAt(p)
                s2=ls2.snippetAt(p)
                if s1[:3] != s2[:3]:
                    return False
                p += min(s1[3],s2[3])
            return True
        else:
            return False

#   LongString.insert(n, ch) for n=0..L-1 inserts BEFORE char index n
#   LongString.insert(n, ch) for n=L appends at the end of the string
#   n < 0 or n > L are out of bounds, but unchecked!

    def insert(self,n,ch):
        k=[i for i,v in enumerate(self.snippet) if v <= n][-1]
        p=self.snippet[k]
        if p == n:  # new snippet in front of this snippet
            rLength=len(self.snippet[k:])
            self.snippet[k:]=[sum(x) for x in zip(self.snippet[k:],rLength*[1])]
            self.snippet.insert(k,n)
            self.ch.insert(k,ch)
            self.originalIndex.insert(k,-1)
        else:  # break this snippet in two
            rLength=len(self.snippet[k + 1:])
            self.snippet[k + 1:]=[sum(x) for x in zip(self.snippet[k + 1:],rLength*[1])]
            self.snippet.insert(k + 1,n + 1)
            self.ch.insert(k + 1,self.ch[k])
            self.originalIndex.insert(k + 1,self.originalIndex[k] + n - p)
            self.snippet.insert(k + 1,n)
            self.ch.insert(k + 1,ch)
            self.originalIndex.insert(k + 1,-1)

#   LongString.delete(n) for n=0..L-1 deletes character index n
#   n < 0 or N >= L are out of bounds, but unchecked!

    def delete(self,n):
        k=[i for i,v in enumerate(self.snippet) if v <= n][-1]
        p=self.snippet[k]
        kl=self.snippet[k + 1] - p
        if kl == 1:  # deleting a single-element snippet is easy
            rLength=len(self.snippet[k + 1:])
            self.snippet[k + 1:]=[sum(x) for x in zip(self.snippet[k + 1:],rLength*[-1])]
            del self.snippet[k]
            del self.ch[k]
            del self.originalIndex[k]
        else:
            rLength=len(self.snippet[k + 1:])
            if p == n:  # deletion at beginning end of snippet
                self.snippet[k + 1:]=[sum(x) for x in zip(self.snippet[k + 1:],rLength*[-1])]
                self.originalIndex[k]=self.originalIndex[k] + 1
            elif n - p + 1 == kl:  # deletion at the end of snippet
                self.snippet[k + 1:]=[sum(x) for x in zip(self.snippet[k + 1:],rLength*[-1])]
            else:  # break snippet into two smaller snippets
                self.snippet[k + 1:]=[sum(x) for x in zip(self.snippet[k + 1:],rLength*[-1])]
                self.snippet.insert(k + 1,n)
                self.ch.insert(k + 1,self.ch[k])
                self.originalIndex.insert(k + 1,self.originalIndex[k] + n - p + 1)

def operate(l,s):
    o=l.split()
    p=int(o[1])
    if o[0] == "I":
        s.insert(p,o[2])
    else:
        s.delete(p)

state=0
for line in sys.stdin:
    line=line.replace("\n","")
#   print(state,line)

#   state 0: expect N

    if state == 0:
        N=20000000000
        s1=StdLongString(N,1)
        s2=StdLongString(N,1)
        state=1

#   state 1: expect program 1

    elif state == 1:
        if line == "E":
#           print(s1)
#           s1.expand()
            state=2
        else:
            operate(line,s1)

#   state 2: expect program 2

    else:
        if line == "E":
#           print(s2)
#           s2.expand()
            if s1.isEqual(s2):
                print("0")
            else:
                print("1")
            state=0
        else:
            operate(line,s2)

exit(0)