#include <bits/stdc++.h>
using namespace std;

using pii = pair<int,int>;
using ll = long long;
#define rep(i, j) for(int i=0; i < (int)(j); i++)
#define repeat(i, j, k) for(int i = (j); i < (int)(k); i++)
#define all(v) v.begin(),v.end()
#define debug(x) cerr << #x << " : " << x << endl

template<class T> bool set_min(T &a, const T &b) { return a > b  ? a = b, true : false; }
template<class T> bool set_max(T &a, const T &b) { return a < b  ? a = b, true : false; }
// vector
template<class T> istream& operator >> (istream &is , vector<T> &v) { for(T &a : v) is >> a; return is; }
template<class T> ostream& operator << (ostream &os , const vector<T> &v) { for(const T &t : v) os << "\t" << t; return os << endl; }
// pair
template<class T, class U> ostream& operator << (ostream &os , const pair<T, U> &v) { return os << "<" << v.first << ", " << v.second << ">"; }

const int INF = 1 << 30;
const ll INFL = 1LL << 60;
int global_cnt =0;

class Solver {
  public:
    vector<string> S;
    map<char, map<ll, ll>> val;
    map<char, ll> len;
    ll get_number(int &i, string &s) {
        assert(isdigit(s[i]));
        ll res = 0;
        while(isdigit(s[i])) {
            res *= 10;
            res += (s[i++] - '0');
        }
        return res;
    }
    char get_name(int &i, string &s) {
        char name = s[i++];
        assert(('a' <= name and name <= 'z') or ('A' <= name and name <= 'Z'));
        return name;
    }
    tuple<ll, bool> get_expression(int &i, string &s) {
        auto fail = make_tuple(0, false);
        if(isdigit(s[i])) {
            return make_tuple(get_number(i, s), true);
        }
        char name;
        ll index;
        {
            name = get_name(i, s);
            assert(len.count(name)); // need decleared
            bool ok; tie(index, ok) = get_bexpression(i, s);
            if(not ok) return fail;
            if(index >= len[name]) {
                return fail;
            }
            if(not val[name].count(index)) {
                return fail;
            }
        }
        return make_tuple(val[name][index], true);
    }
    tuple<ll, bool> get_bexpression(int &i, string &s) {
        assert(s[i++] == '[');
        auto ret = get_expression(i, s);
        assert(s[i++] == ']');
        return ret;
    }
    
    void declaration(int &i, string &s) {
        char name = get_name(i, s);        
        assert(s[i++] == '[');
        ll num = get_number(i, s);
        assert(s[i++] == ']');
        assert(not len.count(name));
        len[name] = num;
    }

    bool assignment(int &i, string &s) {
        bool ok;
        char name;
        ll index;
        
        name = get_name(i, s);
        tie(index, ok) = get_bexpression(i, s);
        if(not ok) return false;
        
        assert(s[i++] == '=');
        
        ll right;
        tie(right, ok) = get_expression(i, s);
        if(not ok) return false;        

        // check
        assert(len.count(name)); // need deleared
        if(index >= len[name]) {
            return false; // out of range
        }
        val[name][index] = right;
        return true;
    }
    
    bool solve() {
        while(true) {
            string s; cin >> s;
            if(s == ".") break;
            S.push_back(s);
        }
        
        if(S.size() == 0) return false;
        rep(i, S.size()) {
            int pos = 0;
            if(S[i].find("=") == string::npos) declaration(pos, S[i]);
            else {
                bool ok = assignment(pos, S[i]);
                if(not ok) {
                    cout << i + 1 << endl;
                    return true;
                }
            }
            assert(pos == S[i].size());
        }
        cout << 0 << endl;
        return true;
    }
};

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    while(Solver().solve());
    return 0;
}

Measured memory_bytes: 3264