anchor.diff:     rule load_ctxt_c if (load_in_progress);
         load_in_progress <= False;
         incr_loadIdx;
  -      match {.cmd,.cond0,.first_burst,.last_burst,.cmd_len} <- toGet(serverCheckAvail).get;
  +      match {.cmd,.cond0,.last_burst,.cmd_len} <- toGet(serverCheckAvail).get;
         if  (cond0) begin
   	 if (verbose) $display("mkMemReadEngineBuff::%d load_ctxt_c cmd.len %d idx %d cond0 %d last_burst %d", counter, cmd.len, loadIdx, cond0, last_burst);
  -	 serverRequest.enq(tuple5(truncate(loadIdx),cmd,first_burst,last_burst,cmd_len));
  -	 clientFirstBurst[loadIdx] <= False;
  +	 serverRequest.enq(tuple4(truncate(loadIdx),cmd,last_burst,cmd_len));
   	 if (last_burst) begin
   	    if (verbose) $display("mkMemReadEngineBuff::%d load_ctxt_b last_burst %d", counter, last_burst);
   	    clientInFlight[loadIdx] <= False;
  
positive.code: 			   end
   		     endmethod
  		  endinterface
                    interface data = memDataPipes[i];
                 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));
  	    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
  
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);
  