// CL interpreter - stack representation

// Oleg Mazonka 2003

#include <iostream>
#include <vector>

using namespace std;

class heap;


struct el{
	enum KS { K = -1, S = -2 };
	union{
		heap * p;
		KS q;
	};
	bool isK() const { return q==K; }
	bool isS() const { return q==S; }
	bool isA() const { return q!=S && q!=K; }

	el():p(0){}
	el(KS q):q(q){}
	el(const el&e);
	~el();
	void operator=(const el&);

	void print(bool=false) const;
	void evaluate();
	void apply(el);
	bool equal(el) const;

private:
	void grab();
	void swap(el&e){ heap*x = p; p=e.p; e.p=x; }
};
	
struct heap{
	int n;
	vector<el> v;
	
	heap():n(1){}

	void print() const;
	bool equal(heap*);
};

void el::grab() { if(isA()&&p) ++(p->n); }
el::el(const el&e): p(e.p) { grab(); }
el::~el(){ 
	if(isA() && p) 
		if(p->n == 1) 
			delete p;
		else
			--(p->n);
}
void el::operator=(const el&e){
	el x;
	swap(x);
	p = e.p;
	grab();
}

bool el::equal(el a) const{
	if( p==a.p ) return true;
	if( !isA() || !a.isA() ) return false;
	return p->equal(a.p);
}

bool heap::equal(heap * p){

	if( v.size() != p->v.size() ) return false;

	for( int i=v.size(); i>0; i-- )
	if( ! v[i-1].equal(p->v[i-1]) )
		return false;
	return true;

}

el readKS();
void extractBits(el);

int main(){

 try{
	if( sizeof(el::KS)!=sizeof(heap*) ) throw "int!=void*\n";

	el e = readKS();
//	cout<<"input: "; e.print(); cout<<endl;
	e.evaluate();
	cout<<"evaluated: "; e.print(); cout<<endl;
	cout<<"bits: ";
	extractBits(e);

 }catch(const char *s){
	cout<<s;
 }

}

/*
	E:=T*
	T:=S|K|(E)
*/

int readT();
// 0 EOF, 1 K, 2 S, 3 '(', 4 ')'

el readE(){

  el e;
  while( 1 ){
	int r = readT();
	if( r==0 ) break;
	if( r==4 ) break;
	if( r==1 ) e.apply(el::K);
	if( r==2 ) e.apply(el::S);
	if( r==3 ) e.apply(readE());
  }
  return e;
}

int readT(){
	char a;
	cin.get(a);
	if( !cin ) return 0;
	
	if( a=='K' ) return 1;
	if( a=='S' ) return 2;
	if( a=='(' ) return 3;
	if( a==')' ) return 4;
	
	return 0;
}

el readKS(){
	return readE();
}

void el::print(bool par) const {

	if( isK() ) cout<<"K";
	if( isS() ) cout<<"S";
	if( isA() )
	if(p){
	
		if(par) cout<<"(";
		p->print();
		if(par) cout<<")";
	}else cout<<"-EMPTY-";
}

void heap::print() const {

	for( int i=v.size(); i!=0; --i )
	v[i-1].print(true);

}

void el::apply(el arg){

	if( p==0 ){
		p = arg.p;
		grab();
		return;
	}

	heap * h = new heap;
	h->v.push_back(arg);
	h->v.push_back(*this);
	el e;
	e.p = h;
	swap(e);
}

void el::evaluate(){

	while(1){

	if( !isA() ) return;
	else if( !p ) return;

	vector<el> &v = p->v;

	if( v.size() == 1 ){
		el e = v.back();
		v.pop_back();
		swap(e);
	continue;	
	}

	if( v.back().isA() ){
		el e = v.back();
		v.pop_back();
		int sz = e.p->v.size();		
		for( int i=0; i<sz; i++ )
		v.push_back( e.p->v[i] );
	continue;
	}

	if( v.back().isK() && v.size() > 2 ){
		v.pop_back();
		el e = v.back();
		v.pop_back();
		v.pop_back();
		v.push_back( e );
	continue;
	}

	if( v.back().isS() && v.size() > 3 ){
		v.pop_back(); // S
		el x = v.back();
		v.pop_back(); // x
		el y = v.back();
		v.pop_back(); // y
		el z = v.back();
		v.pop_back(); // z
		el r;
		r.apply(y);
		r.apply(z);
		v.push_back( r );
		v.push_back( z );
		v.push_back( x );

	continue;
	}
		
	break;
	}

	if( isA()&&p )
	for( int i=p->v.size(); i>0; i-- )
	p->v[i-1].evaluate();
}

void extractBits(el e){

	el s(el::S);
	el k(el::K);

	el pQ(k); // K(K(SK))
	el p1(s); // SK
	el p0(k); // K

	p1.apply(k);
	{
		el as(s);
		as.apply(k);
		el ak(k);
		ak.apply(as);
                pQ.apply(ak);
	}

	pQ.evaluate();
	p0.evaluate();
	p1.evaluate();

	int c=0;
	while(1){
        	// test for list
		el r = e;
		for( int i=0; i<c; i++ ) r.apply(p1);
		el v = r;
		c++;

		r.apply(pQ);
		r.evaluate();

		int m=0;

		if( r.equal(p1) ) m=1;
		else if( r.equal(p0) ) m=2;

		if( m==1 ){
			v.apply(p0);
			v.evaluate();

			if( v.equal(p1) ) cout<<"1";
			else if( v.equal(p0) ) cout<<"0";
			else throw "\ninternal error: Y?=1 but Y0!=0or1\n";

		}

		if( m==2 ) break;
		if( m==0 ) { cout<<"<broken>"; return; }
	}
}