class CalcolatoreBinario {

  // Attributi per la gestione della memoria
  private long memoria;
  private long ultimoRisultato;
  // Attributo per la segnalazione di errori in fase di conversione
  private boolean erroreConversione;

  // Costruttore
  public CalcolatoreBinario() {
    memoria = 0;
    erroreConversione = false;
  }

  ///////////////////////////////////////////////////////////////////////////
  // Metodi per le operazioni aritmetiche
  ///////////////////////////////////////////////////////////////////////////
  public String somma(String a, String b) {
    long x = daBinario(a);
    long y = daBinario(b);
    return risultato(x + y);
  }
  public String sottrai(String a, String b) {
    long x = daBinario(a);
    long y = daBinario(b);
    return risultato(x - y);
  }
  public String moltiplica(String a, String b) {
    long x = daBinario(a);
    long y = daBinario(b);
    return risultato(x * y);
  }
  public String dividi(String a, String b) {
    long x = daBinario(a);
    long y = daBinario(b);
    // Nota: divisione tra interi!
    return risultato(x / y);
  }

  ///////////////////////////////////////////////////////////////////////////
  // Metodi per la gestione della memoria
  ///////////////////////////////////////////////////////////////////////////
  public void mettiInMemoria() {
    memoria = ultimoRisultato;
  }
  public void sommaInMemoria() {
    memoria += ultimoRisultato;
  }
  public String richiamaMemoria() {
    return aBinario(memoria);
  }
  public void cancellaMemoria() {
    memoria = 0;
  }

  ///////////////////////////////////////////////////////////////////////////
  // Metodi private
  ///////////////////////////////////////////////////////////////////////////
  // Questo metodo gestisce il risultato in presenza di eventuali errori
  private String risultato(long z) {
    if (erroreConversione) {
      erroreConversione = false;
      return null;
    } else {
      ultimoRisultato = z;
      return aBinario(ultimoRisultato);
    }
  }

  // Conversione da binario a decimale
  private long daBinario(String bin) {
    // Priva bin di tutti gli eventuali spazi in cima e in fondo
    String binEsatto = bin.trim();
    // La lunghezza di binEsatto è ora pari al numero di cifre significative
    int cifreSignificative = binEsatto.length();
    long dec = 0;
    // Scorre binEsatto da sinistra (bit più significativo) a destra
    // (bit meno significativo), cioè dall'inizio alla fine della stringa
    for (int i = 0; i < cifreSignificative; i++) {
      if (binEsatto.charAt(i) != '1' && binEsatto.charAt(i) != '0') {
        // Se il carattere non è 1 oppure 0, segnala un errore di conversione
        erroreConversione = true;
        return dec;
      } else if (binEsatto.charAt(i) == '1') {
        // Un '1' in posizione p a partire da sinistra vale
        // 2^(cifresignificative - i)
        dec += Math.round(Math.pow(2,(cifreSignificative - i - 1)));
      }
    }
    return dec;
  }

  // Conversione da decimale a binario
  private String aBinario(long dec) {
    StringBuffer bin = new StringBuffer("");
    while (dec > 0) {
      if ((dec % 2) == 1) {
        bin.append(1);
      } else {
        bin.append(0);
      }
      dec /= 2;
    }
    if (bin.length() == 0) {
      bin.append(0);
    } else {
      // Nota: bin contiene il numero binario con le cifre meno significative
      // a sinistra (sono le prime ad essere inserite): è necessario rovesciarlo
      bin.reverse();
    }
    return bin.toString();
  }

}