diff --git a/ca/ca0800.cpp b/ca/ca0800.cpp
index 75377ca20..05bc2c32f 100755
--- a/ca/ca0800.cpp
+++ b/ca/ca0800.cpp
@@ -80,24 +80,6 @@ bool TRiparti_msk::on_field_event(TOperable_field& o, TField_event e, long jolly
         return error_box(TR("Il totale delle percentuali di riparto deve essere 100"));
     }
     break;
-  case F_SHEET:
-    if (e == fe_init)
-    {
-      TSheet_field& sf = sfield(F_SHEET);
-      TMask& sm = sf.sheet_mask();
-      const bool on = get(F_TIPO)[0] != 'C';
-      for (short id = 202; id < 214; id++)
-      {
-        if (sm.id2pos(id) > 0)
-        {
-          sf.enable_column(id, on);
-          sm.enable(id, on);
-        }
-        if (sm.id2pos(id+50) > 0)
-          sm.enable(id+50, on);
-      }
-    }
-    break;
   case F_GENFASI:
     if (e == fe_init)
     {
diff --git a/ca/ca0800a.h b/ca/ca0800a.h
index 3266cc3b6..88b1a0c99 100755
--- a/ca/ca0800a.h
+++ b/ca/ca0800a.h
@@ -1,19 +1,24 @@
 #define F_TIPO       101
 #define F_CODICE_I   102
 #define F_CODICE_B   103
-#define F_DESCRIZ_I  104
-#define F_DESCRIZ_B  105
-#define F_TIPORIP    106
-#define F_LEVEL_1    107
-#define F_LEVEL_2    108
+//le define commentate per ora non servono ma in futuro forse si (segnaposto)
+//#define F_CODICE_P   104
+//#define F_CODICE_C   105
+#define F_DESCRIZ_I  106
+#define F_DESCRIZ_B  107
+//#define F_DESCRIZ_P  108
+//#define F_DESCRIZ_C  109
+#define F_TIPORIP    110
+#define F_LEVEL_1    111
+#define F_LEVEL_2    112
 
-#define F_GRUPPO     111
-#define F_CONTO      112 
-#define F_SOTTOCONTO 113
-#define F_DESCR      114
-#define F_ANNOES     115
-#define F_INDBIL     116
-#define F_CLASSEMOV  117
+#define F_GRUPPO     113
+#define F_CONTO      114 
+#define F_SOTTOCONTO 115
+#define F_DESCR      116
+#define F_ANNOES     117
+#define F_INDBIL     118
+#define F_CLASSEMOV  119
 
 #define F_CODCDC_1   121
 #define F_CODCDC_2   122
diff --git a/ca/ca0800a.uml b/ca/ca0800a.uml
index 7baf09129..dd3350c2f 100755
--- a/ca/ca0800a.uml
+++ b/ca/ca0800a.uml
@@ -18,10 +18,10 @@ BEGIN
   FLAGS "ZP"
   ITEM "I|Interattiva"
     MESSAGE SHOW,1@|HIDE,2@
-  ITEM "C|Conversione"
-    MESSAGE SHOW,1@|HIDE,2@
   ITEM "B|Batch"
     MESSAGE SHOW,2@|HIDE,1@
+  ITEM "P|Pareggio"
+    MESSAGE SHOW,1@|HIDE,2@
   FIELD TIPO
   KEY 1
 END
@@ -56,8 +56,8 @@ BEGIN
   DISPLAY "Codice@8 " CODICE
   DISPLAY "Costo@20" CODCOSTO
   DISPLAY "Commessa@20" CODCMS
-  DISPLAY "Fase@10" CODFASE
   DISPLAY "Descrizione@50" DESCRIZ
+  DISPLAY "Fase@10" CODFASE
   OUTPUT F_CODICE_B CODICE
   OUTPUT F_DESCRIZ_B DESCRIZ
   CHECKTYPE REQUIRED
diff --git a/ca/ca2200.cpp b/ca/ca2200.cpp
index 9315a5400..0b626fb95 100755
--- a/ca/ca2200.cpp
+++ b/ca/ca2200.cpp
@@ -24,63 +24,10 @@ class TRib_movanal_msk : public TAnal_report_mask
 protected:
   virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
 
-  void save_to_ini();
-  void load_from_ini();
-
 public:
   TRib_movanal_msk();
 };
 
-void TRib_movanal_msk::save_to_ini()
-{
-  TConfig ini(CONFIG_DITTA, "ca");
-
-  // Cancella tutte le variabili di pareggio
-  int j;
-  for (j = 1; ini.remove("Pareggio", j); j++);
-
-  TSheet_field& sf = sfield(F_RIGHE);
-  const int idx = sf.cid2index(F_CODCAUS);
-
-  // Salva tutte le righe dello sheet nel formato
-  // Pareggio(1) = Causale|Costo|Commessa|Fase
-  j = 0;
-  FOR_EACH_SHEET_ROW(sf, i, row) 
-  {
-    TToken_string par = row->get(idx);  // Codice causale
-    if (!par.blank())
-    {
-      TAnal_bill bill;
-      const int flags = get_row_bill(sf, i, bill);
-      if (flags != 0)
-      {
-        if (flags & 1) par.add(bill.costo(),    1);
-        if (flags & 2) par.add(bill.commessa(), 2);
-        if (flags & 4) par.add(bill.fase(),     3);
-        ini.set("Pareggio", par, NULL, true, ++j);
-      }
-    }
-  }
-}
-
-void TRib_movanal_msk::load_from_ini()
-{
-  // Svuota lo sheet
-  TSheet_field& sf = sfield(F_RIGHE);
-  sf.destroy();
-
-  // Carica tutte le variabili di pareggio nello sheet
-  TConfig ini(CONFIG_DITTA, "ca");
-  TToken_string par;
-  for (int j = 1; ; j++)
-  {
-    par = ini.get("Pareggio", NULL, j);
-    if (par.empty_items())
-      break;
-    const TAnal_bill bill("", par.get(1), par.get(2), par.get(3));
-    set_row_bill(sf, -1, bill);
-  }
-}
 
 bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
 {
@@ -98,11 +45,7 @@ bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long j
 				return error_box(TR("La data deve appartenere all'anno selezionato"));
 		}
 		break;
-  case DLG_OK: 
-  case DLG_SAVEREC: 
-    if (e == fe_button)
-      save_to_ini(); 
-    break;
+
   default: 
     break;
   }
@@ -111,8 +54,6 @@ bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long j
 
 TRib_movanal_msk::TRib_movanal_msk() : TAnal_report_mask("ca2200a")
 {
-  create_sheet(F_RIGHE);
-  load_from_ini();
 }
 
 //--------------------------------------------------------------------
@@ -122,131 +63,145 @@ class TRib_movanal_app : public TSkeleton_application
 {
   TCache_ripartizioni _cache_rip;
   bool _definitivo;
-  TAssoc_array _caus_cms;
 
   virtual const char* extra_modules() const { return "cm"; } //deve funzionare anche per le commesse
 
 protected:
   virtual void main_loop();
 
-  bool explode_rows(const TRecord_array& input_rows, TRecord_array& output_rows, const int annoes, 
-                    const char tipomov);
-  bool pareggia_commessa(TAnal_mov& anal_mov);
+  bool elabora_righe(TAnal_mov& anal_mov, const TRecord_array& input_rows, TRecord_array& output_rows);
+  bool ripartizione(const TAnal_ripartizioni_batch& rrip, const TRectype& rec, TRecord_array& output_rows);
+  bool pareggio(TAnal_mov& anal_mov, const TAnal_ripartizioni_batch& rrip, const TRectype& rec, TRecord_array& output_rows);
 
 public:
   bool elabora_movimento(TAnal_mov& anal_mov, const bool esplodi);
 	TRib_movanal_app(){}
 };
 
-bool TRib_movanal_app::explode_rows(const TRecord_array& input_rows, TRecord_array& output_rows, 
-                                    const int annoes, const char tipomov)
+
+bool TRib_movanal_app::pareggio(TAnal_mov& anal_mov, const TAnal_ripartizioni_batch& rrip, const TRectype& rec, 
+                                TRecord_array& output_rows)
+{
+  bool ho_pareggiato = false;
+
+  TImporto totdoc(anal_mov.get_char(MOVANA_SEZIONE), anal_mov.get_real(MOVANA_TOTDOC));
+
+  const TImporto imp_riga(rec.get_char(RMOVANA_SEZIONE), rec.get_real(RMOVANA_IMPORTO));
+
+  totdoc -= imp_riga;
+  totdoc.normalize();
+  anal_mov.put(MOVANA_TOTDOC, totdoc.valore());
+  anal_mov.put(MOVANA_SEZIONE, totdoc.sezione());
+
+  //aggiunge la riga originale alle righe di output (e' un pareggio)
+  const int original_nriga = output_rows.rows() + 1;
+  TRectype* newrec = new TRectype(rec);
+  newrec->put(RMOVANA_NUMRIG, original_nriga);
+  output_rows.add_row(newrec);
+
+  //swappa la sezione e la manda al ripartitore in modo da generare righe con la sezione rovesciata rispetto a quella..
+  //..originale ed ottenere cosi' il pareggio
+  TRectype swaprec(rec);
+  swaprec.put(RMOVANA_SEZIONE, imp_riga.sezione() == 'D' ? 'A' : 'D');
+  ho_pareggiato = ripartizione(rrip, swaprec, output_rows);
+
+  //elimina il codcontoori da tutte le righe aggiunte per il pareggio
+  for (int i = output_rows.rows(); i > original_nriga; i--)
+    output_rows.row(i, false).zero(RMOVANA_CODCONTORI);
+
+  return ho_pareggiato;
+}
+
+
+bool TRib_movanal_app::ripartizione(const TAnal_ripartizioni_batch& rrip, const TRectype& rec, TRecord_array& output_rows)
+{
+  bool ho_ripartito = false;
+  // Importo totale da distribuire arrotondato ai decimali della valuta di conto
+  TGeneric_distrib distrib(rec.get_real(RMOVANA_IMPORTO), TCurrency::get_firm_dec());
+
+  // Calcolo tutte le percentuali da ripartire
+  int i;
+  const int righe_ripartizione = rrip.rows();
+  for (i = 1; i <= rrip.rows(); i++)
+    distrib.add(rrip[i].get_real(RRIP_RIPARTO));
+
+  for (i = 1; i <= righe_ripartizione; i++)
+  {
+    const real imp = distrib.get(); // Legge la quota da distribuire
+
+	  if (imp != ZERO)
+	  {
+		  TRectype* newrec = new TRectype(rec);
+		  newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1);
+		  newrec->put(RMOVANA_IMPORTO, imp);  //e la mette nella nuova riga
+		  //poi copia i valori dei campi cdc,cms,fsc,in quelli di tipo ori (nello stesso record)
+		  ca_copia_campo(rec, RMOVANA_CODCCOSTO, *newrec, RMOVANA_CODCCORI);
+		  ca_copia_campo(rec, RMOVANA_CODCMS,    *newrec, RMOVANA_CODCMSORI);
+		  ca_copia_campo(rec, RMOVANA_CODFASE,   *newrec, RMOVANA_CODFASEORI);
+		  ca_copia_campo(rec, RMOVANA_CODCONTO,  *newrec, RMOVANA_CODCONTORI);
+		  //e mette nei campi std i valori che trova nelle righe ripartizione
+		  ca_copia_campo(rrip[i], RRIP_CODCOSTO, *newrec, RMOVANA_CODCCOSTO);
+		  ca_copia_campo(rrip[i], RRIP_CODCMS,   *newrec, RMOVANA_CODCMS);
+		  ca_copia_campo(rrip[i], RRIP_CODFASE,  *newrec, RMOVANA_CODFASE);
+		  ca_copia_campo(rrip[i], RRIP_CODCONTO, *newrec, RMOVANA_CODCONTO);
+
+		  output_rows.add_row(newrec);
+      ho_ripartito = true;
+	  } //if(imp!=ZERO)...
+  } //for(i=1;i<=righe_ripartizione...
+
+  return ho_ripartito;
+}
+
+
+bool TRib_movanal_app::elabora_righe(TAnal_mov& anal_mov, const TRecord_array& input_rows, TRecord_array& output_rows)
 {
   bool ho_cambiato_qualchecosa = false;
+
+  const int annoes = anal_mov.get_int(MOVANA_ANNOES);
+  const char tipomov = anal_mov.get_char(MOVANA_TIPOMOV);
+
   for (int r = 1; r <= input_rows.rows(); r++)
   {
     const TRectype& rec = input_rows.row(r);
     TAnal_bill zio(rec);
     const int rmovana_indbil = zio.indicatore_bilancio();
-    const TAnal_ripartizioni_batch& rrip = _cache_rip.righe(rec.get(RMOVANA_CODCCOSTO), rec.get(RMOVANA_CODCMS),
-                                                            rec.get(RMOVANA_CODFASE), annoes, rmovana_indbil, tipomov);
+
+    //ripartizione batch: passa il conto perche' per prima cosa provera' una ripartizione di tipo 'P' con chiave 3; se non..
+    //..ci riuscira', provera' da solo (metodi della TCache_ripartizioni) le ripartizioni di tipo 'B' con chiave 4.
+    const TAnal_ripartizioni_batch& rrip = _cache_rip.righe(zio, annoes, rmovana_indbil, tipomov);
+    const char tiporip = rrip.tiporip();
+
     //ci sono righe di ripartizione
     const int righe_ripartizione = rrip.rows();
     bool ripartisci = righe_ripartizione > 0;
 
+    //se ci sono righe di ripartizione/pareggio si va a ripartire!
     if (ripartisci)  
     {
-      // Importo totale da distribuire arrotondato ai decimali della valuta di conto
-      TGeneric_distrib distrib(rec.get_real(RMOVANA_IMPORTO), TCurrency::get_firm_dec());
-
-      // Calcolo tutte le percentuali da ripartire
-      int i;
-      for (i = 1; i <= righe_ripartizione; i++)
-        distrib.add(rrip[i].get_real(RRIP_RIPARTO));
-
-      for (i = 1; i <= righe_ripartizione; i++)
+      switch (tiporip)
       {
-        const real imp = distrib.get(); // Legge la quota da distribuire
-
-				if (imp != ZERO)
-				{
-					TRectype* newrec = new TRectype(rec);
-					newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1);
-					newrec->put(RMOVANA_IMPORTO, imp);  //e la mette nella nuova riga
-					//poi copia i valori dei campi cdc,cms,fsc,in quelli di tipo ori (nello stesso record)
-					ca_copia_campo(rec, RMOVANA_CODCCOSTO, *newrec, RMOVANA_CODCCORI);
-					ca_copia_campo(rec, RMOVANA_CODCMS,    *newrec, RMOVANA_CODCMSORI);
-					ca_copia_campo(rec, RMOVANA_CODFASE,   *newrec, RMOVANA_CODFASEORI);
-					ca_copia_campo(rec, RMOVANA_CODCONTO,  *newrec, RMOVANA_CODCONTORI);
-					//e mette nei campi std i valori che trova nelle righe ripartizione
-					ca_copia_campo(rrip[i], RRIP_CODCOSTO, *newrec, RMOVANA_CODCCOSTO);
-					ca_copia_campo(rrip[i], RRIP_CODCMS,   *newrec, RMOVANA_CODCMS);
-					ca_copia_campo(rrip[i], RRIP_CODFASE,  *newrec, RMOVANA_CODFASE);
-					ca_copia_campo(rrip[i], RRIP_CODCONTO, *newrec, RMOVANA_CODCONTO);
-
-					output_rows.add_row(newrec);
-	        ho_cambiato_qualchecosa = true;
-				}
+      //procedura di ripartizione batch 'B' originale; se tiporip=='P' invece ci vuole il pareggio del movana
+      case 'B':
+        ho_cambiato_qualchecosa = ripartizione(rrip, rec, output_rows);
+        break;
+      case 'P':
+        ho_cambiato_qualchecosa = pareggio(anal_mov, rrip, rec, output_rows);
+        break;
+      default:
+        break;
       }
     }
-    else  //nessuna riga di ripartizione->aggiungo la riga input all'output
+    else  //if(ripartisci...   nessuna riga di ripartizione->aggiungo la riga input all'output
     {
       TRectype* newrec = new TRectype(rec);
       newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1);
       output_rows.add_row(newrec);
     }
-  }
+  } //for(int r=1; r<=input_rows.rows()...
   return ho_cambiato_qualchecosa;
 }
 
-bool TRib_movanal_app::pareggia_commessa(TAnal_mov& anal_mov)
-{
-  bool ho_cambiato_qualchecosa = false;
-
-  const TString& codcaus = anal_mov.get(MOVANA_CODCAUS);
-  const TAnal_bill* cms = (const TAnal_bill*)_caus_cms.objptr(codcaus);
-  if (cms != NULL) // La causale del movimento e' tra quelle da pareggiare
-  {
-    const TImporto totdoc(anal_mov.get_char(MOVANA_SEZIONE), anal_mov.get_real(MOVANA_TOTDOC));
-    if (!totdoc.is_zero()) // Movimento da pareggiare
-    {
-      TRecord_array& body = anal_mov.body();
-      // Cerco la commessa/fase/costo tra le righe esistenti
-      int i;
-      for (i = body.last_row(); i > 0; i--)
-      {
-        const TRectype& row = body[i];
-        if ((cms->costo().blank() || row.get(RMOVANA_CODCCOSTO) == cms->costo()) &&
-            (cms->commessa().blank() || row.get(RMOVANA_CODCMS) == cms->commessa()) &&           
-            (cms->fase().blank() || row.get(RMOVANA_CODFASE) == cms->fase()))
-          break;
-      }
-      // Se non trovo nessuna riga compatibile, me la creo
-      if (i <= 0)
-      {
-        TRectype& rmovana = anal_mov.new_row();
-        rmovana.put(RMOVANA_DESCR, TR("Pareggio commessa"));
-        rmovana.put(RMOVANA_CODCCOSTO, cms->costo());
-        rmovana.put(RMOVANA_CODCMS,    cms->commessa());
-        rmovana.put(RMOVANA_CODFASE,   cms->fase());
-        i = rmovana.get_int(RMOVANA_NUMRIG);
-      }
-
-      // Sottraggo all'importo della riga il totale documento, 
-      // il quale verra' quindi azzerato
-      TRectype& rmovana = body[i];
-      TImporto importo(rmovana.get_char(RMOVANA_SEZIONE), rmovana.get_real(RMOVANA_IMPORTO));
-      importo -= totdoc;
-      importo.normalize();
-      rmovana.put(RMOVANA_SEZIONE, importo.sezione());
-      rmovana.put(RMOVANA_IMPORTO, importo.valore());
-      anal_mov.put(MOVANA_TOTDOC, ZERO);
-
-      ho_cambiato_qualchecosa = true;
-    }
-  }
-  
-  return ho_cambiato_qualchecosa;
-}
 
 bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi)
 {
@@ -266,13 +221,11 @@ bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi
     output_rows.destroy_rows();             //..e poi lo pulisce
 
     //Esploditore
-    if (explode_rows(compact_rows, output_rows, anal_mov.get_int(MOVANA_ANNOES), anal_mov.get_char(MOVANA_TIPOMOV)))
+    if (elabora_righe(anal_mov, compact_rows, output_rows))
     {
       input_rows = output_rows; //rimette i record elaborati negli originali
       do_rewrite = true;
     }
-    if (pareggia_commessa(anal_mov))
-      do_rewrite = true;
     
     if (_definitivo)  //se l'elaborazione e' definitiva...
     {
@@ -285,8 +238,12 @@ bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi
     //Imploditore
     do_rewrite = ca_implode_rows(input_rows, compact_rows);
     if (do_rewrite)
+    {
       input_rows = compact_rows; // rimette i record compattati negli originali
+      anal_mov.update_totdoc();   //aggiorna il totale movana (necessarip per ripartizioni a pareggio, di sicurezza per le altre)
+    }
   }
+
   return do_rewrite; //se ha elaborato delle righe e/o e' una elaborazione definitiva, riscrive la..
 }
 
@@ -348,23 +305,6 @@ void TRib_movanal_app::main_loop()
       //Presa la decisione si parte! Tenetevi forte...
       if (run)
       {
-        // Riempie la lista della causali dei movimenti da pareggiare
-        _caus_cms.destroy();
-        TSheet_field& sf = mask.sfield(F_RIGHE);
-        const int pos_codcaus = sf.cid2index(F_CODCAUS);
-        FOR_EACH_SHEET_ROW(sf, i, row) 
-        {
-          const TString4 codcaus = row->get(pos_codcaus);
-          if (codcaus.full())
-          {
-            TAnal_bill* bill = new TAnal_bill;
-            if (mask.get_row_bill(sf, i, *bill) != 0)
-              _caus_cms.add(codcaus, bill);
-            else
-              delete bill;
-          }
-        }
-
         if (compattazione)
           cur_movana.scan(compatta_callback, this, TR("Compattamento movimenti..."));
         else
diff --git a/ca/ca2200a.h b/ca/ca2200a.h
index 4007d50a6..1404b0e22 100755
--- a/ca/ca2200a.h
+++ b/ca/ca2200a.h
@@ -5,7 +5,6 @@
 #define F_DEFINITIVO  203
 #define F_ANNO        204
 #define F_COMPATTA    205
-#define F_RIGHE       300
 //Devono valere un numero piu' alto di S_CDC12 (che attualmente e' 112) senno' non nascono in fila nello..
 //..sheet
 #define F_CODCAUS     113
diff --git a/ca/ca2200a.uml b/ca/ca2200a.uml
index 163789028..30358e3fc 100755
--- a/ca/ca2200a.uml
+++ b/ca/ca2200a.uml
@@ -83,162 +83,6 @@ BEGIN
   PROMPT 2 7 "Blocca movimenti elaborati (DEFINITIVO e vale solo per ripartizione)"
 END
 
-TEXT -1
-BEGIN
-  PROMPT 1 9 "@bCommesse/CdC da pareggiare"
-END
-
-SPREADSHEET F_RIGHE -1 -1
-BEGIN
-  PROMPT 1 10 ""
-  ITEM "Cms 1"
-  ITEM "Cms 2"
-  ITEM "Cms 3"
-  ITEM "Cms 4"
-  ITEM "Cms 5"
-  ITEM "Cms 6"
-  ITEM "Cms 7"
-  ITEM "Cms 8"
-  ITEM "Cms 9"
-  ITEM "Cms 10"
-  ITEM "Cms 11"
-  ITEM "Cms 12"
-  ITEM "Causale"
-  ITEM "Descrizione@50"
-END
-  
-ENDPAGE
-
-ENDMASK
-
-PAGE "Riga Commesse/CdC da pareggiare" -1 -1 78 15
-
-STRING F_CODCAUS 3
-BEGIN
-  PROMPT 1 0 "Causale  "
-  USE LF_CAUSALI SELECT MOVIND!=""
-  INPUT CODCAUS F_CODCAUS
-  DISPLAY "Codice" CODCAUS
-  DISPLAY "Descrizione@50" DESCR
-  OUTPUT F_CODCAUS CODCAUS
-  OUTPUT F_DESCAUS DESCR
-  CHECKTYPE NORMAL
-  ADD RUN cg0 -4
-  FLAGS "U"
-END
-
-STRING F_DESCAUS 50
-BEGIN
-  PROMPT 23 0 ""
-  USE LF_CAUSALI KEY 2 SELECT MOVIND!=""
-  INPUT DESCR F_DESCAUS
-  DISPLAY "Descrizione@50" DESCR
-  DISPLAY "Codice" CODCAUS
-  COPY OUTPUT F_CODCAUS
-  ADD RUN cg0 -4
-END
-
-//Non cancellare GROUP 1 dai 12 campi successivi, pena la comparsa di campi inutili e perniciosi nella
-//maschera di riga
-STRING S_CDC1 20
-BEGIN
-  PROMPT 1 2 "Cms1 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC2 20
-BEGIN
-  PROMPT 1 3 "Cms2 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC3 20
-BEGIN
-  PROMPT 1 4 "Cms3 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC4 20
-BEGIN
-  PROMPT 1 5 "Cms4 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC5 20
-BEGIN
-  PROMPT 1 6 "Cms5 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC6 20
-BEGIN
-  PROMPT 1 7 "Cms6 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC7 20
-BEGIN
-  PROMPT 1 8 "Cms7 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC8 20
-BEGIN
-  PROMPT 1 9 "Cms8 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC9 20
-BEGIN
-  PROMPT 1 10 "Cms9 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC10 20
-BEGIN
-  PROMPT 1 11 "Cms10 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC11 20
-BEGIN
-  PROMPT 1 12 "Cms11 "
-  FLAGS "B"
-  GROUP 1
-END
-
-STRING S_CDC12 20
-BEGIN
-  PROMPT 1 13 "Cms12 "
-  FLAGS "B"
-  GROUP 1
-END
-
-BUTTON DLG_OK 10 2
-BEGIN
-  PROMPT -13 -1 ""
-END
-
-BUTTON DLG_DELREC 10 2
-BEGIN
-  PROMPT -23 -1 ""
-END
-
-BUTTON DLG_CANCEL 10 2
-BEGIN
-  PROMPT -33 -1 ""
-END
-
 ENDPAGE
 
 ENDMASK
diff --git a/ca/cacnv.cpp b/ca/cacnv.cpp
index 63235f2c1..f35695198 100755
--- a/ca/cacnv.cpp
+++ b/ca/cacnv.cpp
@@ -471,72 +471,73 @@ void TConversione_cm2ca::create_new_movana(long numreg_cg, bool definitiva, TAss
     //Per prima cosa crea l'array delle righe di ripartizione con questo gr/co/stc/annoes
 		const int annoes = mov_head.get_int(MOV_ANNOES);
     
-    if (ca_config().get_bool("UsePdcc"))  //solo se in CA si usa il piano dei conti contabile..
-    {                                       //..e' possibile costruire la riga movimento
-      //Compila la riga del movimentodi analitica
-      TRectype& analriga = analmov.new_row();
+    const TAnal_ripartizioni_batch& rrip = _cache_rip.righe_interattive(zio, annoes);
 
-      analriga.put(RMOVANA_SEZIONE, importo.sezione());
-      analriga.put(RMOVANA_IMPORTO, importo.valore());
-      analriga.put(RMOVANA_DESCR, importo.descrizione());
+    const int righe_ripartizione = rrip.rows();
+    const bool ripartisci = righe_ripartizione > 0;
 
-      analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
-      analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
+    if (ripartisci)  //ci sono righe ripartizione: da 1 riga mov CG a N righe mov CA
+    {
+      // Importo totale da distribuire arrotondato ai decimali della valuta di conto
+      TGeneric_distrib distrib(importo.valore(), TCurrency::get_firm_dec());
 
-      analriga.put(RMOVANA_CODCMS, chiave.get(0));
-      analriga.put(RMOVANA_CODFASE, chiave.get(1));
+      // Calcola tutte le percentuali da ripartire
+      int i;
+      for (i = 1; i <= rrip.rows(); i++)
+        distrib.add(rrip[i].get_real(RRIP_RIPARTO));
 
-      TString16 codconto;
-      codconto.format("%03d%03d%06ld", gruppo, conto, sottoconto);
-      analriga.put(RMOVANA_CODCONTO, codconto);
+      //Compila le righe del movimento di analitica in base alle righe ripartizione
+      for (i = 1; i <= rrip.rows(); i++)
+      {
+        const TRectype& riga_rip = rrip.row(i);
 
-      //controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
-      check_phase(analriga);
+        TRectype& analriga = analmov.new_row();
+        const real imp = distrib.get(); // Legge la quota da distribuire
+        analriga.put(RMOVANA_SEZIONE, importo.sezione());
+        analriga.put(RMOVANA_IMPORTO, imp);  //e la mette nella nuova riga
+        analriga.put(RMOVANA_DESCR, importo.descrizione());
+
+        analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
+        analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
+
+        //parametri da prendere dalle righe ripartizione!!
+        analriga.put(RMOVANA_CODCCOSTO, riga_rip.get(RRIP_CODCOSTO));
+        analriga.put(RMOVANA_CODCMS, riga_rip.get(RRIP_CODCMS));
+        analriga.put(RMOVANA_CODFASE, riga_rip.get(RRIP_CODFASE));
+        analriga.put(RMOVANA_CODCONTO, riga_rip.get(RRIP_CODCONTO));
+        
+        //controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
+        check_phase(analriga);
+      }
     }
-		else
-		{
-			const TAnal_ripartizioni_batch& rrip = _cache_rip.righe(zio, annoes, ' ', 'I');
+    else  //nessuna riga ripartizione -> da 1 riga movimento CG ad 1 riga movimento CA
+    {
+      if (ca_config().get_bool("UsePdcc"))  //solo se in CA si usa il piano dei conti contabile..
+      {                                       //..e' possibile costruire la riga movimento
+        //Compila la riga del movimentodi analitica
+        TRectype& analriga = analmov.new_row();
 
-			const int righe_ripartizione = rrip.rows();
-			const bool ripartisci = righe_ripartizione > 0;
+        analriga.put(RMOVANA_SEZIONE, importo.sezione());
+        analriga.put(RMOVANA_IMPORTO, importo.valore());
+        analriga.put(RMOVANA_DESCR, importo.descrizione());
 
-			if (ripartisci)  //ci sono righe ripartizione: da 1 riga mov CG a N righe mov CA
-			{
-				// Importo totale da distribuire arrotondato ai decimali della valuta di conto
-				TGeneric_distrib distrib(importo.valore(), TCurrency::get_firm_dec());
+        analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
+        analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
 
-				// Calcola tutte le percentuali da ripartire
-				int i;
-				for (i = 1; i <= rrip.rows(); i++)
-					distrib.add(rrip[i].get_real(RRIP_RIPARTO));
+        analriga.put(RMOVANA_CODCMS, chiave.get(0));
+        analriga.put(RMOVANA_CODFASE, chiave.get(1));
 
-				//Compila le righe del movimento di analitica in base alle righe ripartizione
-				for (i = 1; i <= rrip.rows(); i++)
-				{
-					const TRectype& riga_rip = rrip.row(i);
+        TString16 codconto;
+        codconto.format("%03d%03d%06ld", gruppo, conto, sottoconto);
+        analriga.put(RMOVANA_CODCONTO, codconto);
 
-					TRectype& analriga = analmov.new_row();
-					const real imp = distrib.get(); // Legge la quota da distribuire
-					analriga.put(RMOVANA_SEZIONE, importo.sezione());
-					analriga.put(RMOVANA_IMPORTO, imp);  //e la mette nella nuova riga
-					analriga.put(RMOVANA_DESCR, importo.descrizione());
-
-					analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
-					analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
-
-					//parametri da prendere dalle righe ripartizione!!
-					analriga.put(RMOVANA_CODCCOSTO, riga_rip.get(RRIP_CODCOSTO));
-					analriga.put(RMOVANA_CODCMS, riga_rip.get(RRIP_CODCMS));
-					analriga.put(RMOVANA_CODFASE, riga_rip.get(RRIP_CODFASE));
-					analriga.put(RMOVANA_CODCONTO, riga_rip.get(RRIP_CODCONTO));
-	        
-					//controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
-					check_phase(analriga);
-				}
-			}
-			else
-				error_box(TR("Manca la ripartizione di conversione del conto : %d %d %ld"), zio.gruppo(), zio.conto(), zio.sottoconto());
-		}
+        //controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
+        check_phase(analriga);
+      }
+      else  //qui va aggiunta la lista dei conti che non hanno ripartizione quando NON si usa il..
+            //..piano dei conti contabile in analitica
+        error_box(TR("Manca la ripartizione di un conto"));
+    }
   } //end FOR_EACH..
 
   //e alla fine riesce a mettere anche l'importone in testata
diff --git a/ca/calib01.cpp b/ca/calib01.cpp
index c71af25ad..9e78f8564 100755
--- a/ca/calib01.cpp
+++ b/ca/calib01.cpp
@@ -1521,6 +1521,21 @@ void TAnal_mov::zero(char c)
 	kill_saldi();
 }
 
+void TAnal_mov::update_totdoc()
+{
+  TImporto totdoc;
+  for (int i = rows(); i > 0; i--)
+  {
+    const TRectype& riga = body().row(i); 
+    TImporto imp_riga(riga.get_char(RMOVANA_SEZIONE), riga.get_real(RMOVANA_IMPORTO));
+    totdoc += imp_riga;
+  }
+  totdoc.normalize();
+
+  put(MOVANA_TOTDOC, totdoc.valore());
+  put(MOVANA_SEZIONE, totdoc.sezione());
+}
+
 TAnal_mov::TAnal_mov(long numreg) : TMultiple_rectype(LF_MOVANA)
 {
   add_file(LF_RMOVANA, RMOVANA_NUMRIG);
@@ -1564,7 +1579,12 @@ int TAnal_ripartizioni_batch::indbil() const
   return head().get_int(RIP_INDBIL); 
 }
 
-int TAnal_ripartizioni_batch::read (const char* codice, char tiporip)
+char TAnal_ripartizioni_batch::tiporip() const
+{
+  return head().get_char(RIP_TIPO);
+}
+
+int TAnal_ripartizioni_batch::read (const char tiporip, const char* codice)
 {
   TLocalisamfile rip(LF_RIP);
   _rip.put(RIP_TIPO, tiporip); //solo tipi batch!
@@ -1573,7 +1593,7 @@ int TAnal_ripartizioni_batch::read (const char* codice, char tiporip)
   if (err == NOERR)
   {
     TRectype rrip(LF_RRIP);
-    rrip.put(RRIP_TIPO, 'B');
+    rrip.put(RRIP_TIPO, tiporip);
     rrip.put(RRIP_CODICE, codice);
     TRecord_array::read(rrip);
   }
@@ -1583,7 +1603,7 @@ int TAnal_ripartizioni_batch::read (const char* codice, char tiporip)
 int TAnal_ripartizioni_batch::read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa, 
                                          const char* fase, const int annoes, const int indbil, const int classe_mov) const
 {
-  rip.put(RIP_TIPO, "B"); //solo tipi batch!
+  rip.put(RIP_TIPO, "B"); //solo tipi batch, unici per chiave cdc/cms/fase
   rip.put(RIP_CODCOSTO, codcosto);
   rip.put(RIP_CODCMS, commessa);
   rip.put(RIP_CODFASE, fase);
@@ -1628,14 +1648,14 @@ int TAnal_ripartizioni_batch::read (const char* codcosto, const char* commessa,
   }
 
   if (err == NOERR)
-    err = read(rip.get(RIP_CODICE), 'B');
+    err = read('B', rip.get(RIP_CODICE)); //per chiave 4 solo tipo B (batch)
   return err;
 }
 
-int TAnal_ripartizioni_batch::read_rip_3(TLocalisamfile& rip, const int gr, const int co, const long sot, 
-                                    const int annoes, const int indbil, const int classe_mov, char tiporip) const
+int TAnal_ripartizioni_batch::read_rip_3(TLocalisamfile& rip, const char tiporip, const int gr, const int co, const long sot, 
+                                    const int annoes, const int indbil, const int classe_mov) const
 {
-  rip.put(RIP_TIPO, tiporip); //solo tipi batch!
+  rip.put(RIP_TIPO, tiporip); //tipo 'P' oppure tipo 'I', che sono quelli che vanno per conto
   rip.put(RIP_GRUPPO, gr);
   rip.put(RIP_CONTO, co);
   rip.put(RIP_SOTTOCONTO, sot);
@@ -1645,43 +1665,43 @@ int TAnal_ripartizioni_batch::read_rip_3(TLocalisamfile& rip, const int gr, cons
 	return rip.read();
 }
 
-int TAnal_ripartizioni_batch::read (const int gr, const int co, const long sot, 
-                                    const int annoes, const int indbil, const int classe_mov, char tiporip)
+int TAnal_ripartizioni_batch::read (const char tiporip, const int gr, const int co, const long sot, 
+                                    const int annoes, const int indbil, const int classe_mov)
 {
   CHECKD(classe_mov > 0, "Classe movimento non valida ", classe_mov);
   TLocalisamfile rip(LF_RIP);
   rip.setkey(3);
 
-  int err = read_rip_3(rip, gr, co, sot, annoes, indbil, classe_mov, tiporip);
+  int err = read_rip_3(rip, tiporip, gr, co, sot, annoes, indbil, classe_mov);
   if (err != NOERR)
-     err = read_rip_3(rip, gr, co, sot, annoes, indbil, 0, tiporip);
+     err = read_rip_3(rip, tiporip, gr, co, sot, annoes, indbil, 0);
 
   //la put va rifatta perche' potrebbe essersi spostato al record successivo!!!
   //se fallisce il primo tentativo prova con lo stesso anno e indbil=0
   if (err != NOERR && indbil != 0)
   {
-    err = read_rip_3(rip, gr, co, sot, annoes, 0, classe_mov, tiporip);
+    err = read_rip_3(rip, tiporip, gr, co, sot, annoes, 0, classe_mov);
     if (err != NOERR)
-      err = read_rip_3(rip, gr, co, sot, annoes, 0, 0, tiporip);
+      err = read_rip_3(rip, tiporip, gr, co, sot, annoes, 0, 0);
   }
   //se fallisce ancora riprova con anno=0 e lo stesso indbil
   if (err != NOERR && annoes != 0)
   {
-    err = read_rip_3(rip, gr, co, sot, 0, indbil, classe_mov, tiporip);
+    err = read_rip_3(rip, tiporip, gr, co, sot, 0, indbil, classe_mov);
     if (err != NOERR)
-      err = read_rip_3(rip, gr, co, sot, 0, indbil, 0, tiporip);
+      err = read_rip_3(rip, tiporip, gr, co, sot, 0, indbil, 0);
  
     //estremo tentativo con annoes e indbil = 0
     if (err != NOERR && indbil != 0)
     {
-      err = read_rip_3(rip, gr, co, sot, 0, 0, classe_mov, tiporip);
+      err = read_rip_3(rip, tiporip, gr, co, sot, 0, 0, classe_mov);
       if (err != NOERR)
-        err = read_rip_3(rip, gr, co, sot, 0, 0, 0, tiporip);
+        err = read_rip_3(rip, tiporip, gr, co, sot, 0, 0, 0);
     }
   }
 
   if (err == NOERR)
-    err = read(rip.get(RIP_CODICE), tiporip);
+    err = read(tiporip, rip.get(RIP_CODICE)); //per chiave 3 sia tiporip=P che tiporip=B
   return err;
 }
 
@@ -1700,30 +1720,47 @@ TObject* TCache_ripartizioni::key2obj(const char* key)
 
   TAnal_ripartizioni_batch* rip = new TAnal_ripartizioni_batch;
  
-  if (nkey == 3)
+  switch (nkey)
   {
-    const int gruppo = parametro.get_int(1);
-    const int conto = parametro.get_int(2);
-    const long sottoconto = parametro.get_long(3);
-    const int anno = parametro.get_int(4);
-    const int indbil = parametro.get_int(5);
-    const int classe_mov = parametro.get_int(6);
-		const char tiporip = parametro.get_char(7);
+  case 3:
+    {
+      const int gruppo = parametro.get_int(1);
+      const int conto = parametro.get_int(2);
+      const long sottoconto = parametro.get_long(3);
+      const int anno = parametro.get_int(4);
+      const int indbil = parametro.get_int(5);
+      const int classe_mov = parametro.get_int(6);
 
-    rip->read(gruppo, conto, sottoconto, anno, indbil, classe_mov, tiporip);
+      //solo i movimenti a pareggio hanno chiave 3
+      rip->read('P', gruppo, conto, sottoconto, anno, indbil, classe_mov);
+    }
+    break;
+  case 5:
+    {
+      const int gruppo = parametro.get_int(1);
+      const int conto = parametro.get_int(2);
+      const long sottoconto = parametro.get_long(3);
+      const int anno = parametro.get_int(4);
+      const int indbil = parametro.get_int(5);
+      const int classe_mov = parametro.get_int(6);
+
+      //solo i movimenti interattivi e di conversione hanno chiave 5
+      rip->read('I', gruppo, conto, sottoconto, anno, indbil, 1);
+    }
+    break;
+  default:  //chiave 4: normali ripartizioni batch
+    {
+      const TString80 codcosto = parametro.get(1);
+      const TString80 commessa = parametro.get(2);
+      const TString16 fase = parametro.get(3);
+      const int anno = parametro.get_int(4);
+      const int indbil = parametro.get_int(5);
+      const int classe_mov = parametro.get_int(6);
+
+      rip->read(codcosto, commessa, fase, anno, indbil, classe_mov);
+    }
+    break;
   }
-  else  //chiave 4
-  {
-    const TString80 codcosto = parametro.get(1);
-    const TString80 commessa = parametro.get(2);
-    const TString16 fase = parametro.get(3);
-    const int anno = parametro.get_int(4);
-    const int indbil = parametro.get_int(5);
-    const int classe_mov = parametro.get_int(6);
-
-    rip->read(codcosto, commessa, fase, anno, indbil, classe_mov);
-  }
-
 	if (rip->head().get_int(RIP_TIPORIP) == 1)
 	{
 		bool some_value = false;
@@ -1787,7 +1824,7 @@ const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const char* costo, co
   return *(const TAnal_ripartizioni_batch*)objptr(parametro);
 }
 
-const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TBill& bill, const int annoes, const char tipomov, char tiporip)
+const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TBill& bill, const int annoes, const char tipomov)
 {
   //classi di movimento: se preventivi 2, se normali 1
   int classe_movimento;
@@ -1798,7 +1835,44 @@ const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TBill& bill, co
 
   TToken_string parametro;
   parametro << "3|" << bill.gruppo() << '|' << bill.conto() << '|' << bill.sottoconto() << '|' 
-            << annoes << '|' << bill.indicatore_bilancio() << '|' << classe_movimento << '|' << tiporip;  //per chiave 3
+            << annoes << '|' << bill.indicatore_bilancio() << '|' << classe_movimento;  //per chiave 3
+  return *(const TAnal_ripartizioni_batch*)objptr(parametro);
+}
+
+const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TAnal_bill& bill, const int annoes, const int indbil, 
+                                                           const char tipomov)
+{
+  TConfig& config = ca_config();
+  const bool use_pdcc = config.get_bool("UsePdcc");    //usa il piano dei conti contabile
+  if (use_pdcc)
+  {
+    const TString& contone = bill.conto();
+    const int gr = atoi(contone.mid(0,3));
+    const int co = atoi(contone.mid(3,3));
+    const long so = atol(contone.mid(6,6));
+    const TBill zio(gr, co, so);
+    const TAnal_ripartizioni_batch& rb = righe(zio, annoes, tipomov);
+    //ha trovato una ripartizione?
+    if (rb.rows() > 0)
+      return rb;
+
+  }
+  //se non riesce a trovare una ripartizione per conto (chiave 3, tipo 'P') prova con la chiave 4 (cdc/cms/fase, tipo 'B')
+  return righe(bill.costo(), bill.commessa(), bill.fase(), annoes, indbil, tipomov);
+}
+
+const TAnal_ripartizioni_batch& TCache_ripartizioni::righe_interattive(const TBill& bill, const int annoes, const char tipomov)
+{
+    //classi di movimento: se preventivi 2, se normali 1
+  int classe_movimento;
+  if (tipomov == 'P' || tipomov == 'V')
+    classe_movimento = 2;
+  else
+    classe_movimento = 1; //sempre questo per cacnv
+
+  TToken_string parametro;
+  parametro << "5|" << bill.gruppo() << '|' << bill.conto() << '|' << bill.sottoconto() << '|' 
+            << annoes << '|' << bill.indicatore_bilancio() << '|' << classe_movimento;  //per chiave 5
   return *(const TAnal_ripartizioni_batch*)objptr(parametro);
 }
 
@@ -1847,6 +1921,10 @@ bool ca_implode_rows(const TRecord_array& input_rows, TRecord_array& compact_row
     //se esiste almeno un campo origine compilato puo' implodere, senno' lascia perdere
     if (ca_ori_present(rec))
     {
+      //controlla se e' un pareggio e non una ripartizione
+      if (rec.get(RMOVANA_CODCONTORI).blank())
+        continue;
+
       int i = 0;
       for (i = compact_rows.rows(); i > 0; i--) //giro sulle righe gia' compattate per scoprire se
       {                                         //il nostro record esiste gia' o e' da aggiungere
diff --git a/ca/calib01.h b/ca/calib01.h
index fb96dc188..85f6dd3dd 100755
--- a/ca/calib01.h
+++ b/ca/calib01.h
@@ -157,6 +157,7 @@ public:
 
 public:
   int read(long numreg, word lockop = _nolock); // Funzione read di comodo
+  void update_totdoc();
   TAnal_mov(long numreg = 0);
 	TAnal_mov(const TRectype& rec);	//accetta LF_MOVANA,LF_RMOVANA,LF_MOV
 };
@@ -164,21 +165,24 @@ public:
 ///////////////////////////////////////////////////////////
 //  TAnal_ripartizioni_batch (ahi!)
 ///////////////////////////////////////////////////////////
+class TAnal_bill;
 
 class TAnal_ripartizioni_batch : public TRecord_array
 {
   TRectype _rip;
 private:
-  int read_rip_3(TLocalisamfile& rip, const int gr, const int co, const long sot, 
-                 const int annoes, const int indbil, const int classe_mov, char tiporip) const;
+  int read_rip_3(TLocalisamfile& rip, const char tiporip, const int gr, const int co, const long sot, 
+                 const int annoes, const int indbil, const int classe_mov) const;
   int read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa, const char* fase,
                  const int annoes, const int indbil, const int classe_mov) const;
 public:
   const TRectype& head() const { return _rip; }
   int indbil() const;
-  int read (const char* codice, char tiporip);
+  char tiporip() const;
+  int read (const char tiporip, const char* codice);
   int read (const char* codcosto, const char* commessa, const char* fase, const int annoes, const int indbil, const int classe_mov);
-  int read (const int gr, const int co, const long sot, const int annoes, const int indbil, const int classe_mov, char tiporip);
+  int read (const char tiporip, const int gr, const int co, const long sot, const int annoes, const int indbil, const int classe_mov);
+  
   TAnal_ripartizioni_batch();
 };
 
@@ -196,11 +200,17 @@ protected:
 
 public:
 	void set_esercizio(const int codes);
+  //batch
   const TAnal_ripartizioni_batch& righe(const char* costo, const char* commessa, const char* fase,
                                         const int annoes, const int indbil, const char tipomov);
-  const TAnal_ripartizioni_batch& righe(const TBill& bill, const int annoes, const char tipomov, char tiporip = 'B');
-
-  TCache_ripartizioni();
+  //pareggio
+  const TAnal_ripartizioni_batch& righe(const TBill& bill, const int annoes, const char tipomov);
+  //batch
+  const TAnal_ripartizioni_batch& righe(const TAnal_bill& bill, const int annoes, const int indbil, const char tipomov);
+  //interattive per conversione e contabilizzazione (usate da cacnv e da contabilizzazione analitica docs)
+  const TAnal_ripartizioni_batch& righe_interattive(const TBill& bill, const int annoes, const char tipomov = ' ');
+  
+    TCache_ripartizioni();
 };
 
 // metodi di implosione movimenti ripartiti!! Serve nel ribaltamento movimenti, stampa rendiconto...
diff --git a/ca/f149.trr b/ca/f149.trr
index 85a533564..2b551df27 100755
--- a/ca/f149.trr
+++ b/ca/f149.trr
@@ -1,6 +1,6 @@
 149
 13
-TIPO|1|1|0|Tipo Ripartizione (<I>nterattiva, <B>atch)
+TIPO|1|1|0|Tipo Ripartizione (<I>nterattiva, <B>atch, <P>areggio)
 CODICE|1|8|0|Codice ripartizione
 GRUPPO|2|3|0|Gruppo
 CONTO|2|3|0|Conto
diff --git a/ve/velib04f.cpp b/ve/velib04f.cpp
index 9bf0228d1..3e40a0511 100755
--- a/ve/velib04f.cpp
+++ b/ve/velib04f.cpp
@@ -351,7 +351,7 @@ bool TContabilizzazione_analitica::find_conti_iva_indetraibile(const TRiga_docum
   else
 	{
     // Cerca la ripartizione del conto
-		const TAnal_ripartizioni_batch& rip = _rip.righe(bill, annoes, tipomov);
+		const TAnal_ripartizioni_batch& rip = _rip.righe_interattive(bill, annoes, tipomov);
 		for (int i = 1; i <= rip.rows(); i++)
 		{
 			const TRectype& rigarip = rip.row(i);
@@ -438,7 +438,7 @@ bool TContabilizzazione_analitica::find_conti(const TRiga_documento& riga, TStri
   if (contanal.blank())  // Non ho trovato il conto in anagrafica ...
   { 
     // Cerca la ripartizione del conto
-    const TAnal_ripartizioni_batch& rip = _rip.righe(bill, annoes, tipomov, 'I');
+    const TAnal_ripartizioni_batch& rip = _rip.righe_interattive(bill, annoes, tipomov);
     TToken_string conto;
     for (int i = 1; i <= rip.rows(); i++)
     {