import tools.*;
import io.*;

class Merge extends Program {
  static final int MAXL= 100;
  void run() {
    TextReader lect= new TextReader("cuentas.dat");
    // Se crea un arreglo para mantener MAXL cuentas
    Cuenta[] cuentas= new Cuenta[MAXL];
    int n= 0;
    while (true) {
      // Se leen MAXL líneas y se colocan en el arreglo de cuentas
      int lin= 0;
      while (lin<MAXL) {
        Cuenta cue= new Cuenta(lect);
        // El último archivo producido contendrá menos de MAXL líneas
        if (lect.eofReached())
          break;
        cuentas[lin]= cue;
        lin= lin+1;
      }
      if (lin==0)
        break;
      // Se ordenan las líneas que se leyeron
      ordenarxci(cuentas, lin);
      // Se escribe el resultado en un archivo con nombre "aux"+n
      TextWriter escr= new TextWriter("aux"+n);
      int i= 0;
      while (i<lin) {
        cuentas[i].escribir(escr);
        i= i+1;
      }
      escr.close();
      // Se examina si se debe producir un nuevo archivo
      n= n+1;
    }

    TextWriter escr= new TextWriter("cuentasxci.dat");
    TextReader[] lectores= new TextReader[n];
    cuentas= new Cuenta[n];
    // Crear los lectores y leer una cuenta en cada archivo
    int i= 0;
    while (i<n) {
      lectores[i]= new TextReader("aux"+i);
      cuentas[i]= new Cuenta(lectores[i]);
      i= i+1;
    }
    // Mientras queden archivos por leer
    while (n>0) {
      // Se determina el índice de la menor cuenta en el arreglo de n cuentas
      i= buscarMin(cuentas, n);
      // Se graba en el archivo de salida
      cuentas[i].escribir(escr);
      // Leer una nueva cuenta de lectores[i]
      cuentas[i]= new Cuenta(lectores[i]);
      if (lectores[i].eofReached()) {
        // Si no hay más cuentas en ese archivo se elimina de ambos arreglo
        lectores[i].close();
        n= n-1;
        lectores[i]= lectores[n];
        cuentas[i]= cuentas[n];
      }
    }
    escr.close();
  }
  void ordenarxci(Cuenta[ ] a, int n) {
    int i= 0;
    while (i<n) {
      // Buscamos la posicion del minimo en a[i], ai+1], ..., a[n-1]
      int k= i;
      int j= i+1;
      while (j<n) {
        if (compare(a[j].ci,a[k].ci)<0)
          k= j;
        j= j+1;
      }
      // intercambiamos a[i] con a[j]
      Cuenta aux= a[i];
      a[i]= a[k];
      a[k]= aux;
      i= i+1;
    }
  }
  int buscarMin(Cuenta[] a, int n) {
    int min= 0;
    int i= 1;
    while (i<n) {
      if (compare(a[i].ci,a[min].ci)<0)
        min= i;
      i= i+1;
    }
    return min;
  }
}