#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
#include <unordered_map>
#include <map>
#define QUEUE_NOT_EMPTY 0
#define IN_QUEUE 1
#define NOT_IN_QUEUE 0
#define NO_SOLUTION 0
#define HAS_SOLUTION 1
#define STRING_END '\n'
#define IN_BOUNDARY 1
#define OVER_BOUNDARY 0
using namespace std;

const string finallFormation = "12345678x"; //问题3：此处用不用const会不会影响最终判断？

string initialFormation;

//debug
void outputFormation(string formation){
    cout << "当前局面为：" << formation << endl;
    for (int row = 0; row < 3; row ++){
        for (int column = 0; column < 3; column ++){
            cout << formation[row * 3 + column] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

void initialization(){
    //cin >> initialFormation;//问题1：如何读入字符串？
    char character;
    for (int rank = 0; rank < 9; rank ++){
        cin >> character;
        initialFormation += character;
    }
    //outputFormation(initialFormation);
}
//顺时针，起于上
int incrementX[4] = {0, 1, 0, -1};
int incrementY[4] = {-1, 0, 1, 0};
int rankOfString;

void locationToRank(int xLocation, int yLocation){
    rankOfString = 3 * yLocation + xLocation;//问题2：rank为什么模糊定义，是保留字吗？
}

int xLocation, yLocation;

void rankToLocation(int rank){
    xLocation = rank % 3;
    yLocation = rank / 3;
}

typedef pair<string, int> stringAndLength;
queue<stringAndLength> queueForStringAndLength;
unordered_map<string, int> visitedRecordOfString;//为什么map类型不匹配？
int solutionFlag;

int testBoundary(int xLocation, int yLocation){
    if (xLocation >= 0 && xLocation < 3 && yLocation >= 0 && yLocation < 3) return IN_BOUNDARY;
    else return OVER_BOUNDARY;
}

int BFS(){
    queueForStringAndLength.push({initialFormation, 0});
    visitedRecordOfString[initialFormation] = IN_QUEUE;
    int currentRank;
    int currentLength;
    while(queueForStringAndLength.empty() == QUEUE_NOT_EMPTY){
        auto currentStringAndLength = queueForStringAndLength.front();
        currentRank = currentStringAndLength.first.find('x');
        currentLength = currentStringAndLength.second;
        //outputFormation(currentStringAndLength.first);
        if(currentStringAndLength.first == finallFormation){
            solutionFlag = HAS_SOLUTION;
            break;
        }
        queueForStringAndLength.pop();
        rankToLocation(currentRank);
        for (int direction = 0; direction < 4; direction ++){
            xLocation += incrementX[direction];
            yLocation += incrementY[direction];
            if (testBoundary(xLocation, yLocation) == IN_BOUNDARY){
                locationToRank(xLocation, yLocation);
                swap(currentStringAndLength.first[rankOfString], currentStringAndLength.first[currentRank]);
                if(visitedRecordOfString.count(currentStringAndLength.first) == NOT_IN_QUEUE){
                    queueForStringAndLength.push({currentStringAndLength.first, currentLength + 1});
                    visitedRecordOfString[currentStringAndLength.first] = IN_QUEUE;
                }
                swap(currentStringAndLength.first[currentRank], currentStringAndLength.first[rankOfString]);
            }
            xLocation -= incrementX[direction];
            yLocation -= incrementY[direction];
        }
    }
    if (solutionFlag == HAS_SOLUTION) return currentLength;
    else return -1;
}

void outputSolution(){
    printf("%d", BFS());
}

int main(){
    initialization();
    outputSolution();
    return 0;
}