Problem: In this problem, we consider a simple programming language that has only declarations of one- dimensional integer arrays and assignment statements. The problem is to find a bug in the given program.

The syntax of this language is given in BNF as follows:

<image>

where <new line> denotes a new line character (LF).

Characters used in a program are alphabetical letters, decimal digits, =, [, ] and new line characters. No other characters appear in a program.

A declaration declares an array and specifies its length. Valid indices of an array of length n are integers between 0 and n - 1, inclusive. Note that the array names are case sensitive, i.e. array a and array A are different arrays. The initial value of each element in the declared array is undefined.

For example, array a of length 10 and array b of length 5 are declared respectively as follows.


a[10]
b[5]


An expression evaluates to a non-negative integer. A <number> is interpreted as a decimal integer. An <array_name> [<expression>] evaluates to the value of the <expression> -th element of the array. An assignment assigns the value denoted by the right hand side to the array element specified by the left hand side.

Examples of assignments are as follows.


a[0]=3
a[1]=0
a[2]=a[a[1]]
a[a[0]]=a[1]


A program is executed from the first line, line by line. You can assume that an array is declared once and only once before any of its element is assigned or referred to.

Given a program, you are requested to find the following bugs.

* An index of an array is invalid.
* An array element that has not been assigned before is referred to in an assignment as an index of array or as the value to be assigned.



You can assume that other bugs, such as syntax errors, do not appear. You can also assume that integers represented by <number>s are between 0 and 231 - 1 (= 2147483647), inclusive.



Input

The input consists of multiple datasets followed by a line which contains only a single '.' (period). Each dataset consists of a program also followed by a line which contains only a single '.' (period). A program does not exceed 1000 lines. Any line does not exceed 80 characters excluding a new line character.

Output

For each program in the input, you should answer the line number of the assignment in which the first bug appears. The line numbers start with 1 for each program. If the program does not have a bug, you should answer zero. The output should not contain extra characters such as spaces.

Example

Input

a[3]
a[0]=a[1]
.
x[1]
x[0]=x[0]
.
a[0]
a[0]=1
.
b[2]
b[0]=2
b[1]=b[b[0]]
b[0]=b[1]
.
g[2]
G[10]
g[0]=0
g[1]=G[0]
.
a[2147483647]
a[0]=1
B[2]
B[a[0]]=2
a[B[a[0]]]=3
a[2147483646]=a[2]
.
.


Output

2
2
2
3
4
0

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
#include<regex>
#include<cctype>
using namespace std;
#define INFS (1LL<<28)
#define INF (1LL<<60)
#define DEKAI 1000000007
#define MOD 998244353
#define lp(i,n) for(int i=0;i<n;i++)
#define double long double
#define all(c) begin(c), end(c)

//#define int long long 

namespace {
#define __DECLARE__(C)    \
    template <typename T> \
    std::ostream &operator<<(std::ostream &, const C<T> &);

#define __DECLAREM__(C)               \
    template <typename T, typename U> \
    std::ostream &operator<<(std::ostream &, const C<T, U> &);

__DECLARE__(std::vector)
__DECLARE__(std::deque)
__DECLARE__(std::set)
__DECLARE__(std::stack)
__DECLARE__(std::queue)
__DECLARE__(std::priority_queue)
__DECLARE__(std::unordered_set)
__DECLAREM__(std::map)
__DECLAREM__(std::unordered_map)

template <typename T, typename U>
std::ostream &operator<<(std::ostream &, const std::pair<T, U> &);
template <typename... T>
std::ostream &operator<<(std::ostream &, const std::tuple<T...> &);
template <typename T, std::size_t N>
std::ostream &operator<<(std::ostream &, const std::array<T, N> &);

template <typename Tuple, std::size_t N>
struct __TuplePrinter__ {
    static void print(std::ostream &os, const Tuple &t) {
        __TuplePrinter__<Tuple, N - 1>::print(os, t);
        os << ", " << std::get<N - 1>(t);
    }
};

template <typename Tuple>
struct __TuplePrinter__<Tuple, 1> {
    static void print(std::ostream &os, const Tuple &t) { os << std::get<0>(t); }
};

template <typename... T>
std::ostream &operator<<(std::ostream &os, const std::tuple<T...> &t) {
    os << '(';
    __TuplePrinter__<decltype(t), sizeof...(T)>::print(os, t);
    os << ')';
    return os;
}

template <typename T, typename U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &v) {
    return os << '(' << v.first << ", " << v.second << ')';
}

#define __INNER__                             \
    os << '[';                                \
    for (auto it = begin(c); it != end(c);) { \
        os << *it;                            \
        os << (++it != end(c) ? ", " : "");   \
    }                                         \
    return os << ']';

template <typename T, std::size_t N>
std::ostream &operator<<(std::ostream &os, const std::array<T, N> &c) {
    __INNER__
}

#define __DEFINE__(C)                                           \
    template <typename T>                                       \
    std::ostream &operator<<(std::ostream &os, const C<T> &c) { \
        __INNER__                                               \
    }

#define __DEFINEM__(C)                                             \
    template <typename T, typename U>                              \
    std::ostream &operator<<(std::ostream &os, const C<T, U> &c) { \
        __INNER__                                                  \
    }

#define __DEFINEW__(C, M1, M2)                                  \
    template <typename T>                                       \
    std::ostream &operator<<(std::ostream &os, const C<T> &c) { \
        std::deque<T> v;                                        \
        for (auto d = c; !d.empty(); d.pop()) v.M1(d.M2());     \
        return os << v;                                         \
    }

__DEFINE__(std::vector)
__DEFINE__(std::deque)
__DEFINE__(std::set)
__DEFINEW__(std::stack, push_front, top)
__DEFINEW__(std::queue, push_back, front)
__DEFINEW__(std::priority_queue, push_front, top)
__DEFINE__(std::unordered_set)
__DEFINEM__(std::map)
__DEFINEM__(std::unordered_map)
}


#define rep(i,n) lp(i,n)
using Weight = int;
using Flow = int;
struct Edge {
    int src, dst;
    Weight weight;
    Flow cap;
    Edge() : src(0), dst(0), weight(0) {}
    Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;

void add_edge(Graph &g, int a, int b, Weight w = 1) {
    g[a].emplace_back(a, b, w);
    g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) { g[a].emplace_back(a, b, w); }






map<string,int> varmaxi;
map<pair<string,int>,int> val;

void mpin(){
	varmaxi.clear();
	val.clear();
}

bool iseq(string &s){
	lp(i,s.size()){
		if(s[i]=='=')return true;
	}
	return false;
}

void stsep(string s,string &l,string &r){
	lp(i,s.size()){
		if(s[i]=='='){
			l=s.substr(0,i);
			r=s.substr(i+1,s.size()-i-1);
			return;
		}
	}
	assert(false);
}

pair<string,string> valsep(string s){
	lp(i,s.size()){
		if(s[i]=='['){
			string x,y;
			x=s.substr(0,i);
			y=s.substr(i+1,s.size()-i-2);
			return {x,y};		
		}
	}
	assert(false);
}

int valget(string s){
	pair<string,string> p=valsep(s);
	string x=p.first;
	string y=p.second;
	int num=stoi(y);
	if(varmaxi.find(x)==varmaxi.end()){
		return -1;
	}
	int maxi=varmaxi[x];
	if(num>=maxi){
		return -1;
	}
	if(val.find({x,num})==val.end()){
		return -1;
	}
	return val[{x,num}];
}
int valget(string x,string y){
	int num=stoi(y);
	if(varmaxi.find(x)==varmaxi.end()){
		return -1;
	}
	int maxi=varmaxi[x];
	if(num>=maxi){
		return -1;
	}
	if(val.find({x,num})==val.end()){
		return -1;
	}
	return val[{x,num}];
}
bool isd(string s){
	lp(i,s.size()){
		if('0'<=s[i]&&s[i]<='9')continue;
		return false;
	}
	return true;
}

int solr(string s){
	//cout<<s<<endl;
	if (isd(s)){
		return stoi(s);
	}
	else{
		string x,y;
		pair<string,string> p=valsep(s);
		x=p.first;
		y=p.second;
		y=to_string(solr(y));
		return valget(x,y);
	}
}

int valset(string s,int num){
	string x,y;
	x=valsep(s).first;
	y=valsep(s).second;
	int v=stoi(y);
	if(varmaxi.find(x)==varmaxi.end())return -1;
	if(varmaxi[x]<=v)return -1;
	val[{x,v}]=num;
	return 0;
}

int soll(string s,int num){
	if (isd(s)){
		return stoi(s);
	}
	else{
		string x,y;
		pair<string,string> p=valsep(s);
		x=p.first;
		y=p.second;
		y=to_string(solr(y));
		if(y=="-1")return -1;
		s=x+"["+y+"]";
		return valset(s,num);
	}
}

bool solve(string l,string r){
	int x=solr(r);
	if(x==-1)return false;
	if(soll(l,x)==-1)return false;
	return true;
}

signed main(){
	while(1){
		mpin();
		int cnt=0;
		vector<string> v;
		while(1){
			string s;
			cin>>s;
			if(s==".")break;
			v.push_back(s);
		}
		if(v.empty())break;
		lp(i,v.size()){
			string s=v[cnt];
			cnt++;
			if(iseq(s)){
				string l,r;
				stsep(s,l,r);
				if(solve(l,r)==false){
					break;
				}
			}
			else{
				string x=valsep(s).first;
				string y=valsep(s).second;
				int n=stoi(y);
				varmaxi[x]=n;
			}
			if(i+1==v.size())cnt=0;
		}
		cout<<cnt<<endl;
	}
	return 0;
}