anchor.diff:      method Action             wrissuecap1_en(Bit#(1) v);
   endinterface
   
  +interface AxiMasterWires;
  +   interface Wire#(Bit#(1)) arready;
  +   interface Wire#(Bit#(1)) awready;
  +   interface Wire#(Bit#(1)) rvalid;
  +   interface Wire#(Bit#(1)) wready;
  +   interface Wire#(Bit#(1)) bvalid;
  +endinterface
  +
  +interface AxiSlaveWires;
  +   interface Wire#(Bit#(1)) arvalid;
  +   interface Wire#(Bit#(1)) awvalid;
  +   interface Wire#(Bit#(1)) rready;
  +   interface Wire#(Bit#(1)) wvalid;
  +   interface Wire#(Bit#(1)) bready;
  +endinterface
  +
  +module mkAxiMasterWires(AxiMasterWires);
  +   Vector#(5, Wire#(Bit#(1))) wires <- replicateM(mkDWire(0));
  +   interface Wire arready = wires[0];
  +   interface Wire awready = wires[1];
  +   interface Wire rvalid = wires[2];
  +   interface Wire wready = wires[3];
  +   interface Wire bvalid = wires[4];
  +endmodule
  +
  +module mkAxiSlaveWires(AxiSlaveWires);
  +   Vector#(5, Wire#(Bit#(1))) wires <- replicateM(mkDWire(0));
  +   interface Wire arready = wires[0];
  +   interface Wire awready = wires[1];
  +   interface Wire rvalid = wires[2];
  +   interface Wire wready = wires[3];
  +   interface Wire bvalid = wires[4];
  +endmodule
  +
   (* always_ready, always_enabled *)
   interface Bidir#(numeric type data_width);
       method Action             i(Bit#(data_width) v);
  
positive.code:                     vs_axi_gp[i].awprot(v.prot);
                      vs_axi_gp[i].awqos(v.qos);
                      vs_axi_gp[i].awsize(v.size);
                  endmethod
              endinterface
              interface Put resp_write;
                  method Action put(AxiWrite#(32, id_width) v);
                      vs_axi_gp[i].wid(v.wid);
                      vs_axi_gp[i].wstrb(v.wstrb);
                      vs_axi_gp[i].wdata(v.wd.data);
                      vs_axi_gp[i].wlast(v.wd.last);
                  endmethod
              endinterface
              interface Get resp_read;
                  method ActionValue#(AxiRead#(32, id_width)) get();
                      AxiRead#(32, id_width) v;
                      v.r.id = vs_axi_gp[i].rid();
                      v.r.resp = vs_axi_gp[i].rresp();
                      v.rd.data = vs_axi_gp[i].rdata();
                      v.rd.last = vs_axi_gp[i].rlast();
                      return v;
                  endmethod
              endinterface
              interface Get resp_b;
                  method ActionValue#(AxiRESP#(id_width)) get();
                      AxiRESP#(id_width) v;
                      v.id = vs_axi_gp[i].bid();
                      v.resp = vs_axi_gp[i].bresp();
                      return v;
                  endmethod
              endinterface
              method aclk = vs_axi_gp[i].aclk;
              method aresetn = vs_axi_gp[i].aresetn;
              method arvalid = vs_axi_gp[i].arvalid;
              method arready = vs_axi_gp[i].arready;
              method awvalid = vs_axi_gp[i].awvalid;
              method awready = vs_axi_gp[i].awready;
              method rvalid = vs_axi_gp[i].rvalid;
              method rready() = vs_axi_gp[i].rready;
              method wvalid() = vs_axi_gp[i].wvalid;
              method wready = vs_axi_gp[i].wready;
              method bvalid = vs_axi_gp[i].bvalid;
              method bready = vs_axi_gp[i].bready;
          endinterface;
      for (Integer i = 0; i < 4; i = i + 1)
          vtops_axi_hp[i] = interface AxiSlaveHighSpeed#(data_width, id_width);
              interface AxiSlaveCommon axi;
              interface Put req_ar;
                  method Action put(AxiREQ#(id_width) v);
                      vs_axi_hp[i].araddr(v.addr);
                      vs_axi_hp[i].arburst(v.burst);
                      vs_axi_hp[i].arcache(v.cache);
  
negative.code:                      v.prot = vm_axi_gp[i].awprot();
                       v.qos = vm_axi_gp[i].awqos();
                       v.size = vm_axi_gp[i].awsize();
  
  	             vtopmw_axi_gp[i].awready <= 1;
                       return v;
                  endmethod
              endinterface
              interface Put resp_read;
                  method Action put(AxiRead#(32, id_width) v) if (vm_axi_gp[i].rready());
                      vm_axi_gp[i].rid(v.r.id);
                      vm_axi_gp[i].rresp(v.r.resp);
                      vm_axi_gp[i].rdata(v.rd.data);
                      vm_axi_gp[i].rlast(v.rd.last);
  
  	            vtopmw_axi_gp[i].rvalid <= 1;
                  endmethod
              endinterface
              interface Get resp_write;
                   method ActionValue#(AxiWrite#(32, id_width)) get() if (vm_axi_gp[i].wvalid());
                       AxiWrite#(32, id_width) v;
                       v.wid = vm_axi_gp[i].wid();
                       v.wstrb = vm_axi_gp[i].wstrb();
                       v.wd.data = vm_axi_gp[i].wdata();
                       v.wd.last = vm_axi_gp[i].wlast();
  
  	             vtopmw_axi_gp[i].wready <= 1;
                       return v;
                  endmethod
              endinterface
              interface Put resp_b;
                  method Action put(AxiRESP#(id_width) v) if (vm_axi_gp[i].bready());
                      vm_axi_gp[i].bid(v.id);
                      vm_axi_gp[i].bresp(v.resp);
  	       
  	            vtopmw_axi_gp[i].bvalid <= 1;
                  endmethod
              endinterface
              method aclk = vm_axi_gp[i].aclk;
              method aresetn = vm_axi_gp[i].aresetn;
              endinterface;
      for (Integer i = 0; i < 2; i = i + 1)
         rule axi_master_handshake;
  	    vs_axi_gp[i].arvalid(vtopsw_axi_gp[i].arvalid);
  	    vs_axi_gp[i].awvalid(vtopsw_axi_gp[i].awvalid);
              vs_axi_gp[i].rready(vtopsw_axi_gp[i].rready);
  	    vs_axi_gp[i].wvalid(vtopsw_axi_gp[i].wvalid);
              vs_axi_gp[i].bready(vtopsw_axi_gp[i].bready);
         endrule
      for (Integer i = 0; i < 2; i = i + 1)
          vtops_axi_gp[i] = interface AxiSlaveCommon#(32, id_width);
              interface Put req_ar;
                  method Action put(AxiREQ#(id_width) v) if (vs_axi_gp[i].arready());
                      vs_axi_gp[i].araddr(v.addr);
                      vs_axi_gp[i].arburst(v.burst);
                      vs_axi_gp[i].arcache(v.cache);
  