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

typedef struct {
    int time;
    int row;
    int col;
} Node;

typedef struct {
    Node* heap;
    int size;
    int capacity;
} PriorityQueue;

PriorityQueue* createPQ(int capacity) {
    PriorityQueue* pq = (PriorityQueue*)malloc(sizeof(PriorityQueue));
    pq->heap = (Node*)malloc(sizeof(Node) * capacity);
    pq->size = 0;
    pq->capacity = capacity;
    return pq;
}

void swap(Node* a, Node* b) {
    Node temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(PriorityQueue* pq, int index) {
    if (index == 0) return;
    int parent = (index - 1) / 2;
    if (pq->heap[parent].time > pq->heap[index].time) {
        swap(&pq->heap[parent], &pq->heap[index]);
        heapifyUp(pq, parent);
    }
}

void heapifyDown(PriorityQueue* pq, int index) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int smallest = index;
    
    if (left < pq->size && pq->heap[left].time < pq->heap[smallest].time) {
        smallest = left;
    }
    if (right < pq->size && pq->heap[right].time < pq->heap[smallest].time) {
        smallest = right;
    }
    
    if (smallest != index) {
        swap(&pq->heap[smallest], &pq->heap[index]);
        heapifyDown(pq, smallest);
    }
}

void push(PriorityQueue* pq, int time, int row, int col) {
    if (pq->size >= pq->capacity) return;
    
    pq->heap[pq->size].time = time;
    pq->heap[pq->size].row = row;
    pq->heap[pq->size].col = col;
    heapifyUp(pq, pq->size);
    pq->size++;
}

Node pop(PriorityQueue* pq) {
    Node result = pq->heap[0];
    pq->heap[0] = pq->heap[pq->size - 1];
    pq->size--;
    heapifyDown(pq, 0);
    return result;
}

int isEmpty(PriorityQueue* pq) {
    return pq->size == 0;
}

void freePQ(PriorityQueue* pq) {
    free(pq->heap);
    free(pq);
}

int solution(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize;
    int n = gridColSize[0];
    
    // Check if we can move initially
    if (grid[0][1] > 1 && grid[1][0] > 1) {
        return -1;
    }
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    // Dijkstra's algorithm
    PriorityQueue* pq = createPQ(10000);
    push(pq, 0, 0, 0);  // (time, row, col)
    int visited[100][100];
    memset(visited, 0, sizeof(visited));
    
    while (!isEmpty(pq)) {
        Node current = pop(pq);
        int time = current.time;
        int row = current.row;
        int col = current.col;
        
        if (visited[row][col]) {
            continue;
        }
        visited[row][col] = 1;
        
        // Check if we reached the destination
        if (row == m - 1 && col == n - 1) {
            freePQ(pq);
            return time;
        }
        
        for (int i = 0; i < 4; i++) {
            int nr = row + directions[i][0];
            int nc = col + directions[i][1];
            if (nr >= 0 && nr < m && nc >= 0 && nc < n && !visited[nr][nc]) {
                int next_time = time + 1;
                
                // If we arrive before the required time, we need to wait
                if (next_time < grid[nr][nc]) {
                    int diff = grid[nr][nc] - next_time;
                    // If diff is odd, we need one extra move to end up at the target cell
                    if (diff % 2 == 1) {
                        next_time = grid[nr][nc] + 1;
                    } else {
                        next_time = grid[nr][nc];
                    }
                }
                
                push(pq, next_time, nr, nc);
            }
        }
    }
    
    freePQ(pq);
    return -1;
}

void parseGrid(const char* str, int*** grid, int* rows, int* cols) {
    // Count rows
    *rows = 0;
    const char* p = str;
    while (*p) {
        if (*p == '[' && *(p+1) != '[') (*rows)++;
        p++;
    }
    
    // Count cols from first row
    *cols = 0;
    p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        (*cols)++;
        while (*p >= '0' && *p <= '9') p++;
    }
    
    // Allocate grid
    *grid = (int**)malloc(*rows * sizeof(int*));
    for (int i = 0; i < *rows; i++) {
        (*grid)[i] = (int*)malloc(*cols * sizeof(int));
    }
    
    // Parse values
    p = str;
    int row = 0;
    while (*p && row < *rows) {
        while (*p && *p != '[') p++;
        if (*p == '[') p++;
        
        int col = 0;
        while (*p && *p != ']' && col < *cols) {
            while (*p == ' ' || *p == ',') p++;
            if (*p == ']' || *p == '\0') break;
            (*grid)[row][col] = (int)strtol(p, (char**)&p, 10);
            col++;
        }
        row++;
        if (*p == ']') p++;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Extract grid string from JSON
    char* gridStart = strstr(line, "[[")+1;
    char* gridEnd = strstr(gridStart, "]]") + 2;
    *gridEnd = '\0';
    
    int** grid;
    int rows, cols;
    parseGrid(gridStart, &grid, &rows, &cols);
    
    int* gridColSize = (int*)malloc(rows * sizeof(int));
    for (int i = 0; i < rows; i++) {
        gridColSize[i] = cols;
    }
    
    int result = solution(grid, rows, gridColSize);
    printf("%d\n", result);
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    return 0;
}