#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// --- Data Structures ---

typedef struct {
    int row, col, steps;
} Node;

typedef struct {
    Node *data;
    int front, back, capacity;
} Queue;

Queue *createQueue(int capacity) {
    Queue *q = malloc(sizeof(Queue));
    if (!q) return NULL;
    q->data = malloc(sizeof(Node) * capacity);
    q->front = 0;
    q->back = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue *q, int row, int col, int steps) {
    if (q->back < q->capacity) {
        q->data[q->back++] = (Node){row, col, steps};
    }
}

Node dequeue(Queue *q) {
    return q->data[q->front++];
}

int queueEmpty(Queue *q) {
    return q->front == q->back;
}

void freeQueue(Queue *q) {
    if (q) {
        free(q->data);
        free(q);
    }
}

// --- Solution Logic (BFS) ---

int solution(char **maze, int m, int n, int startRow, int startCol) {
    if (m == 0 || n == 0) return -1;

    // Visited array to prevent loops
    int *visited = calloc(m * n, sizeof(int));
    if (!visited) return -1;
    
    Queue *q = createQueue(m * n);
    if (!q) { free(visited); return -1; }

    enqueue(q, startRow, startCol, 0);
    visited[startRow * n + startCol] = 1;

    int dirs[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

    while (!queueEmpty(q)) {
        Node cur = dequeue(q);
        int row = cur.row;
        int col = cur.col;
        int steps = cur.steps;

        // Check if this is an exit (boundary cell that is NOT the start)
        // Note: The problem usually defines an exit as an empty cell '.' on the boundary
        if ((row == 0 || row == m-1 || col == 0 || col == n-1) && 
            (row != startRow || col != startCol)) {
            
            free(visited);
            freeQueue(q);
            return steps;
        }

        // Explore neighbors
        for (int d = 0; d < 4; d++) {
            int nr = row + dirs[d][0];
            int nc = col + dirs[d][1];

            // Check bounds
            if (nr >= 0 && nr < m && nc >= 0 && nc < n) {
                // Check walls and visited
                if (maze[nr][nc] == '.' && !visited[nr * n + nc]) {
                    visited[nr * n + nc] = 1;
                    enqueue(q, nr, nc, steps + 1);
                }
            }
        }
    }

    free(visited);
    freeQueue(q);
    return -1;
}

// --- Parsing Logic ---

// Parse a string like [["+","."], [".","."]] into a char** array
// This parser is robust against spaces, quotes, and commas.
char **parseMaze(char *line, int *outM, int *outN) {
    // 1. Calculate number of rows (count occurrences of '[')
    // We start m at -1 because the outer array has a '[' as well.
    int m = -1;
    char *p = line;
    while (*p) {
        if (*p == '[') m++; 
        p++;
    }
    
    if (m <= 0) { *outM = 0; *outN = 0; return NULL; }

    char **maze = malloc(sizeof(char*) * m);
    int row = 0;
    int col = 0;
    int maxCol = 0;

    // 2. Parse content
    // Find the first opening bracket
    p = strchr(line, '['); 
    if (!p) return NULL;
    p++; 

    // Temporary row buffer
    char rowBuf[1024]; 
    int inRow = 0;

    while (*p) {
        if (*p == '[') {
            inRow = 1;
            col = 0;
        } else if (*p == ']') {
            if (inRow) {
                // End of a row
                maze[row] = malloc(col * sizeof(char));
                memcpy(maze[row], rowBuf, col);
                if (col > maxCol) maxCol = col;
                row++;
                inRow = 0;
            }
        } else if (inRow) {
            // Only capture valid maze characters
            if (*p == '+' || *p == '.') {
                rowBuf[col++] = *p;
            }
        }
        p++;
    }

    *outM = row;
    *outN = maxCol;
    return maze;
}

void parseEntrance(char *line, int *row, int *col) {
    // Look for format [row,col]
    char *start = strchr(line, '[');
    if (start) {
        sscanf(start + 1, "%d,%d", row, col);
    } else {
        *row = 0; *col = 0;
    }
}

// --- Main ---

int main(void) {
    char line[100000];

    // Read Maze Line
    if (!fgets(line, sizeof(line), stdin)) return 0;
    int m, n;
    char **maze = parseMaze(line, &m, &n);

    // Read Entrance Line
    if (!fgets(line, sizeof(line), stdin)) return 0;
    int startRow, startCol;
    parseEntrance(line, &startRow, &startCol);

    // Solve
    if (maze) {
        int result = solution(maze, m, n, startRow, startCol);
        printf("%d\n", result);

        // Cleanup
        for (int i = 0; i < m; i++) free(maze[i]);
        free(maze);
    } else {
        printf("-1\n");
    }

    return 0;
}