p359.ans2
======================
3

=================
p359.in2
======================
3 
a:=b; 
b^:=3; 
writeln(a^); 

=================
p359.cpp
======================
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n;
vector<string> lines;

void read() {
    cin >> n;
    lines.resize(n);
    cin >> lines;
}

void solve() {
    // This turns out to just be an implementation problem, and particularly in
    // C++ we can just use pointers and directly implement this.
    int* pa = new int(0);
    int* pb = new int(0);
    int* pc = new int(0);
    int* pd = new int(0);

    for(int i = 0; i < n; i++) {
        string line = lines[i];

        if(!line.empty() && line.back() == ';') {
            line.pop_back();
        }

        if(line.substr(0, 8) == "writeln(") {
            string inside = line.substr(8, line.size() - 8);
            if(!inside.empty() && inside.back() == ')') {
                inside.pop_back();
            }
            if(inside.size() != 2 || inside[1] != '^') {
                continue;
            }
            char p = inside[0];
            int val;
            if(p == 'a') {
                val = *pa;
            } else if(p == 'b') {
                val = *pb;
            } else if(p == 'c') {
                val = *pc;
            } else if(p == 'd') {
                val = *pd;
            } else {
                continue;
            }

            cout << val << endl;
        } else {
            size_t pos = line.find(":=");
            if(pos == string::npos) {
                continue;
            }

            string left = line.substr(0, pos);
            string right = line.substr(pos + 2);

            if(left.back() == '^') {
                if(left.size() != 2 || left[1] != '^') {
                    continue;
                }
                char p1 = left[0];
                int* ptr1;
                if(p1 == 'a') {
                    ptr1 = pa;
                } else if(p1 == 'b') {
                    ptr1 = pb;
                } else if(p1 == 'c') {
                    ptr1 = pc;
                } else if(p1 == 'd') {
                    ptr1 = pd;
                } else {
                    continue;
                }

                if(isdigit(right[0]) && right.size() == 1) {
                    int val = right[0] - '0';
                    *ptr1 = val;
                } else {
                    if(right.size() != 2 || right[1] != '^') {
                        continue;
                    }
                    char p2 = right[0];
                    int val;
                    if(p2 == 'a') {
                        val = *pa;
                    } else if(p2 == 'b') {
                        val = *pb;
                    } else if(p2 == 'c') {
                        val = *pc;
                    } else if(p2 == 'd') {
                        val = *pd;
                    } else {
                        continue;
                    }

                    *ptr1 = val;
                }
            } else {
                if(left.size() != 1) {
                    continue;
                }
                char p1 = left[0];
                if(right.size() != 1) {
                    continue;
                }
                char p2 = right[0];

                int* newptr;
                if(p2 == 'a') {
                    newptr = pa;
                } else if(p2 == 'b') {
                    newptr = pb;
                } else if(p2 == 'c') {
                    newptr = pc;
                } else if(p2 == 'd') {
                    newptr = pd;
                } else {
                    continue;
                }

                if(p1 == 'a') {
                    pa = newptr;
                } else if(p1 == 'b') {
                    pb = newptr;
                } else if(p1 == 'c') {
                    pc = newptr;
                } else if(p1 == 'd') {
                    pd = newptr;
                }
            }
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}

=================
statement.txt
======================
359. Pointers
Time limit per test: 0.25 second(s)
Memory limit: 65536 kilobytes
input: standard
output: standard



Pete learns dynamic pointers. In informatics tutorial he read about pointers in Pascal. Pointer is a special variable, containing address of some location in RAM. That location can contain value of a certain type. Pete declared four pointers pointing to memory cells with integer values in a following manner:

var a, b, c, d : ^integer;

Than he allocated memory with instruction new:

new(a); new(b); new(c); new(d);

and assigned zero values to memory cells, pointed by these pointers:

a^:=0; b^:=0; c^:=0; d^:=0;

Please note that a^ means accessing location of memory, pointed by the pointer. Notation a (without symbol "^") means accessing to the pointer itself. Pete uses four types of operators in his program:
pointer^:=constant, e.g. a^:=5. This operator puts value constant into the memory area pointed by pointer (compare fig. 1 and fig. 2);
pointer1^:=pointer2^, e.g. c^:=a^. This operator puts value from the memory area pointed by pointer2 to the memory area pointed by pointer1 (compare fig. 2 and fig. 3);
pointer1:=pointer2, e.g. b:=c. After execution of this operator pointer1 will point to the same memory area as pointer2 (compare fig. 3 and fig. 4);
writeln(pointer^), e.g. writeln(b^). Prints value from the memory area pointed by pointer^ (operator writeln(b^) will print 5 in our example).



Pete use digits 0 to 9 as constants, and letters a, b, c or d as pointer variables.

Input
The first line of the input file contains integer number N (1 ≤ N ≤ 30). N lines follow. Each of the following lines contains exactly one operator of one of four described types. Each operator finished with symbol ";" (semicolon). Input file contains no blanks. You may assume that before executing of this program pointers a, b, c, d were declared, the memory was allocated for them, and memory areas pointed by them were filled with 0.

Output
Print to the output file numbers that will be printed by Pete's program.

Example(s)
sample input
sample output
10 
writeln(a^); 
a^:=7; 
b^:=a^; 
writeln(b^); 
c:=a; 
c^:=5; 
writeln(a^); 
a:=b; 
writeln(a^); 
a^:=a^; 
0 
7 
5 
7 

sample input
sample output
3 
a:=b; 
b^:=3; 
writeln(a^); 
3

=================
p359.ans1
======================
0 
7 
5 
7 

=================
p359.in1
======================
10 
writeln(a^); 
a^:=7; 
b^:=a^; 
writeln(b^); 
c:=a; 
c^:=5; 
writeln(a^); 
a:=b; 
writeln(a^); 
a^:=a^; 

=================
