diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java
index 45af4c9293..372dce61cb 100644
--- a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/CLASDecoder.java
@@ -217,34 +217,38 @@ public Bank getDataBankADC(String name, DetectorType type){
         List<DetectorDataDgtz> adcDGTZ = this.getEntriesADC(type);
         if (adcDGTZ.isEmpty()) return null;
 
-        Bank adcBANK = new Bank(schemaFactory.getSchema(name), adcDGTZ.size());
-
+        Bank adcBANK = new Bank(schemaFactory.getSchema(name),
+                adcDGTZ.stream().mapToInt(b -> b.getADCSize()).sum());
+       
+        int row = 0;
         for(int i = 0; i < adcDGTZ.size(); i++){
-            adcBANK.putByte( 0, i, (byte) adcDGTZ.get(i).getDescriptor().getSector());
-            adcBANK.putByte( 1, i, (byte) adcDGTZ.get(i).getDescriptor().getLayer());
-            adcBANK.putShort(2, i, (short) adcDGTZ.get(i).getDescriptor().getComponent());
-            adcBANK.putByte( 3, i, (byte) adcDGTZ.get(i).getDescriptor().getOrder());
-            adcBANK.putInt(  4, i, adcDGTZ.get(i).getADCData(0).getADC());
-            if (type == DetectorType.BMT || type == DetectorType.FMT || type == DetectorType.FTTRK) {
-            	adcBANK.putInt( 4, i, adcDGTZ.get(i).getADCData(0).getHeight());
-            	adcBANK.putInt( 7, i, adcDGTZ.get(i).getADCData(0).getIntegral());
-            	adcBANK.putLong(8, i, adcDGTZ.get(i).getADCData(0).getTimeStamp());
-            }
-            if(type == DetectorType.BAND) {
-                adcBANK.putInt(  5, i, adcDGTZ.get(i).getADCData(0).getHeight());
-                adcBANK.putFloat(6, i, (float) adcDGTZ.get(i).getADCData(0).getTime());
-                adcBANK.putShort(7, i, (short) adcDGTZ.get(i).getADCData(0).getPedestal());
-            }
-            else {
-                adcBANK.putFloat(5, i, (float) adcDGTZ.get(i).getADCData(0).getTime());
-                adcBANK.putShort(6, i, (short) adcDGTZ.get(i).getADCData(0).getPedestal());
+            for (int j = 0; j<adcDGTZ.get(i).getADCSize(); j++) {
+                adcBANK.putByte( 0, row, (byte) adcDGTZ.get(i).getDescriptor().getSector());
+                adcBANK.putByte( 1, row, (byte) adcDGTZ.get(i).getDescriptor().getLayer());
+                adcBANK.putShort(2, row, (short) adcDGTZ.get(i).getDescriptor().getComponent());
+                adcBANK.putByte( 3, row, (byte) adcDGTZ.get(i).getDescriptor().getOrder());
+                adcBANK.putInt(  4, row, adcDGTZ.get(i).getADCData(j).getADC());
+                if (type == DetectorType.BMT || type == DetectorType.FMT || type == DetectorType.FTTRK) {
+                    adcBANK.putInt( 4, row, adcDGTZ.get(i).getADCData(j).getHeight());
+                    adcBANK.putInt( 7, row, adcDGTZ.get(i).getADCData(j).getIntegral());
+                    adcBANK.putLong(8, row, adcDGTZ.get(i).getADCData(j).getTimeStamp());
+                }
+                if(type == DetectorType.BAND) {
+                    adcBANK.putInt(  5, row, adcDGTZ.get(i).getADCData(j).getHeight());
+                    adcBANK.putFloat(6, row, (float) adcDGTZ.get(i).getADCData(j).getTime());
+                    adcBANK.putShort(7, row, (short) adcDGTZ.get(i).getADCData(j).getPedestal());
+                }
+                else {
+                    adcBANK.putFloat(5, row, (float) adcDGTZ.get(i).getADCData(j).getTime());
+                    adcBANK.putShort(6, row, (short) adcDGTZ.get(i).getADCData(j).getPedestal());
+                }
+                if(type == DetectorType.BST) adcBANK.putLong(7, row, adcDGTZ.get(i).getADCData(j).getTimeStamp());
+                row++;
             }
-            if(type == DetectorType.BST) adcBANK.putLong(7, i, adcDGTZ.get(i).getADCData(0).getTimeStamp());
-         }
+        }
         return adcBANK;
     }
 
-
     public Bank getDataBankTDC(String name, DetectorType type){
 
         List<DetectorDataDgtz> tdcDGTZ = this.getEntriesTDC(type);
diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java
index 20a2a64739..2265b36259 100644
--- a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/DetectorEventDecoder.java
@@ -217,19 +217,32 @@ private void fitPulses(DetectorDataDgtz data, IndexedTable cfg) {
         final int nadc = data.getADCSize();
         for (int i = 0; i < nadc; i++) {
             ADCData adc = data.getADCData(i);
-            if(adc.getPulseSize()>0){
+            if (adc.getPulseSize() > 0) {
                 try {
-                    extendedFitter.fit(nsa, nsb, tet, ped, adc.getPulseArray());
+                    ExtendedFADCFitter[] hits = extendedFitter.multiFit(nsa, nsb, tet, ped, adc.getPulseArray());
+                    // the first hit is treated conventionally:
+                    adc.setIntegral(hits[0].adc + hits[0].ped*(nsa+nsb));
+                    adc.setHeight((short) hits[0].pulsePeakValue);
+                    adc.setTimeWord(hits[0].t0);
+                    adc.setPedestal((short) hits[0].ped);
+                    adc.setADC(nsa, nsb);
+                    // and extra hits get a new object here:
+                    for (int j = 1; j < hits.length; j++) {
+                        ADCData a = new ADCData();
+                        a.setOrder(adc.getOrder());
+                        a.setIntegral(hits[j].adc + hits[j].ped*(nsa+nsb));
+                        a.setHeight((short) hits[j].pulsePeakValue);
+                        a.setTimeWord(hits[j].t0);
+                        a.setPedestal((short) hits[j].ped);
+                        a.setADC(nsa, nsb);
+                        data.addADC(a);
+                    }
                 } catch (Exception e) {
+                    e.printStackTrace();
                     System.err.println(">>>> error : fitting pulse "+dd.getCrate()+
                         " / "+dd.getSlot()+" / "+dd.getChannel());
                 }
-                adc.setIntegral(extendedFitter.adc + extendedFitter.ped*(nsa+nsb));
-                adc.setHeight((short) this.extendedFitter.pulsePeakValue);
-                adc.setTimeWord(this.extendedFitter.t0);
-                adc.setPedestal((short) this.extendedFitter.ped);
             }
-            data.getADCData(i).setADC(nsa, nsb);
         }
     }
 
diff --git a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java
index 245c5c84d8..b18138b44c 100644
--- a/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java
+++ b/common-tools/clas-detector/src/main/java/org/jlab/detector/decode/ExtendedFADCFitter.java
@@ -1,5 +1,8 @@
 package org.jlab.detector.decode;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  *
  * @author gavalian
@@ -17,9 +20,7 @@ public class ExtendedFADCFitter implements IFADCFitter {
     public double  baseline, rms;
     private int    tcourse, tfine;
 
-    public ExtendedFADCFitter(){
-        
-    }
+    public ExtendedFADCFitter(){}
 
     public void fitCourseTime(int nsa, int nsb, int tet, int pedr, short[] pulse) {
         pedsum=0;adc=0;mmsum=0;summing_in_progress=0;
@@ -162,4 +163,81 @@ public void fit(DetectorDataDgtz.ADCData data) {
         }
     }
 
+    public ExtendedFADCFitter[] multiFit(int nsa, int nsb, int tet, int pedr, short[] pulse) {
+        
+        List<ExtendedFADCFitter> hits = new ArrayList<>();
+
+        // initialize with our conventional pulse fitting:
+        fit(nsa, nsb, tet, pedr, pulse);
+        hits.add(this);
+
+        // and look for more later pulses:
+        if (pulsePeakPosition > 0) {
+
+            // start at the first pulse's maximum and look forward:
+            boolean belowThreshold = false;
+            for (int crossBin=pulsePeakPosition+1; crossBin<pulse.length; crossBin++) {
+
+                // mark that we went below theshold:
+                if (pulse[crossBin] <= ped+tet) belowThreshold = true;
+
+                // we went below and above theshold again:
+                else if (belowThreshold) {
+
+                    belowThreshold = false;
+
+                    // find the maximum:
+                    for (int maxBin = crossBin; maxBin<pulse.length; maxBin++) {
+                        if (pulse[maxBin] < pulse[maxBin-1]) {
+
+                            // make a new hit:
+                            ExtendedFADCFitter f = new ExtendedFADCFitter();
+                            f.ped = ped;
+                            f.thresholdCrossing = crossBin;
+                            f.pulsePeakPosition = maxBin-1;
+                            f.pulsePeakValue = pulse[maxBin-1];
+
+                            // define its energy:
+                            final int eLimit = Math.min(pulse.length, crossBin + nsa);
+                            for (int eBin = Math.max(crossBin-nsb,0); eBin < eLimit; eBin++)
+                                f.adc += pulse[eBin] - f.ped;
+
+                            // find the half-max crossing upwards:
+                            final double halfMax = (pulse[maxBin-1] + baseline)/2;
+                            for (int halfBinUp = crossBin+1; halfBinUp < maxBin; halfBinUp++) {
+                                if (pulse[halfBinUp] <= halfMax && pulse[halfBinUp+1] > halfMax) {
+
+                                    // define timing:
+                                    int a0 = pulse[halfBinUp];
+                                    int a1 = pulse[halfBinUp+1];
+                                    f.tcourse = halfBinUp;
+                                    f.tfine   = ((int) ((halfMax - a0)/(a1-a0) * 64));
+                                    f.t0      = (tcourse << 6) + tfine;
+
+                                    // find the half-max crossing downwards:
+                                    for (int halfBinDown = halfBinUp; halfBinDown<pulse.length; halfBinDown++) {
+                                        if (pulse[halfBinDown] > halfMax && pulse[halfBinDown+1] <= halfMax) {
+                                            f.pulseWidth = halfBinDown - halfBinUp;
+                                            break;
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+
+                            // add the new hit we just made:
+                            hits.add(f);
+
+                            // move search bin forward:
+                            crossBin = f.pulsePeakPosition;
+                            break;
+                        }
+                    }
+                    // if we didn't generate a new hit, stop:
+                    if (hits.size() < 2) break;
+                }
+            }
+        }
+        return hits.stream().toArray(ExtendedFADCFitter[]::new);
+    }
 }