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

#define MAX_QUEUE 20000
#define MAX_STATES 10000

typedef struct {
    char state[5];
    int steps;
} QueueItem;

typedef struct {
    char states[MAX_STATES][5];
    int count;
} StateSet;

bool contains(StateSet* set, char* state) {
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->states[i], state) == 0) {
            return true;
        }
    }
    return false;
}

void addState(StateSet* set, char* state) {
    if (!contains(set, state) && set->count < MAX_STATES) {
        strcpy(set->states[set->count], state);
        set->count++;
    }
}

void getNeighbors(char* state, char neighbors[][5], int* count) {
    *count = 0;
    for (int i = 0; i < 4; i++) {
        int digit = state[i] - '0';
        // Rotate up
        strcpy(neighbors[*count], state);
        neighbors[*count][i] = '0' + (digit + 1) % 10;
        (*count)++;
        // Rotate down
        strcpy(neighbors[*count], state);
        neighbors[*count][i] = '0' + (digit + 9) % 10;
        (*count)++;
    }
}

int solution(char deadends[][5], int deadendCount, char* target) {
    StateSet dead = {0};
    for (int i = 0; i < deadendCount; i++) {
        addState(&dead, deadends[i]);
    }
    
    if (contains(&dead, "0000")) {
        return -1;
    }
    if (strcmp(target, "0000") == 0) {
        return 0;
    }
    
    StateSet visited = {0};
    addState(&visited, "0000");
    
    QueueItem queue[MAX_QUEUE];
    int front = 0, rear = 0;
    strcpy(queue[rear].state, "0000");
    queue[rear].steps = 0;
    rear++;
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        char neighbors[8][5];
        int neighborCount;
        getNeighbors(current.state, neighbors, &neighborCount);
        
        for (int i = 0; i < neighborCount; i++) {
            if (strcmp(neighbors[i], target) == 0) {
                return current.steps + 1;
            }
            
            if (!contains(&dead, neighbors[i]) && !contains(&visited, neighbors[i])) {
                addState(&visited, neighbors[i]);
                strcpy(queue[rear].state, neighbors[i]);
                queue[rear].steps = current.steps + 1;
                rear++;
            }
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse deadends array
    char deadends[1000][5];
    int deadendCount = 0;
    char* token = strtok(line, "[],\"\n ");
    while (token != NULL && deadendCount < 1000) {
        if (strlen(token) == 4) {
            strcpy(deadends[deadendCount], token);
            deadendCount++;
        }
        token = strtok(NULL, "[],\"\n ");
    }
    
    char target[5];
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    
    int result = solution(deadends, deadendCount, target);
    printf("%d\n", result);
    
    return 0;
}