#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>

using namespace std;

char inp[300][300];
int val[300][300];
int gi[300][300];
int num;

const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};

struct gate {
    int x, y, ex, ey;
    char type;
    int value;
    int il;
};

vector<gate> gates;

void hash(int x, int y) {
    gate g;
    g.x = x;
    g.y = y;
    for (int xx = x; ; xx ++) {
        if (xx >= num || inp[xx][y] != '#') {
            g.ex = xx - 1;
            break;
        }
    }
    for (int yy = y; ; yy ++) {
        if (inp[x][yy] != '#') {
            g.ey = yy - 1;
            break;
        }
    }
    for (int i = x + 1; i < g.ex; i ++) {
        for (int j = y + 1; j < g.ey; j ++) {
            if (inp[i][j] != ' ') {
                g.type = inp[i][j];
                i = 300;
                j = 300;
            }
        }
    }
    g.il = 0;
    if (y > 0) {
        for (int i = x; i <= g.ex; i ++) {
            if (inp[i][y - 1] == '=') {
                g.il += 1;
            }
        }
    }
    if (g.type == '1') {
        g.value = 0;
    } else if (g.type == '&') {
        g.value = 1;
    } else {
        g.value = 0;
    }
    for (int xx = x; xx <= g.ex; xx ++) {
        for (int yy = y; yy <= g.ey; yy ++) {
            gi[xx][yy] = gates.size();
        }
    }
    gates.push_back(g);
}
    
void set(int x, int y, int n, int dir) {
    if (val[x][y] == -1) {
        if (inp[x][y] == ' ') {
            x /= 0;
        }
        val[x][y] = n;
        if (inp[x][y] == '0' || inp[x][y] == '1') {
            set(x, y+1, n, 0);
        } else if (inp[x][y] == '+') {
            for (int i = 0; i < 4; i ++) {
                if (x+dx[i] >= 0 && x+dx[i] < num && y+dy[i] >= 0 && inp[x+dx[i]][y+dy[i]] != '\0') {
                    if (i % 2 == 0 && (inp[x+dx[i]][y+dy[i]] == '-' || inp[x+dx[i]][y+dy[i]] == '+' || inp[x+dx[i]][y+dy[i]] == 'x' || inp[x+dx[i]][y+dy[i]] == '=')) {
                        set(x+dx[i], y+dy[i], n, i);
                    }
                    if (i % 2 == 1 && (inp[x+dx[i]][y+dy[i]] == '|' || inp[x+dx[i]][y+dy[i]] == '+' || inp[x+dx[i]][y+dy[i]] == 'x')) {
                        set(x+dx[i], y+dy[i], n, i);
                    }
                }
            }
        } else if (inp[x][y] == '-') {
            set(x, y+1, n, 0);
            set(x, y-1, n, 2);
        } else if (inp[x][y] == '|') {
            set(x+1, y, n, 1);
            set(x-1, y, n, 3);
        } else if (inp[x][y] == 'x') {
            val[x][y] = -1;
            set(x+dx[dir], y+dy[dir], n, dir);
        } else if (inp[x][y] == '=') {
            set(x, y+1, n, 0);
        } else if (inp[x][y] == 'o') {
            set(x, y+1, 1-n, 0);
        } else if (inp[x][y] == '#') {
            switch (gates[gi[x][y]].type) {
                case '1':
                    if (n == 1) {
                        gates[gi[x][y]].value = 1;
                    }
                    break;
                case '&':
                    if (n == 0) {
                        gates[gi[x][y]].value = 0;
                    }
                    break;
                case '=':
                    if (n == 1) {
                        gates[gi[x][y]].value = 1 - gates[gi[x][y]].value;
                    }
                    break;
            }
            gates[gi[x][y]].il -= 1;
            if (gates[gi[x][y]].il == 0) {
                for (int xx = gates[gi[x][y]].x; xx <= gates[gi[x][y]].ex; xx ++) {
                    int yy = gates[gi[x][y]].ey + 1;
                    if (inp[xx][yy] == 'o' || inp[xx][yy] == '=') {
                        set(xx, yy, gates[gi[x][y]].value, 0);
                    }
                }
            }
        }
    }
}

int main() {
    while (true) {
        memset(val, -1, sizeof(val));
        memset(gi, -1, sizeof(gi));
        num = 0;
        cin.getline(inp[0], 300);
        while (inp[num][0] != '*') {
            cin.getline(inp[++ num], 300);
            bool ble = false;
            for (int i = 0; i < 300; i ++) {
                if (inp[num][i] == '\n') {
                    ble = true;
                }
                if (ble) {
                    inp[num][i] = '\0';
                }
            }
        }
        if (num == 0) {
            return 0;
        }
        gates.clear();
        for (int i = 0; i < num; i ++) {
            for (int j = 0; inp[i][j] != '\0'; j ++) {
                if (inp[i][j] == '#' && gi[i][j] == -1) {
                    hash(i, j);
                }
            }
        }
        for (int i = 0; i < num; i ++) {
            for (int j = 0; inp[i][j] != '\0'; j ++) {
                if (inp[i][j] == '0') {
                    set(i, j, 0, -1);
                } else if (inp[i][j] == '1' && gi[i][j] == -1) {
                    set(i, j, 1, -1);
                }
            }
        }
        vector<pair<char, int> > res;
        for (int i = 0; i < num; i ++) {
            for (int j = 0; inp[i][j] != '\0'; j ++) {
                if (inp[i][j] >= 'A' && inp[i][j] <= 'Z') {
                    res.push_back(pair<char, int>(inp[i][j], val[i][j]));
                }
            }
        }
        sort(res.begin(), res.end());
        for (unsigned int i = 0; i < res.size(); i ++) {
            printf("%c=%d\n", res[i].first, res[i].second);
        }
        printf("\n");
    }
}