anchor.diff:  			   end
    		     endmethod
   		  endinterface
  -                  interface data = memDataPipes[i];
  +                  interface data = interface PipeOut;
  +	             method MemDataF#(userWidth) first;
  +	                return clientDataFifo[i].first;
  +	             endmethod
  +	             method Action deq;
  +	                if (verbose) $display("mkMemReadEngineBuff::check_out: idx %d data %h clientAvail %d eob %d", i, clientDataFifo[i].first.data, clientAvail[i].read(), clientDataFifo[i].first.last);
  +	                clientDataFifo[i].deq;
  +	                clientAvail[i].increment(1);
  +	             endmethod
  +	             method Bool notEmpty = clientDataFifo[i].notEmpty;
  +                  endinterface;
                  endinterface);
      interface readServers = rs;
      interface MemReadClient dmaClient;
         interface Get readReq;
   	 method ActionValue#(MemRequest) get();
  -	    match {.idx, .cmd, .first_burst, .last_burst, .bl} <- toGet(serverRequest).get;
  -	    serverProcessing.enq(tuple4(truncate(bl>>beat_shift), idx, first_burst, last_burst));
  +	    match {.idx, .cmd, .last_burst, .bl} <- toGet(serverRequest).get;
  +	    serverProcessing.enq(tuple3(truncate(bl>>beat_shift), idx, last_burst));
   	    if (verbose) $display("MemReadEngine::%d readReq idx %d offset %h burstLenBytes %h last_burst %d", counter, idx, cmd.base, bl, last_burst);
   	    return MemRequest { sglId: cmd.sglId, offset: extend(cmd.base), burstLen:bl, tag: (cmd.tag << valueOf(serverIdxSz)) | extend(idx)
   `ifdef BYTE_ENABLES
  
positive.code:       else begin
  	 respCnt <= new_respCnt;
        end
        clientDataFifo[idx].enq(MemDataF { data: d.data, tag: d.tag,
           first: //first_burst && 
  (respCnt == 0), last: l});
     endrule
  
     Vector#(numServers, MemReadEngineServer#(userWidth)) rs;
  
negative.code:    Vector#(numServers, Reg#(Bool))          clientInFlight <- replicateM(mkReg(False));
     Vector#(numServers, ConfigCounter#(16))  clientAvail <- replicateM(mkConfigCounter(fromInteger(bufferSizeBeats)));
     Vector#(numServers, Reg#(MemengineCmd))  clientCommand <- replicateM(mkReg(unpack(0)));
     Vector#(numServers, FIFOF#(MemDataF#(userWidth))) clientDataFifo <- replicateM(mkSizedBRAMFIFOF(bufferSizeBeats));
     Vector#(numServers, FIFO#(MemengineCmd)) clientRequest <- replicateM(mkFIFO());
     
     Reg#(Bool) load_in_progress <- mkReg(False);
     FIFO#(Tuple4#(MemengineCmd,Bool,Bool,Bit#(BurstLenSize)))              serverCheckAvail <- mkSizedFIFO(1);
     FIFO#(Tuple4#(Bit#(serverIdxSz),MemengineCmd,Bool,Bit#(BurstLenSize))) serverRequest <- mkSizedFIFO(valueOf(cmdQDepth));
     FIFO#(Tuple3#(Bit#(8),Bit#(serverIdxSz),Bool)) serverProcessing <- mkSizedFIFO(valueOf(cmdQDepth));
  
     FIFOF#(MemData#(busWidth))                       serverDataFifo <- mkFIFOF;
  
     Reg#(Bit#(8))                    respCnt <- mkReg(0);
     Reg#(Bit#(TAdd#(1,serverIdxSz))) loadIdx <- mkReg(0);
  