(* Μιχάλης Γαλιανάκης (2ο ΤΕΕ Ρεθύμνου) *)

program friktories(input,output) ;
const
  stath=25 ;
  
type
  typos=0..1000000 ;
  egrafi=record
    a:byte ;
    syn:typos ;
  end ;

var
  ar1:text ;
  pin:array[1..stath]of egrafi ;
  backup:egrafi ;
  a,w,i:byte ;
  fr:string ;
 
begin
  for i:=1 to stath do
    begin
      pin[i].a:=i+127 ;
      pin[i].syn:=0 ;
    end ;
  assign(ar1,'friktories.in') ;
  reset(ar1) ;
  while not eof(ar1) do
    begin
      repeat
        read(ar1,fr) ;
        w:=length(fr) ;
        for i:=1 to w do
          begin
            a:=ord(fr[i]) ;
            if (a<128)or(a>151) then
              begin
                if a=32 then
                  a:=152
                else
                  a:=0 ;
              end ;
            if a<>0 then
              pin[a-127].syn:=pin[a-127].syn+1 ;
          end ;
      until w<>255 ;
      readln(ar1) ;
    end ;
  close(ar1) ;
  w:=1 ;
  repeat
    w:=w+1 ;
    a:=1 ;
    for i:=stath downto w do
      if pin[i-1].syn<pin[i].syn then
        begin
          a:=0 ;
          backup:=pin[i] ;
          pin[i]:=pin[i-1] ;
          pin[i-1]:=backup ;
        end ;
  until (a=1)or(w=stath) ;
  assign(ar1,'friktories.out') ;
  rewrite(ar1) ;
  for i:=1 to stath do
    begin
      if pin[i].a=152 then
      pin[i].a:=32 ;
      writeln(ar1,chr(pin[i].a),' ',pin[i].syn);
    end ;
  close(ar1) ;
  halt(0) ;
end.

/* Ιωάννης Χατζημίχος (8ο ΓΕΛ Λαρίσης) */
      
#include <stdio.h>
#include <stdlib.h>
#define MSIZE 1000000

int cnt[26];
char a[MSIZE+1];

int main(void) {
  freopen("friktories.in", "r", stdin);
  freopen("friktories.out", "w", stdout);
  unsigned char c;
  int i, j, vis=0, m;
  cnt[25] = -1;
  
  while(gets(a)) {
    for (i=0; a[i]!='\0'; i++) {
      c = a[i];
      if ( c >= 128 && c <= 151 ) cnt[c-128]++;
      else if ( c == 32 ) cnt[24]++;
    }
  }
  
  for (i=0; i<25; i++) {
    m = 25;
    for (j=0; j<25; j++) {
     if ( ( vis|(1<<j) ) != vis && cnt[j] > cnt[m] ) m = j;
    }
    vis |= (1<<m);
    printf("%c %d\n", (m==24?' ':m+128), cnt[m]);
  }
  
  return 0;
}

/* Άγγελος Καθαρόπουλος (Αρσάκειο ΓΕΛ Θεσσαλονίκης) */
     
#include <stdio.h>

struct freq
{
  int f;
  unsigned char ch;
};

void mySort(freq *table,int size);


int main ()
{
  FILE * frikin;
  FILE * frikout;
  frikin = fopen("friktories.in","rb");
  frikout = fopen("friktories.out","w");
  if (frikin == NULL || frikout == NULL) 
  { 
    perror("Couldn't open a file"); 
    return -1; 
  }
 
  freq myChars[25];
  for (int i = 0; i < 25; i++) { myChars[i].f = 0;
    myChars[i].ch=i+128; }
 
  myChars[24].ch = 32;
  long size,res;
  unsigned char *container;
  fseek(frikin,0,SEEK_END);
  size = ftell(frikin);
  rewind(frikin);
  container = new unsigned char[size];
  if (container == NULL) {fclose(frikout); fclose(frikin);
    perror("Error allocating the memory needed to read the file"); return -1; }

  res = fread(container,1,size,frikin);
  if (res != size) 
  {
    fclose(frikout); fclose(frikin); 
    delete [] container; 
    perror("Error reading file into memory");
    return -1; 
  }

  fclose(frikin);
  for (unsigned char *temp = container; *temp; temp++)
  {
    if (*temp < 152 && *temp > 127)
    {
      myChars[(*temp)-128].f++;
    }
    else if (*temp == 32)
    {
      myChars[24].f++;
    }
  }
  mySort(myChars,25);
  for (int i = 0; i < 25; i++) 
  { 
    fprintf(frikout,"%c %d\n",myChars[i].ch,myChars[i].f); 
  }
  delete [] container;
  fclose(frikout);
  return 0;
}


void mySort(freq *table, int size)
{
  unsigned short swap = 1;
  freq temp;
  while (swap)
  {
    swap = 0;
    for (int i = 0; i < size-1; i++)
    {
      if (table[i].f < table[i+1].f)
      {
        temp = table[i];
        table[i] = table[i+1];
        table[i+1] = temp;
        swap = 1;
      }
    }
  }
}

(* ΔΗΜΗΤΡΗΣ ΜΟΥΔΗΛΟΣ ΓΕΛ ΑΝΑΒΥΣΣΟΥ *)
     
Program sabotage;
var
  width,height,mines,mine_x,mine_y,i:longint;
  start_x,start_y,end_x,end_y: longint;
  map:array [1..1000,1..1000] of longint;
  c_x:array[1..10000] of longint ;
  c_y:array[1..10000] of longint ;
  t_x:array[1..10000] of longint;
  t_y:array[1..10000] of longint ;
  N,temp_step,step:longint;
  x,y,tx,ty:longint;
  ok:boolean;
  fdata,fdata2:text;

Begin
  assign (fdata,'sabotage.in');
  reset (fdata);
  read (fdata,width);
  read (fdata,height);
  read (fdata,mines);
  if mines<>0 then
    begin
      for i:=1 to mines do
        begin
          read (fdata,mine_x);
          read (fdata,mine_y);
          map[mine_x,mine_y]:=-1;
        end;
    end;
    
  read (fdata,start_x);
  read (fdata,start_y);
  read (fdata,end_x);
  read (fdata,end_y);
  
  c_x[1]:=end_x;
  c_y[1]:=end_y;
  t_x[1]:=end_x;
  t_y[1]:=end_y;
  N:=1;
  temp_step:=0;
  step:=1;
  ok:=true;
  
  While (map[start_x,start_y]=0) and (ok=true) do
    begin
      ok:=false;
      For i:=1 to step do
        begin
          if c_x[i]+1<=width then
            begin
              if (map[c_x[i]+1,c_y[i]]=0) then
                begin
                  map[c_x[i]+1,c_y[i]]:=N;
                  temp_step:=temp_step+1;
                  t_x[temp_step]:=c_x[i]+1;
                  t_y[temp_step]:=c_y[i];
                  ok:=true;
                end;
            end;
          if c_x[i]-1>0 then
            begin
              if (map[c_x[i]-1,c_y[i]]=0) then
                begin
                  map[c_x[i]-1,c_y[i]]:=N;
                  temp_step:=temp_step+1;
                  t_x[temp_step]:=c_x[i]-1;
                  t_y[temp_step]:=c_y[i];
                  ok:=true;
                end;
            end;
          if c_y[i]-1>0 then
            begin
              if (map[c_x[i],c_y[i]-1]=0) then
                begin
                  map[c_x[i],c_y[i]-1]:=N;
                  temp_step:=temp_step+1;
                  t_x[temp_step]:=c_x[i];
                  t_y[temp_step]:=c_y[i]-1;
                  ok:=true;
                end;
            end;
        end;
      For i:=1 to temp_step do
        begin
          c_x[i]:=t_x[i];
          c_y[i]:=t_y[i];
        end;
      step:=temp_step;
      N:=N+1;
      temp_step:=0;
    end;
    
  close(fdata);
  map[end_x,end_y]:=0;
  assign (fdata2,'sabotage.out');
  rewrite (fdata2);
  
  if map[start_x,start_y]<>0 then
    begin
      x:=start_x;
      y:=start_y;
      writeln(fdata2,map[start_x,start_y]+1);
      writeln(fdata2,x,' ',y);
      For i:=map[start_x,start_y] downto 1 do
        begin
          tx:=x;
          ty:=y;
          ok:=false;
          if y+1<=height then
            begin
              if (ok=false) and (map[x,y+1]=i-1) then
                begin
                  ty:=y+1;
                  writeln(fdata2,x,' ',ty);
                  ok:=true;
                end;
            end;
          if x-1>0 then
            begin
              if (ok=false) and (map[x-1,y]=i-1) then
                begin
                  tx:=x-1;
                  writeln(fdata2,tx,' ',y);
                  ok:=true;
                end;
            end;
          if x+1<=width then
            begin
              if (ok=false) and (map[x+1,y]=i-1) then
                begin
                  tx:=x+1;
                  writeln(fdata2,tx,' ',y);
                  ok:=true;
                end;
            end;
          x:=tx;
          y:=ty;
        end;
    end
  else
    begin
      writeln(fdata2,'0');
    end;
  close(fdata2);
  halt(0);
End.

/* ΑΝΑΣΤΑΣΙΟΣ ΓΕΡΜΑΝΙΔΗΣ ΚΟΛΛΕΓΙΟ ΨΥΧΙΚΟΥ*/
      
#include <stdio.h>
#define MAXSIZE 1001

int Qx[MAXSIZE*MAXSIZE], Qy[MAXSIZE*MAXSIZE];
char field[MAXSIZE][MAXSIZE];

int main(void) {
  FILE *in, *out;
  
  in=fopen("sabotage.in", "r");
  out=fopen("sabotage.out", "w");
  
  int x=0, y=0, startx=0, starty=0, endx=0, endy=0,
  mines=0, minex=0, miney=0, steps=0,
  tailqx=0, tailqy=0, headqx=0, headqy=0,
  i=0, p=0, direction=0, mode=0,
  ux=0, uy=0, vx=0, vy=0, kx=0, ky=0,
  found=0, finished=0;
  
  for (i=1; i<x+1; i++) {
    for (p=1; p<y+1; p++) {
      field[i][p] = 0;
    }
  }
  
  for (i=0;i<(x+1)*(y+1);i++) {
    Qx[i]=0;
    Qy[i]=0;
  }
  
  fscanf(in,"%d %d\n", &x, &y);
  if (startx>endx) { direction=1; }
  fscanf(in,"%d\n", &mines);
  
  for (i=0;i<mines;i++) {
    fscanf(in,"%d %d\n", &minex, &miney);
    field[minex][miney]=1;
    minex=0;
    miney=0;
  }
  
  fscanf(in,"%d %d\n", &startx, &starty);
  fscanf(in,"%d %d\n", &endx, &endy);
  fclose(in);
  
  field[startx][starty]=4;
  Qx[tailqx++]=startx;
  Qy[tailqy++]=starty;
  
  while (!finished) {
    ux=Qx[headqx];
    uy=Qy[headqy];
    if (ux==0 && uy==0) {
      finished=1;
    }
    
    for (i=0;i<3 && ux!=0 && uy!=0;i++) {
      vx=0;
      vy=0;
      if (!direction) {
        if (field[ux+1][uy]==0 && ux!=x) {
          vx=ux+1;
          vy=uy;
          mode=1;
        }
        else if (field[ux][uy+1]==0 && uy!=endy) {
          vy=uy+1;
          vx=ux;
          mode=2;
        }
        else if (field[ux-1][uy]==0 && ux!=1) {
          vx=ux-1;
          vy=uy;
          mode=3;
        }
      }
      else if (direction) {
        if (field[ux-1][uy]==0 && ux!=1) {
          vx=ux-1;
          vy=uy;
          mode=3;
        }
        else if (field[ux][uy+1]==0 && uy!=endy) {
          vy=uy+1;
          vx=ux;
          mode=2;
        }
        else if (field[ux+1][uy]==0 && ux!=x) {
          vx=ux+1;
          vy=uy;
          mode=1;
        }
      }  
      
      if (vx != 0 && vy != 0 && field[vx][vy]==0) {
        field[vx][vy]=mode;
        if (vx==endx && vy==endy) {
          found=1;
          finished=1;
        }
        Qx[tailqx++]=vx;
        Qy[tailqy++]=vy;
      }
    }
    headqx++;
    headqy++;
    steps++;
  }
  
  if (!found) {
    fprintf(out,"%d\n",0);
  }
  else {
    kx=endx;
    ky=endy;
    for(i=0;i<(x+1)*(y+1);i++) {
      Qx[i]=0;
      Qy[i]=0;
    }
    
    for (i=steps+1; i>0; i--) {
      if (field[kx][ky]!=4) {
        if (field[kx][ky]==1) {
          Qx[i]=kx-1;
          Qy[i]=ky;
        }
        else if (field[kx][ky]==2) {
          Qx[i]=kx;
          Qy[i]=ky-1;
        }
        else if (field[kx][ky]==3) {
          Qx[i]=kx+1;
          Qy[i]=ky;
        }
        kx=Qx[i];
        ky=Qy[i];
      }
    }
    
    for (p=0; Qx[p]==0;p++) { ; }
    
    fprintf(out,"%d\n", steps-p+3);
    for (i=p;i<steps+2;i++) {
      fprintf(out,"%d %d\n", Qx[i], Qy[i]);
    }
    
    fprintf(out,"%d %d\n", endx, endy);
  }
  fclose(out);
  return(0);
}

/* ΙΩΑΝΝΗΣ ΧΑΤΖΗΜΙΧΟΣ 8ο ΓΕΛ ΛΑΡΙΣΑΣ */

#include <cstdio>
#include <cstdlib>
#include <queue>

using namespace std;

int moves[3][2] = { {0, -1}, {0, 1}, {1, 0} };

struct point {
  int r;
  int c;
};

int par[1001][1001], R, C;


void BFS(int r, int c) {
  queue<point> Q;
  point cur, next;
  int i;
  cur.r = r;
  cur.c = c;
  Q.push(cur);
  
  while(!Q.empty()) {
    cur = Q.front();
    Q.pop();
    for (i=0; i<3; i++) {
      next.r = cur.r + moves[i][0];
      next.c = cur.c + moves[i][1];
      if ( next.r <= 0 || next.r > R || next.c <= 0 || next.c > C ) continue;
      if ( par[next.r][next.c] ) continue;
      par[next.r][next.c] = i+1;
      Q.push(next);
    }
  }
}


int main(void) {
  FILE *in = fopen("sabotage.in", "r"), *out =
    fopen("sabotage.out", "w");
  int i, M, r, c, sr, sc;
  int mv[1000001], mvcnt = 0, mvid;
  
  fscanf(in, "%d %d %d", &C, &R, &M);
  for (i=1; i<=M; i++) {
    fscanf(in, "%d %d", &c, &r);
    par[r][c] = 8888;
  }
  
  fscanf(in, "%d %d", &sc, &sr);
  BFS(sr, sc);
  fscanf(in, "%d %d", &c, &r);
  
  if ( !par[r][c] ) {
    fprintf(out, "0\n");
  }
  else {
    while (r!=sr || c!=sc) {
      mvid = par[r][c]-1;
      mv[++mvcnt] = mvid;
      r -= moves[mvid][0];
      c -= moves[mvid][1];
    }
    fprintf(out, "%d\n%d %d\n", mvcnt+1, sc, sr);
    r = sr; c = sc;
    for (i=mvcnt; i>=1; i--) {
      r += moves[mv[i]][0];
      c += moves[mv[i]][1];
      fprintf(out, "%d %d\n", c, r);
    }
  }
  
  fclose(in); fclose(out); return 0;
}

/* Αρσένης Γεράσιμος 2ο ΓΕΛ Μοσχάτου */

#include <stdio.h>
#include <stdlib.h>
#define MAX 70000

int comp(const void *i, const void *j) {
  return *(long *)i-*(long *)j;
}


int main() {
  FILE *fin=fopen("blocks.in", "r"), *fout=fopen("blocks.out", "w");
  long blocks[MAX], n, i, j;
  fscanf(fin, "%ld", &n);
  fclose(fin);
  for (i=2, j=0; i*i<=n; i++)
    if (n%i==0) { 
      blocks[j]=i; 
      j++; 
      if (i!=n/i) { 
        blocks[j]=n/i;
        j++; 
      } 
    }
  blocks[j]=1; j++;
  qsort(blocks, j, sizeof(long), comp);
  fprintf(fout, "%ld\n", j);
  for (i=0; i<j; i++)
    fprintf(fout, "%ld\n", blocks[i]);
  fclose(fout);
  return 0;
}

/* Παναγιωτάκος Γεώργιος 1ο ΓΕΛ Σπάρτης */
     
#include <iostream>
#include <fstream>
#include <list>

using namespace std;

int n,m1,m2;
class Pt 
{
  public:
  int x,y;
};

bool operator<(Pt a,Pt b)
{
  if(a.x==b.x)
    return a.y<b.y;
  else
    return a.x<b.x;
}

list<Pt> L;

int main()
{
  //input
  ifstream fin("sonar.in");
  ofstream fout("sonar.out");
  fin >> n >> m1 >> m2;
  //
  //main prog
  int u,i;
  Pt a;

  for(u=0;u<m1;u++)
  {
    fin >> a.x >> i;
    a.y=n+1-i;
    L.push_back(a);
  }
  for(u=0;u<m2;u++)
  {
    fin >> a.y >> i;
    a.x=n+1-i;
    L.push_back(a);
  }
  L.sort();
  Pt last;
  last.x=-1;
  last.y=-1;
  list<Pt>::iterator l;
  for(l=L.begin();l!=L.end();l++)
  {
    if((*l).x==last.x && (*l).y==last.y)
    { l=L.erase(l);
      l--;
      continue;
    }
    last.x=(*l).x;
    last.y=(*l).y;
  }
  fout << L.size() << "\n";
  for(l=L.begin();l!=L.end();l++)
    fout << (*l).x << " " << (*l).y << "\n";
  return 0;
}

/* Dimitris Fotakis
   Nikolaos S. Papaspyrou */
  
#define DEBUG
#ifdef DEBUG
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...) do ; while(0)
#define NDEBUG
#endif
 
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <time.h>
#include <sys/types.h>
#define NILL (-1)
#define INF ((long) (LONG_MAX))
#define NONE (-1)
#define VISITED 0
#define UNVISITED 1
#define EXPLORED 2

  
void randomize ()
{
  time_t t1;
  (void) time(&t1);
  srand((long) t1); /* use time in seconds to set the seed */
}

/* Implements a FIFO queue for use with BFS */
typedef struct _elem {
  int id;
  struct _elem *next;
} elem;
elem *head = NULL, *tail = NULL;


void addToQueue (int v)
{
  elem *last;
  if ((last = (elem *)malloc(sizeof(elem))) == NULL) {
    fprintf(stderr, "Out of memory!\n");
    exit(1);
  }
  last->id = v;
  last->next = NULL;
  if (tail != NULL) tail->next = last;
  tail = last;
  if (head == NULL) head = last;
}


int extractFromQueue ()
{
  elem *first;
  int res;
  if (head == NULL) return(NILL);
  first = head;
  res = first->id;
  head = first->next;
  if (head == NULL) tail = NULL;
  free(first);
  return res;
}

/* Data type definitions for adjacency list */
typedef struct _edge {
  int id;
  struct _edge *next;
} Edge;

typedef struct _node {
  Edge *head;
  Edge *tail;
  int prevInCycle;
  int nextInCycle;
  int inCycle;
  int degree;
} Node;

typedef Node * List;

/* Creates an edge */

Edge *initEdge (int id)
{
  Edge *e;
  if ((e =(Edge *)malloc(sizeof(Edge))) == NULL) {
    fprintf(stderr, "Out of memory!\n");
    exit(1);
  }
  e->next = NULL;
  e->id = id;
  return e;
}

/* Reads a graph from filename and creates its adjacency list */
/* Initializes N (#vertices) and M (#edges) and returns the list */

List readGraph(FILE *fp, int *N, int *M)
{
  Edge *lastV1, *lastV2;
  int i, n = 0, v1, v2;
  List G;
  fscanf(fp, "%d\n", M);
  if ((G = (List) malloc((*M)*sizeof(Node))) == NULL) {
    fprintf(stderr, "Out of memory!\n");
    exit(1);
  }
  for (i = 0; i < *M; i++) {
    G[i].head = G[i].tail = NULL;
    G[i].nextInCycle = G[i].prevInCycle = NONE;
    G[i].degree = G[i].inCycle = 0;
  }
  for (i = 0; i < *M; i++) {
    fscanf(fp, "%d %d\n", &v1, &v2);
    if (n < v1) n = v1;
    if (n < v2) n = v2;
    v1--; v2--;
    lastV1 = initEdge(v2); G[v1].degree++;
    lastV2 = initEdge(v1); G[v2].degree++;
    if (G[v1].head == NULL)
      G[v1].head = G[v1].tail = lastV1;
    else
      G[v1].tail = G[v1].tail->next = lastV1;
    if (G[v2].head == NULL)
      G[v2].head = G[v2].tail = lastV2;
    else
      G[v2].tail = G[v2].tail->next = lastV2;
  }
  *N = n;
  if ((G = (List) realloc(G, n*sizeof(Node))) == NULL) {
    fprintf(stderr, "Error in realloc!\n");
    exit(1);
  }
  return G;
}


bool degree_lt_2 (List G, int N)
{
  int i;
  for (i = 0; i < N; i++)
    if (G[i].degree < 2)
      return true;
  return false;
}


bool not_connected (List G, int N)
{
  int s, cc = 0, v;
  Edge *e;
  int *m;
  if ((m = (int *) malloc(N*sizeof(int))) == NULL) {
    fprintf(stderr, "Out of memory!\n");
    exit(1);
  }
  for (s = 0; s < N; s++)
    m[s] = UNVISITED;
  for (s = 0; s < N; s++) {
    if (m[s] == EXPLORED) continue;
    addToQueue(s);
    m[s] = VISITED; cc++;
    while ((v = extractFromQueue()) != NILL) {
      m[v] = EXPLORED;
      for (e = G[v].head; e != NULL; e = e->next)
        if (m[e->id] == UNVISITED) {
          addToQueue(e->id);
          m[e->id] = VISITED;
        }
    }
  }
  return cc > 1;
}


int extension_rotation (List G, int N)
{
  long iter, maxIter = (long) (((double) N)*(pow(log((double)N), 4)));
  int inVert = 1, cur, last, rotv, i, k, ofs, tmp, first;
  Edge *p;
  cur = rand() % N;
  G[cur].inCycle = 1;
  first = cur;
  for (iter=0; inVert <= N && iter < maxIter; iter++) {
    /* complete a Hamiltonian path to a cycle */
    if (inVert == N)
      for (p = G[cur].head; p != NULL; p = p->next)
        if (G[p->id].prevInCycle == NONE) {
          G[p->id].prevInCycle = cur;
          return(inVert+1);
        }
    /* extension phase */
    for (p = G[cur].head, k = 0; !k && p != NULL; p = p->next)
      if (G[p->id].inCycle == 0) {
        G[p->id].inCycle = 1;
        G[p->id].prevInCycle = cur;
        G[cur].nextInCycle = p->id;
        cur = p->id;
        inVert++;
        k = 1;
      }
    /* rotation phase */
    if (!k) {
      do {
        ofs = (rand() % G[cur].degree);
        for (p = G[cur].head; ofs > 0; ofs--)
          p = p->next;
        rotv = p->id;
      } while (rotv == G[cur].prevInCycle);
      if (rotv == first) {
        first = G[rotv].nextInCycle;
        G[rotv].nextInCycle = NONE;
        G[rotv].prevInCycle = cur;
        G[cur].nextInCycle = rotv;
        G[first].prevInCycle = NONE;
        cur = rotv;
      }
      else {
        last = G[rotv].nextInCycle;
        G[rotv].nextInCycle = cur;
        G[cur].nextInCycle = rotv;
        i = G[last].nextInCycle;
        G[last].nextInCycle = NONE;
        G[last].prevInCycle = i;
        do {
          tmp = G[i].nextInCycle;
          G[i].nextInCycle = G[i].prevInCycle;
          G[i].prevInCycle = tmp;
          i = tmp;
        } while (i != rotv);
        cur = last;
      }
    }
  }
  return inVert;
}


int main ()
{
  FILE * fin = fopen("code.in", "rt");
  FILE * fout = fopen("code.out", "wt");
  int N, M, res, i;
  int iter = 0, maxIter = 40;
  List G;
  assert(fin != NULL);
  assert(fout != NULL);
  G = readGraph(fin, &N, &M);
  if (degree_lt_2(G, N) || not_connected(G, N))
    fprintf(fout, "0\n");
  else {
    randomize();
    do {
      if ((res = extension_rotation(G, N)) == N+1) break;
      iter++;
      for (i = 0; i < N; i++) {
        G[i].nextInCycle = G[i].prevInCycle = NONE;
        G[i].inCycle = 0;
      }
    } while (iter < maxIter);
    if (res == N+1) {
      fprintf(fout, "1\n");
      for (i = G[0].nextInCycle; i != 0; i = G[i].nextInCycle)
        fprintf(fout, "%d\n", i+1);
    }
    else
      fprintf(fout, "0\n");
  }
  fclose(fin);
  fclose(fout);
  return 0;
}