#include <iostream>
#include <string>
#include <vector>

using namespace std;

typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<VVVI> VVVVI;
typedef pair<int,int> PII;
typedef vector<PII> VPII;
typedef vector<VPII> VVPII;
typedef vector<VVPII> VVVPII;

char value[4][3] = {
  { '7', '8', '9' },
  { '4', '5', '6' },
  { '1', '2', '3' },
  { '0', '0', ' ' }
};

bool valid_position (int r, int c){
  return (r >= 0 && r < 4 &&
	  c >= 0 && c < 3 &&
	  !(r == 3 && c == 2));
}

int main(){
  string s;

  VVVPII next_position (4, VVPII (3));

  // compute all valid next positions

  for (int row = 0; row < 4; row++){
    for (int col = 0; col < 3; col++){
      if (valid_position (row, col)){
	if (valid_position (row+1, col)) next_position[row][col].push_back (make_pair (row+1,col));
	if (valid_position (row-1, col)) next_position[row][col].push_back (make_pair (row-1,col));
	if (valid_position (row, col+1)) next_position[row][col].push_back (make_pair (row,col+1));
	if (valid_position (row, col-1)) next_position[row][col].push_back (make_pair (row,col-1));
      }
    }
  }

  while (getline (cin, s)){
    if (s == "eof") break;
    
    VVVVI digits_consumed (4, VVVI (3, VVI (4, VI (3, -1))));

    digits_consumed[1][0][1][1] = 0;

    int time = 0;
    while (true){

      // check for termination

      bool done = false;
      for (int left_row = 0; left_row < 4; left_row++){
	for (int left_col = 0; left_col < 3; left_col++) if (valid_position (left_row, left_col)){
	  for (int right_row = 0; right_row < 4; right_row++){
	    for (int right_col = left_col+1; right_col < 3; right_col++) if (valid_position (right_row, right_col)){
	      if (digits_consumed[left_row][left_col][right_row][right_col] == s.length()) done = true;
	    }
	  }
	}
      }
      if (done) break;      

      VVVVI new_digits_consumed = digits_consumed;

      // for all possible current positions of fingers

      for (int left_row = 0; left_row < 4; left_row++){
	for (int left_col = 0; left_col < 3; left_col++) if (valid_position (left_row, left_col)){
	  for (int right_row = 0; right_row < 4; right_row++){
	    for (int right_col = left_col+1; right_col < 3; right_col++) if (valid_position (right_row, right_col)){
	      int curr_position = digits_consumed[left_row][left_col][right_row][right_col];
	      
	      if (curr_position >= 0){

		// consider moving both fingers

		for (int i = 0; i < next_position[left_row][left_col].size(); i++){
		  int new_left_row = next_position[left_row][left_col][i].first;
		  int new_left_col = next_position[left_row][left_col][i].second;

		  for (int j = 0; j < next_position[right_row][right_col].size(); j++){
		    int new_right_row = next_position[right_row][right_col][j].first;
		    int new_right_col = next_position[right_row][right_col][j].second;		    

		    if (new_left_col < new_right_col){
		      
		      new_digits_consumed[new_left_row][new_left_col][new_right_row][new_right_col] = 
			max (new_digits_consumed[new_left_row][new_left_col][new_right_row][new_right_col],
			     curr_position);
		    }
		  }
		}

		// consider moving only the left finger
		
		for (int i = 0; i < next_position[left_row][left_col].size(); i++){
		  int new_left_row = next_position[left_row][left_col][i].first;
		  int new_left_col = next_position[left_row][left_col][i].second;

		  if (new_left_col < right_col){

		    new_digits_consumed[new_left_row][new_left_col][right_row][right_col] = 
		      max (new_digits_consumed[new_left_row][new_left_col][right_row][right_col],
			   curr_position + (s[curr_position] == value[right_row][right_col]));
		  }
		  
		}

		// consider moving only the right finger

		for (int i = 0; i < next_position[right_row][right_col].size(); i++){
		  int new_right_row = next_position[right_row][right_col][i].first;
		  int new_right_col = next_position[right_row][right_col][i].second;

		  if (left_col < new_right_col){

		    new_digits_consumed[left_row][left_col][new_right_row][new_right_col] = 
		      max (new_digits_consumed[left_row][left_col][new_right_row][new_right_col],
			   curr_position + (s[curr_position] == value[left_row][left_col]));
		  }
		    
		}

		// consider moving neither finger

		new_digits_consumed[left_row][left_col][right_row][right_col] = 
		  max (new_digits_consumed[left_row][left_col][right_row][right_col],
		       curr_position + (s[curr_position] == value[left_row][left_col] || 
					s[curr_position] == value[right_row][right_col]));
	      }
	    }
	  }
	}
      }

      digits_consumed = new_digits_consumed;
      
      time++;
    }

    cout << time << endl;
  }  
}