anchor.diff:     Reg#(Bit#(24))                      needleLenReg <- mkReg(0);
      MPStreamEngine#(PcieDataBusWidth,DataBusWidth)    mpEngine <- mkMPStreamEngine();
   
  -   FIFOF#(Bit#(32)) msgFromSoftwareFifo <- mkFIFOF();
  -   FIFOF#(Bit#(32)) msgToSoftwareFifo <- mkFIFOF();
  +   FIFOF#(MemData#(32)) msgFromSoftwareFifo <- mkFIFOF();
  +   FIFOF#(MemData#(32)) msgToSoftwareFifo <- mkFIFOF();
      FIFOF#(MemDataF#(PcieDataBusWidth)) dataFromNvmeFifo <- mkFIFOF();
      FIFOF#(MemDataF#(PcieDataBusWidth)) dataToNvmeFifo <- mkFIFOF();
      FIFOF#(Bit#(SizeOf#(NvmeIoCommand))) requestFifo <- mkFIFOF();
  
positive.code:    } MsgFromSoftwareTag deriving (Bits,Eq);
  
  typedef struct {
     Bool     last;
     MsgFromSoftwareTag tag;
     Bit#(24)  data;
     } MsgFromSoftware deriving (Bits);
  
  typedef enum {
     Loopback,
     LocDone,
     TransferDone
     } MsgToSoftwareTag deriving (Bits,Eq);
  
  typedef struct {
     Bool     last;
     MsgToSoftwareTag tag;
     Bit#(24)  data;
     } MsgToSoftware deriving (Bits);
  
negative.code:       let r <- toGet(responseFifo).get();
        NvmeIoResponse response = unpack(r);
        Bit#(8) sct = truncate(response.statusCodeType);
        responseProbe <= response.statusCode;
        
        MsgToSoftware outmsg = MsgToSoftware { tag: TransferDone, data: { sct, response.statusCode }};
        outmsgTagProbe <= outmsg.tag;
        outmsgDataProbe <= outmsg.data;
        msgToSoftwareFifo.enq(MemData { data: extend(pack(outmsg)), last: True });
     endrule
     rule rl_match;
        let loc <- toGet(mpEngine.locdone).get();
        MsgToSoftware outmsg = MsgToSoftware { tag: LocDone, data: truncate(pack(loc)) };
        outmsgTagProbe <= outmsg.tag;
        outmsgDataProbe <= outmsg.data;
        msgToSoftwareFifo.enq(MemData { data: extend(pack(outmsg)), last: (loc == -1) });
     endrule
  
     AxiStreamSlave#(32) msgFromSoftwareStream <- mkAxiStream(msgFromSoftwareFifo);
  