#include <bits/stdc++.h>
#define int long long
using namespace std;
using ld = long double;

template <class T, class U>
bool contains(const map<T, U> &mp, const T &key) {
    return mp.find(key) != mp.end();
}

struct State {
    int idx;
    int line;
    vector<string> s;
};

struct Expr {
    enum Type {
        IMV,
        ARRAY,
    } type;
    int value;
    char arr_name;
    Expr *num;
    static Expr *from_int(int x) {
        return new Expr {Type::IMV, x, '\0', nullptr};
    }
};

struct Statement {
    enum Type {
        DECL,
        ASSIGN,
    } type;
    char arr_name;
    Expr *num;
    Expr *value;
};

char get_char(State &st) {
    if ((int)st.s[st.line].size() <= st.idx) return '\n';
    return st.s[st.line][st.idx];
}

bool is_digit(State &st) {
    return '0' <= get_char(st) && get_char(st) <= '9';
}

int parse_num(State &st) {
    string num = "";
    while (is_digit(st)) {
        num += get_char(st);
        st.idx += 1;
    }
    int ret = stoll(num);
    return ret;
}

Expr *parse_expr(State &st) {
    if (is_digit(st)) {
        return Expr::from_int(parse_num(st));
    } else {
        Expr *expr = new Expr();
        expr->type = Expr::Type::ARRAY;
        expr->arr_name = get_char(st);
        st.idx += 2;
        expr->num = parse_expr(st);
        st.idx += 1;
        return expr;
    }
}

vector<Statement> parse_program(State &st) {
    vector<Statement> statements;
    while (st.line < (int)st.s.size()) {
        Statement s;
        s.arr_name = get_char(st);
        st.idx += 2;
        s.num = parse_expr(st);
        st.idx += 1;
        if (get_char(st) == '\n') {
            s.type = Statement::Type::DECL;
        } else {
            st.idx += 1;
            s.type = Statement::Type::ASSIGN;
            s.value = parse_expr(st);
        }
        st.line++;
        st.idx = 0;
        statements.push_back(s);
    }
    return statements;
}

map<char, int> arr_size;
map<char, map<int, int>> arr_data;
bool eval_expr(Expr &expr, int &ret) {
    if (expr.type == Expr::Type::IMV) {
        ret = expr.value;
        return true;
    } else {
        int num;
        bool valid = eval_expr(*expr.num, num);
        if (!valid) return false;
        if (!contains(arr_size, expr.arr_name)) return false;
        if (!(0 <= num && num < arr_size[expr.arr_name])) return false;
        if (!contains(arr_data[expr.arr_name], num)) return false;
        ret = arr_data[expr.arr_name][num];
        return true;
    }
}
bool eval_statement(Statement &s) {
    if (s.type == Statement::Type::DECL) {
        int num;
        bool valid = eval_expr(*s.num, num);
        if (!valid) return false;
        arr_size[s.arr_name] = num;
    } else {
        if (!contains(arr_size, s.arr_name)) return false;
        int num, value;
        bool valid = eval_expr(*s.num, num);
        if (!valid) return false;
        if (!(0 <= num && num < arr_size[s.arr_name])) return false;
        valid = eval_expr(*s.value, value);
        if (!valid) return false;
        arr_data[s.arr_name][num] = value;
    }
    return true;
}
int check_program(vector<Statement> &prog) {
    int ans = 0;
    for (int i = 0; i < (int)prog.size(); i++) {
        auto &s = prog[i];
        if (!eval_statement(s)) {
            ans = i + 1;
            break;
        }
    }
    return ans;
}

signed main() {
    while (1) {
        arr_size.clear();
        arr_data.clear();
        string s;
        cin >> s;
        if (s == ".") break;

        State state = {0, 0, {}};
        state.s.push_back(s);
        while (1) {
            cin >> s;
            if (s == ".") break;
            state.s.push_back(s);
        }
        auto prog = parse_program(state);
        cout << check_program(prog) << endl;
    }
}



Measured memory_bytes: 5228