public class Band{
	private char[] mWord;
	private int mPointer;
	public Band(String pWord){
		pWord="#"+pWord+"#";
		mWord=pWord.toCharArray();
		mPointer=1;
	}
	public void write(char a){
		mWord[mPointer]=a;
	}	
	public char read(){
		return mWord[mPointer];
	}
	public void goLeft(){
		mPointer--;
	}
	public void goRight(){
		mPointer++;
	}
}

import java.io.*;
import java.util.List;
import java.util.LinkedList;
import java.util.Map;
import java.util.HashMap;
public class Zustand{
	private Map<Character,Uebergang> mUebergang;
	private boolean mExit;
	private boolean mAccept;
	public Zustand(){
		mUebergang=new HashMap<Character,Uebergang>();
		mExit=false;
		mAccept=false;
	}
	public void add(Uebergang u,String sign){
		mUebergang.put(new Character(sign.charAt(0)),u);
	}
	public void setExit(boolean b){
		mExit=b;
	}
	public void setAccept(boolean b){
		mAccept=b;
		if(b)mExit=true;
	}
	public boolean isAccepted(){
		return mAccept;
	}
	public boolean isExit(){
		return mExit;
	}
	public Zustand handle(Band b){
		char a=b.read();
		Uebergang x=mUebergang.get(new Character(b.read()));
		if(x==null) return null;
		return x.handle(b);
	}
}
	
import java.io.*;
import java.util.HashMap;
import java.util.Map;
public class TuringMaschine{
	private Zustand mStart;
	private TuringMaschine(){
		mStart=new Zustand();
		Zustand b=new Zustand();
		b.setExit(true);
		b.setAccept(true);
		Uebergang f=new Uebergang('a',b,true);
		mStart.add(f,"a");
	}
	private TuringMaschine(String mFilename){
		try{
			File f=new File(mFilename);
			if(!f.exists()||!f.canRead()){
				System.out.println("Fehler");
				System.exit(0);
			}
			BufferedReader din = new BufferedReader(new FileReader(f));
			HashMap<String,Zustand> z=new HashMap<String,Zustand>();
			mStart=null;
			while(din.ready()){
				parseLine(din.readLine(),mStart,z);
			}
		}catch(Exception e){
			System.out.println(e);
		}
	}
	private void parseLine(String pLine,Zustand pStart, Map<String,Zustand> m){
		
		pLine=pLine.trim();
		if(pLine.startsWith("#"))return;
		
		String[] n=pLine.split("#");
		pLine=n[0];
		String[] y=pLine.split("=>");
		String[] x=y[0].split(",");
		String[] z=y[1].split(",");
		char[] ss=z[0].trim().toCharArray();
		String name=x[0].trim();		
		char w=ss[0];
		String ziel=z[1].trim();
		boolean r=(z[2].trim().startsWith("+")||z[2].trim().toLowerCase().startsWith("r"));
		Zustand a=m.get(name);
		if(a==null)a=new Zustand();
		if(mStart==null)mStart=a;
		m.put(name,a);
		Zustand b=m.get(ziel);
		if(b==null)b=new Zustand();
		m.put(name,b);
		Uebergang f=new Uebergang(w,b,r);
		a.add(f,x[1].trim());
		if(z[2].trim().equals("accept"))b.setAccept(true);
		if(z[2].trim().equals("exit"))b.setExit(true);
		
		
	}
	public boolean check(String pWord){
		Band b=new Band(pWord);
		
		return check(mStart,b);
	}
	private boolean check(Zustand z, Band b){
		while(z!=null&&!z.isExit()){			
			z=z.handle(b);
		}
		if(z==null){
			System.out.println("error");
			return false;
		}
		return z.isAccepted();
	}
	public static void main(String[] args){
		TuringMaschine instance=new TuringMaschine(args[0]);
		
		System.out.println(instance.check(args[1]));
	}
}

public class Uebergang{
	private char mWrite;
	private Zustand mNext;
	private boolean mRight;
	private char mSign;
	public void setSign(char pSign){
		mSign=pSign;
	}
	public char getSign(){
		return mSign;
	}
	public Uebergang(char pWrite,Zustand pNext,boolean pRight){
		mWrite=pWrite;
		mNext=pNext;
		mRight=pRight;
	}
	public Zustand handle(Band b){
		b.write(mWrite);				
		if(mRight)b.goRight();
		else b.goLeft();
		return mNext;
	}
}




#folgende Regeln sind zu beachten: die # kennzeichnet einen Kommentar bis zum Zeilenende.
#ein Datensatz pro Zeile nach dem Muster Zustand;Zeichen;Zeichen Geschrieben;Ziel-Zustand;Band l/r ist erlaubt.
#Beispiel: Z1,a=>a,Z2,r
#Endzustand: Z1,a=>a,Z2,exit
#Akzeptiert: Z1,a=>a,Z2,accept
Z,a=>a,X,r
Z,b=>b,Y,accept
X,b=>b,Y,exit
z3,b=>a,z1,l