/************************************************
Grundlegende Algorithmen mit Java,
http://algorithmen-und-problemloesungen.de/
Copyright @2007-2009 by Doina Logofatu
************************************************/

import java.io.*;
import java.util.*;

public class P05Domino {
  private static final String FileInputName = "domino.in";
  private static final String FileOutputName = "domino.out";

  private static class Piece {
    int first, second;

    Piece(int first, int second) {
      this.first = first;
      this.second = second;
    }
    
    // if the second piece is reversed
    boolean fits(Piece other, boolean reversed){
      return second == (reversed ? other.second : other.first);
    }
    
    Piece reverse(){
      return new Piece( second, first );
    }
    
    public String toString() {
      return first + " " + second;     
    }    
  }

  private List<Piece> vP;
  int iMax, bit;  
  int vNext[][], v[][];

  P05Domino(List<Piece> pieces) {
    this.vP = pieces;
    this.vNext = new int[pieces.size()][2];
    this.v = new int[pieces.size()][2];
  }

  void doProcess() {
    int n = vP.size();
    v[n - 1][0] = 1;
    vNext[n - 1][0] = n;
    v[n - 1][1] = 1;
    vNext[n - 1][1] = n;
    iMax = n - 1;
    bit = 0;
    for (int i = n - 2; i >= 0; i--) {
      v[i][0] = 1;
      vNext[i][0] = n;
      v[i][1] = 1;
      vNext[i][1] = n;
      for (int j = i + 1; j < n; j++) {
        if ( vP.get(i).fits(vP.get(j), false) && v[i][0] < v[j][0] + 1) {
          v[i][0] = v[j][0] + 1;
          vNext[i][0] = j;
        }
        if (vP.get(i).fits(vP.get(j), true) && v[i][0] < v[j][1] + 1) {
          v[i][0] = v[j][1] + 1;
          vNext[i][0] = j;
        }
        if (vP.get(i).reverse().fits(vP.get(j), false) && v[i][1] < v[j][0] + 1) {
          v[i][1] = v[j][0] + 1;
          vNext[i][1] = j;
        }
        if (vP.get(i).reverse().fits(vP.get(j), true) && v[i][1] < v[j][1] + 1) {
          v[i][1] = v[j][1] + 1;
          vNext[i][1] = j;
        }
      }
      int auxMax = v[i][0] > v[i][1] ? v[i][0] : v[i][1];
      if (auxMax > v[iMax][bit]) {
        iMax = i;
        bit = v[i][0] >= v[i][1] ? 0 : 1;
      }
    }
  }

  void write(PrintStream out) {
    int aux;
    out.println(v[iMax][bit]);
    int n = (int) vP.size();
    if (0 == bit) {
      aux = vP.get(iMax).second;
      out.println(vP.get(iMax));
    } else {
      aux = vP.get(iMax).first;
      out.println(vP.get(iMax).reverse());
    }
    iMax = vNext[iMax][bit];
    while (iMax != n) {
      if (aux == vP.get(iMax).first) {
        out.println( vP.get(iMax) );
        aux = vP.get(iMax).second;
        bit = 0;
      } else {
        out.println(vP.get(iMax).reverse());
        aux = vP.get(iMax).first;
        bit = 1;
      }
      iMax = vNext[iMax][bit];
    }
  }

  public static void main(String[] args) throws IOException {
    Scanner scanner = null;
    PrintStream out = null;
    try {
      scanner = new Scanner(new File(FileInputName));
      List<Piece> vP = new ArrayList<Piece>();
      while (scanner.hasNextInt()) {
        int first = scanner.nextInt();
        if (!scanner.hasNextInt())
          break;
        vP.add(new Piece(first, scanner.nextInt()));
      }
      P05Domino domino = new P05Domino(vP);
      domino.doProcess();
      out = new PrintStream(new File(FileOutputName));
      domino.write(out);
    } finally {
      if (scanner != null) {
        scanner.close();
      }
      if (out != null) {
        out.close();
      }
    }
  }
}