#include <cctype>
#include <vector>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cassert>
#include <sstream>

using namespace std;


struct Port {
  int gate; // -1=X
  int pos; // 0=Left, 1=Right
  
  Port(int gate_number=-1, int position=-1) 
    : gate(gate_number)
    , pos(position) {}

  Port offset(int gate_off, int input_off) {
    if (gate==-1) 
      pos+=input_off;
    else
      gate+=gate_off;
  }

  void save(ostream &out) const {
    if (gate==-1) {
      if (pos==0)
	out<<"X";
      else
	out<<pos<<"X";
    } else {
      out<<gate;
      if (pos==0) out<<"L";
      else out<<"R";
    }
  }
};

struct Gate {
  int value[2];
  Port port[4]; // input L, input R, output L, output R
  
  void clear() {
    value[0]=0;
    value[1]=0;
  }
  
  void compute(int L, int R) {
    static const int table[]={
      0,2, 2,2, 1,2, 
      1,2, 0,0, 2,1,
      2,2, 1,1, 0,0};
    
    value[0]=table[(L*3+R)*2];
    value[1]=table[(L*3+R)*2+1];
  }
  
  Gate() {
    clear();
  }

  void offset(int gate_off, int input_off) {
    for (int i=0;i<4;++i)
      port[i].offset(gate_off,input_off);
  }
};

struct Circuit {
  vector<Port> start;
  vector<Port> end;
  
  int value; // input

  vector<Gate> gate;

  void clear();
  void load(istream &in);
  void load(const char *str);
  void save(ostream &out);

  inline int read(Port p);

  int step(int in);

  void append(const Circuit &x);
  void connect(int from, int to);

  Circuit() {}

  Circuit(const char *str) {
    load(str);
  }
};

void skipSpaces(istream &in) {
  while(in) {
    int c=in.get();
    if (!isspace(c)) {
      in.putback(c);
      return;
    }
  }
}

Port getPort(istream &in) {
  int c;  
  c=in.get();
  if (c=='X') 
    return Port(-1,0);
  else if (isdigit(c)) {
    int n=0;
    do {
      n=n*10 + c-'0';
      c=in.get();
    } while (isdigit(c));
    if (c=='L')
      return Port(n,0);
    if (c=='R')
      return Port(n,1);
    if (c=='X') // estensione per il multiinput
      return Port(-1,n);
  }
  cerr<<"unexpected character ["<<c<<"]"<<endl;
  exit(1);
}

void expect(istream &in, int car) {
  int c=in.get();
  if (c!=car) {
    cerr<<"character ["<<c<<"] found while ["<<car<<"] expected"<<endl;
    exit(1);
  }
}

void Circuit::load(const char *str) {
  stringstream ss(stringstream::in | stringstream::out);
  ss << str;
  load(ss);
}

void Circuit::load(istream &in) {
  start.resize(0);
  end.resize(0);
  gate.resize(0);

  int c;

  do {
    start.push_back(getPort(in));
    c=in.get();
    if (c!=':') in.putback(c);
  } while (in && c!=':');
  assert(c==':');

  skipSpaces(in);
  int i;
  for (i=0;;++i) {
    Gate g;
    g.port[0]=getPort(in);
    g.port[1]=getPort(in);
    expect(in, '0');
    expect(in, '#');
    g.port[2]=getPort(in);
    g.port[3]=getPort(in);

    gate.push_back(g);
    
    int c=in.get();
    skipSpaces(in);
    if (c==':') break;
    if (c!=',') {
      cerr<<"characters : or , expected"<<endl;
      exit(2);
    }
  }

  do {
    end.push_back(getPort(in));
    skipSpaces(in);
  } while (in);
    
  assert(start.size()==end.size());
      
  cerr<<"read "<<gate.size()<<" gates, "<<start.size()<<" inputs"<<endl;
}

void Circuit::save(ostream &out) {
  for (int i=0;i<start.size();++i) {
    start[i].save(out);
  }
  out<<":"<<endl;
  for (int i=0;i<gate.size();++i) {
    gate[i].port[0].save(out);
    gate[i].port[1].save(out);
    out<<"0#";
    gate[i].port[2].save(out);
    gate[i].port[3].save(out);
    if (i+1<gate.size())
      out<<","<<endl;
    else
      out<<":"<<endl;
  }
  for (int i=0;i<end.size();++i) {
    end[i].save(out);
  }  
  out<<endl;
}

void Circuit::clear() {
  for (int i=0;i<gate.size();++i)
    gate[i].clear();
  value=0;
}

int Circuit::read(Port p) {
  if (p.gate==-1)
    return value;
  return gate[p.gate].value[p.pos];
}

int Circuit::step(int in) {
  value=in;
  for (int i=0;i<gate.size();++i) {
    gate[i].compute(read(gate[i].port[0]),read(gate[i].port[1]));
  }
  assert(end.size()==1);
  return read(Port(end[0]));
}

void Circuit::append(const Circuit &x) {
  int gate_offset=gate.size();
  int input_offset=start.size();

  for (int i=0;i<x.start.size();++i) {
    Port p=x.start[i];
    p.offset(gate_offset,input_offset);
    start.push_back(p);
    p=x.end[i];
    p.offset(gate_offset,input_offset);
    end.push_back(p);
  }

  for (int j=0;j<x.gate.size();++j) {
    gate.push_back(x.gate[j]);
    gate.back().offset(gate_offset,input_offset);
  }
}

void Circuit::connect(int from, int to) {
  assert(from<start.size() && to<start.size());

  gate[end[from].gate].port[2+end[from].pos]
    = start[to];
  gate[start[to].gate].port[start[to].pos]
    = end[from];

  start.erase(start.begin()+to);
  end.erase(end.begin()+from);

  for (int i=0;i<gate.size();++i) {
    for (int k=0;k<2;++k) {
      if (gate[i].port[k].gate==-1 && 
	  gate[i].port[k].pos>to)
	gate[i].port[k].pos--;
      if (gate[i].port[2+k].gate==-1 &&
	  gate[i].port[2+k].pos>from)
	gate[i].port[2+k].pos--;
    }
  }
}

Circuit circuit;

const char ZERO[]=
  "1R:"
  "8L0L0#0R1L," // 0
  "0RX0#2L2R,"  // 1
  "1L1R0#3L3R," // 2
  "2L2R0#4L4R," // 3
  "3L3R0#8L5R," // 4
  "7L4R0#8R7L," // 5
  "7R6L0#6R7R," // 6
  "5R6R0#5L6L," // 7
  "4L5L0#0LX:"  // 8
  "8R" ;

const char ONE_1[]=
  "1L:"
  "3L0L0#0R1R," // 0
  "X0R0#X3L,"   // 1
  "3R2L0#2R3R," // 2
  "1R2R0#0L2L:" // 3
  "1L" ;

const char TWO_1[]=
  "0L:"
  "X0L0#0RX:"
  "0R";

const char ID[]=
  "0R:"
  "2RX0#1R2R," // 0
  "2L0L0#X2L," // 1
  "1R0R0#1L0L:"// 2
  "1L";

const char DELTA_1[]=
  "4R:"
  "4L4R0#1R2R,"//0
  "3L0L0#4L3L,"//1
  "3R0R0#X3R,"//2
  "1R2R0#1L2L,"//3
  "1LX0#0L0R:"//4
  "2L";

const char QUAD_1[]=
  "1L0L2R3L:"
  "1X0L0#0R2L," //0
  "0X1L0#1R4L," //1
  "0R2X0#4R5R," //2
  "3X3L0#3R5L," //3
  "1R2L0#0X1X," //4
  "3R2R0#2X3X:" //5
  "4L4R5L5R";

const char DUP_1[]=
  "2L0L1R:"
  "1X0L0#0R1L,"//0
  "0R2X0#3R2X,"//1
  "0X2L0#2R3L,"//2
  "2R1L0#0X1X:"//3
  "3L3R1R";

const char TERNA_1[]=
  "1L0R1R0L2R:"
  "3X1X0#3X2L,"//0
  "0X2X0#2X3L,"//1
  "0R4X0#4X3R,"//2
  "1R2R0#0X1X:"//3
  "3L3R1L0L2L";

Circuit zero(ZERO);
Circuit one;
Circuit two;
Circuit id(ID);
Circuit delta;
Circuit tau;
Circuit duplex;
Circuit quad;
Circuit terna;

void construct() {

  one.append(zero);
  one.append(Circuit(ONE_1));
  one.connect(0,1);

  two.append(zero);
  two.append(Circuit(TWO_1));
  two.connect(0,1);

  delta.append(one);
  delta.append(Circuit(DELTA_1));
  delta.connect(0,1);

  tau.append(id);
  tau.append(id);
  tau.connect(1,0);

  duplex.append(Circuit(DUP_1));
  duplex.append(zero);
  duplex.connect(3,1);
  duplex.append(zero);
  duplex.connect(3,0);
  duplex.connect(2,1);

  quad.append(Circuit(QUAD_1));
  quad.append(zero);
  quad.connect(4,0);
  quad.append(zero);
  quad.connect(4,1);
  quad.append(zero);
  quad.connect(4,3);

  terna.append(duplex);
  terna.append(one);
  terna.append(Circuit(TERNA_1));
  terna.connect(0,3);
  terna.connect(0,3);
  terna.connect(0,4);
  terna.connect(1,1);
  terna.connect(1,1);
  assert(terna.start.size()==3);
}

void addTrit(char trit) {
  circuit.append(tau);
  circuit.connect(0,1);
  circuit.append(delta);
  switch(trit) {
  case '0':
    circuit.append(zero);
    break;
  case '1':
    circuit.append(one);
    break;
  case '2':
    circuit.append(two);
    break;
  default:
    assert(false);
  }
  circuit.append(terna);
  circuit.connect(0,5);
  circuit.connect(0,3);
  circuit.connect(0,3);
  circuit.connect(1,1);
  circuit.connect(1,1);
  assert(circuit.start.size()==1);
}

void sequence(const char *s) {
  int i;
  circuit.append(zero);

  for (i=0;s[i];++i);
  --i;
  while (i>=0) {
    addTrit(s[i]);
    i--;
  }
}

main(int argc, char *argv[]) {
  
  if (argc==1) {
    construct();
    sequence("110212101121012211");
    circuit.save(cout);
  } else {  
    char *filename=argv[1];
    ifstream in(filename);
    if (!in) {
      cerr<<"cannot open file ["<<filename<<"]"<<endl;
      exit(4);
    }
    circuit.load(in);
  }

  cerr<<"write stream:"<<endl;
  while(cin) {
    int in;
    cin>>in;
    cout<<circuit.step(in);
  }
  cout<<endl;
}