anchor.diff:     interface MemReadClient dmaClient;
         interface Get readReq;
   	 method ActionValue#(MemRequest) get();
  -	    match {.idx, .cmd, .last_burst, .bl} <- toGet(loadf_c).get;
  -	    workf.enq(tuple3(truncate(bl>>beat_shift), idx, 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: cmd.base, burstLen:bl, tag: (cmd.tag << valueOf(serverIdxSz)) | extend(idx)};
   	 endmethod
         endinterface
  -      interface Put readData = toPut(read_data);
  +      interface Put readData = toPut(serverDataFifo);
      endinterface 
  -   interface dataPipes = read_data_pipes;
  -   interface read_servers = zipWith(toMemreadServer, rs, read_data_pipes);
  +   interface dataPipes = clientDataPipes;
  +   interface read_servers = zipWith(toMemreadServer, rs, clientDataPipes);
   endmodule
  
positive.code: 			end
  			else begin
  `endif
  			   cmds_in[i].enq(cmd);
  `ifdef BSIM
  			end
  `endif
  
negative.code:    let verbose = False;
  
     Integer bufferSizeBeats = bufferSizeBytes/valueOf(dataWidthBytes);
     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)));
     
     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));
     
  
     Vector#(numServers, FIFO#(void))         clientResponse <- replicateM(mkSizedFIFO(valueOf(cmdQDepth)));
     Vector#(numServers, FIFO#(MemengineCmd)) clientRequest <- replicateM(mkFIFO());
  
     FIFOF#(MemData#(dataWidth))                       serverDataFifo <- mkFIFOF;
     Vector#(numServers, FIFOF#(MemData#(dataWidth)))  clientDataFifo <- replicateM(mkSizedBRAMFIFOF(bufferSizeBeats));
     function PipeOut#(Bit#(dataWidth)) check_out(PipeOut#(MemData#(dataWidth)) inpipe, Integer i) = 
        (interface PipeOut;
  	  method Bit#(dataWidth) first;
  	     return inpipe.first.data;
  	  endmethod
  	  method Action deq;
  	     if (verbose) $display("mkMemreadEngineBuff::check_out: idx %d data %h clientAvail %d eob %d", i, inpipe.first.data, clientAvail[i].read(), inpipe.first.last);
  	     inpipe.deq;
  	     clientAvail[i].increment(1);
  	  endmethod
  	  method Bool notEmpty = inpipe.notEmpty;
         endinterface);
     Vector#(numServers, PipeOut#(Bit#(dataWidth))) clientDataPipes = zipWith(check_out, map(toPipeOut,clientDataFifo), genVector);
     
     Reg#(Bit#(8))                    respCnt <- mkReg(0);
     Reg#(Bit#(TAdd#(1,serverIdxSz))) loadIdx <- mkReg(0);
  