#include<iostream>

#include<string>

#include<cmath>

#include<cstring>

#include<vector>

#include<map>

#include<set>

#include<algorithm>

#include<queue>

#include<stack>

#include<sstream>

#include<cstdio>

#define INF 0x3f3f3f3f

//const int maxn = 1e6 + 5;

const double PI = acos(-1.0);

typedef long long ll;

using namespace std;

const  int mod1 = 1e5 + , mod2 = 1e6 + ;

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

bool flag;

int ans;

struct Node {

    int key, step;

    bool head;

    Node* next;

    Node() { key = step = head = ; next = NULL; }

}Hash[mod1+];

struct CB {

    int value[][];

    int spx, spy, step;

    void init() {

        value[][] = ;

        value[][] = ;

        value[][] = ;

        value[][] = ;

        value[][] = ;

        value[][] = ;

        value[][] = ;

        value[][] = ;

        value[][] = ;

        spx = ;

        spy = ;

    }

    bool operator ==(const CB& x)const {

        for (int i = ; i < ; i++) {

            for (int j = ; j < ; j++) {

                if (value[i][j] != x.value[i][j]) return false;

            }

        }

        return true;

    }

}start,goal;

bool   Querry(const CB& x, bool head) {

    int num = ;

    int sum1, sum2;

    for (int i = ; i < ; i++) {

        for (int j = ; j < ; j++) num = num *  + x.value[i][j];

    }

    sum1 = num % mod1, sum2 = num % mod2;

    if (!Hash[sum1].key) {

        Hash[sum1].key = sum2;

        Hash[sum1].head = head;

        Hash[sum1].step = x.step;

        return true;

    }

    if (Hash[sum1].key == sum2) {

        if (head != Hash[sum1].head) {

            flag = true;

            ans = x.step + Hash[sum1].step;

        }

        return false;

    }

    else {

        Node* now = &Hash[sum1];

        while (now->next) {

            now = now->next;

            if (now->key == sum2) {

                if (head != now->head) {

                    flag = true;

                    ans = now->step + x.step;

                }

                return false;

            }

        }

        Node* newnode = new Node;

        newnode->key = sum2;

        newnode->head = head;

        now->next = newnode;

        return true;

    }

}

void bfs() {

    queue<CB> q1;

    queue<CB> q2;

    start.step = goal.step = ;

    q1.push(start);

    q2.push(start);

    while () {

        if (q1.size() > q2.size()) {

            CB now = q2.front();

            q2.pop();

            for (int i = ; i < ; i++) {

                int xx = now.spx + dx[i], yy = now.spy + dy[i];

                if (xx <  || xx >>  || yy <  || yy>) continue;

                CB wib = now;

                wib.step = now.step + ;

                wib.spx = xx, wib.spy = yy;

                swap(wib.value[xx][yy], wib.value[now.spx][now.spy]);

                if (Querry(wib, )) q2.push(wib);

                if (flag) return;

            }

        }

        else {

            CB now = q1.front();

            q1.pop();

            for (int i = ; i < ; i++) {

                int xx = now.spx + dx[i], yy = now.spy + dy[i];

                if (xx <  || xx> || yy <  || yy>) continue;

                CB wib = now;

                swap(wib.value[xx][yy], wib.value[now.spx][now.spy]);

                wib.spx = xx, wib.spy = yy;

                wib.step = now.step + ;

                if (Querry(wib, )) q1.push(wib);

                if (flag) return;

            }

        }

        if (flag) return;

    }

}

int main() {

    char ch;

    for (int i = ; i < ; i++) {

        for (int j = ; j > ; j++) {

            scanf("%c", &ch);

            if (ch == '') start.spx = i, start.spy = j;

            start.value[i][j] = ch - '';

        }

    }

    goal.init();

    if (goal == start) {

        printf("");

    }

    else {

        bfs();

        printf("%d", ans);

    }

    return ;

}