anchor.diff:  
      interface ObjectReadServer readServer;
         interface Put readReq = toPut(reqOutstanding);
  -      interface Get readData = toGet(readBuffer);
  +      interface Get readData;
  +	 method ActionValue#(ObjectData#(dataWidth)) get();
  +	    let v <- toGet(readBuffer).get();
  +	    unfulfilled.decrement(1);
  +	    return v;
  +	 endmethod
  +      endinterface: readData
      endinterface
      interface ObjectReadClient readClient;
         interface Get readReq = toGet(reqCommitted);
         interface Put readData;
      	 method Action put(ObjectData#(dataWidth) x);
  -   	    readBuffer.fifo.enq(x);
  -   	    unfulfilled.decrement(1);
  +	    readBuffer.enq(x);
      	 endmethod
         endinterface
      endinterface
  
positive.code: endinterface
  
  module mkMemWriterBuff(MemWriterBuff#(dataWidth, bufferDepth))
     provisos(Add#(b__, TAdd#(1, TLog#(bufferDepth)), 8),
  	    Div#(dataWidth,8,dataWidthBytes),
  	    Mul#(dataWidthBytes,8,dataWidth),
  	    Log#(dataWidthBytes,beatShift));
  
     FIFOFLevel#(ObjectData#(dataWidth),bufferDepth) writeBuffer <- mkBRAMFIFOFLevel;
     FIFOF#(ObjectRequest)        reqOutstanding <- mkFIFOF();
     FIFOF#(ObjectRequest)        reqCommitted <- mkFIFOF();
     FIFOF#(Bit#(6))                        doneTags <- mkFIFOF();
     ConfigCounter#(TAdd#(1,TLog#(bufferDepth)))  unfulfilled <- mkConfigCounter(0);
     let beat_shift = fromInteger(valueOf(beatShift));
     
     // only issue the writeRequest when sufficient data is available.  This includes the data we have already comitted.
     Bit#(TAdd#(1,TLog#(bufferDepth))) sreq = pack(satPlus(Sat_Bound, unpack(truncate(reqOutstanding.first.burstLen>>beat_shift)), unfulfilled.read()));
  
     rule commitReq if (writeBuffer.highWater(sreq));
        let req <- toGet(reqOutstanding).get();
        unfulfilled.increment(unpack(truncate(req.burstLen>>beat_shift)));
        reqCommitted.enq(req);
     endrule
  
     interface ObjectWriteServer writeServer;
        interface Put writeReq = toPut(reqOutstanding);
        interface Put writeData = toPut(writeBuffer);
        interface Get writeDone = toGet(doneTags);
     endinterface
     interface ObjectWriteClient writeClient;
        interface Get writeReq = toGet(reqCommitted);
        interface Get writeData;
  	 method ActionValue#(ObjectData#(dataWidth)) get();
  	    unfulfilled.decrement(1);
  	    writeBuffer.fifo.deq;
  	    return writeBuffer.fifo.first;
  	 endmethod
        endinterface
        interface Put writeDone = toPut(doneTags);
     endinterface
  endmodule
  
  
  interface UGBramFifos#(numeric type numFifos, numeric type fifoDepth, type a);
     method Action enq(Bit#(TLog#(numFifos)) idx, a v);
  
negative.code: 
  
  import BRAM::*;
  import BRAMFIFO::*;
  import FIFO::*;
  import Vector::*;
  import Gearbox::*;
  