diff --git a/src/com/xilinx/rapidwright/examples/ClockSignalTracer.java b/src/com/xilinx/rapidwright/examples/ClockSignalTracer.java new file mode 100644 index 000000000..766ef674f --- /dev/null +++ b/src/com/xilinx/rapidwright/examples/ClockSignalTracer.java @@ -0,0 +1,1501 @@ +/* + * Copyright (c) 2025, Advanced Micro Devices, Inc. + * All rights reserved. + * + * Author: Chris Lavin, AMD Research and Advanced Development. + * + * This file is part of RapidWright. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package com.xilinx.rapidwright.examples; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.Set; + +import com.xilinx.rapidwright.design.Design; +import com.xilinx.rapidwright.edif.EDIFHierNet; +import com.xilinx.rapidwright.edif.EDIFHierPortInst; +import com.xilinx.rapidwright.edif.EDIFNetlist; +import com.xilinx.rapidwright.edif.EDIFTools; + +/** + * Example of how to traverse signal nets to identify source clocks. + */ +public class ClockSignalTracer { + + private static List getSignalInputs(EDIFHierPortInst output) { + List inputs = new ArrayList<>(); + Map> entry = ClockSignalTracer.map.get(output.getCellType().getName()); + if (entry == null) { + return Collections.emptyList(); + } + Set propInputs = entry.get(output.getPortInst().getName()); + if (propInputs != null) { + for (String input : propInputs) { + EDIFHierPortInst portInst = output.getFullHierarchicalInst().getPortInst(input); + if (portInst == null) { + continue; + } + inputs.add(portInst); + } + } + return inputs; + } + + private static String getSynchronizerClkName(EDIFHierPortInst output) { + String clkPin = synchronizerCells.get(output.getCellType().getName()); + if (clkPin != null && clkPin.contains(",")) { + // TODO distinguish between Port A and B outputs on RAMB cells + } + return clkPin; + } + + public static Set getClockNetsUpstreamFromPin(String pinName, EDIFNetlist n) { + EDIFHierPortInst pin = n.getHierPortInstFromName(pinName); + return getClockNetsUpstreamFromPin(pin); + } + + public static Set getClockNetsUpstreamFromPin(EDIFHierPortInst pin) { + Set clocks = new HashSet<>(); + Queue q = new LinkedList<>(); + if (pin.isOutput()) { + String clkPin = getSynchronizerClkName(pin); + if (clkPin != null) { + EDIFHierPortInst clkInput = pin.getFullHierarchicalInst().getPortInst(clkPin); + if (clkInput != null) { + EDIFHierNet localClkNet = clkInput.getHierarchicalNet(); + for (EDIFHierPortInst clkSrc : localClkNet.getLeafHierPortInsts(true, false)) { + clocks.add(clkSrc.getHierarchicalNet()); + } + return clocks; + } + } + q.addAll(getSignalInputs(pin)); + } else { + q.add(pin); + } + + while (!q.isEmpty()) { + EDIFHierPortInst curr = q.poll(); + for (EDIFHierPortInst src : curr.getHierarchicalNet().getLeafHierPortInsts(true, false)) { + String clkPin = getSynchronizerClkName(src); + if (clkPin != null) { + EDIFHierPortInst clkInput = src.getFullHierarchicalInst().getPortInst(clkPin); + if (clkInput == null) { + continue; + } + EDIFHierNet localClkNet = clkInput.getHierarchicalNet(); + for (EDIFHierPortInst clkSrc : localClkNet.getLeafHierPortInsts(true, false)) { + clocks.add(clkSrc.getHierarchicalNet()); + } + } else { + q.addAll(getSignalInputs(src)); + } + } + } + + return clocks; + } + + // TODO Incomplete list of synchronizer cells + private static Map synchronizerCells; + + static { + synchronizerCells = new HashMap<>(); + synchronizerCells.put("FDRE", "C"); + synchronizerCells.put("FDCE", "C"); + synchronizerCells.put("FDPE", "C"); + synchronizerCells.put("FDSE", "C"); + synchronizerCells.put("LDCE", "G"); + synchronizerCells.put("LDPE", "G"); + + synchronizerCells.put("HARD_SYNC", "CLK"); + + synchronizerCells.put("SRL16E", "CLK"); + synchronizerCells.put("SRLC32E", "CLK"); + synchronizerCells.put("IDDR", "C"); + synchronizerCells.put("ODDR", "C"); + synchronizerCells.put("IDDRE1", "C"); + synchronizerCells.put("ODDRE1", "C"); + + synchronizerCells.put("DSP48E2", "CLK"); + synchronizerCells.put("DSP58", "CLK"); + synchronizerCells.put("DSPCPLX", "CLK"); + synchronizerCells.put("DSPFP32", "CLK"); + + synchronizerCells.put("FIFO18E2", "RDCLK"); + synchronizerCells.put("FIFO36E2", "RDCLK"); + synchronizerCells.put("FIFO18E5", "RDCLK"); + synchronizerCells.put("FIFO36E5", "RDCLK"); + + synchronizerCells.put("RAMB18E2", "CLKARDCLK,CLKBRDCLK"); + synchronizerCells.put("RAMB36E2", "CLKARDCLK,CLKBRDCLK"); + synchronizerCells.put("RAMB18E5", "CLKARDCLK,CLKBRDCLK"); + synchronizerCells.put("RAMB36E5", "CLKARDCLK,CLKBRDCLK"); + + synchronizerCells.put("URAM288E2", "CLK"); + synchronizerCells.put("URAM288E2_BASE", "CLK"); + synchronizerCells.put("URAM288E5", "CLK"); + synchronizerCells.put("URAM288E5_BASE", "CLK"); + } + + // TODO Only contains a limited subset of Unisim cells + public static Map>> map; + static { + map = new HashMap<>(); + HashMap> m = null; + m = new HashMap<>(); + map.put("AIE_PL_M_AXIS32", m); + m.put("M_AXIS_TDATA[19]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[29]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[17]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[27]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TLAST", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[7]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[9]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[11]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[3]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[21]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[31]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[5]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[15]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[25]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[13]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[23]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[1]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TKEEP", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[18]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[28]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[16]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[8]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[4]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[22]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[10]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[6]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[20]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[30]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[26]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[0]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[14]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[2]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[24]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[12]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TVALID", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m = new HashMap<>(); + map.put("AIE_PL_M_AXIS64", m); + m.put("M_AXIS_TDATA[19]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[39]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[27]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[7]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[55]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[11]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[43]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[3]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[31]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[63]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[59]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[15]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[47]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[35]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[23]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[51]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[28]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[16]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[8]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[4]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[44]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[32]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[20]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[52]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[48]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[0]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[36]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[24]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[56]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[12]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TVALID", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[40]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[60]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[29]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[17]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[49]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TLAST", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[9]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[33]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[21]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[53]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[5]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[41]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[37]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[25]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[57]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[13]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[45]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[1]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[61]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TKEEP", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[18]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[38]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[22]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[54]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[10]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[6]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[42]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[30]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[26]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[58]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[14]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[46]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[2]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[34]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[62]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m.put("M_AXIS_TDATA[50]", new HashSet<>(Arrays.asList("M_AXIS_ACLK"))); + m = new HashMap<>(); + map.put("AIE_PL_M_EVENTS", m); + m.put("TRIG[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[5]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[11]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[10]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[13]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[12]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[9]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[15]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TRIG[14]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("AIE_PL_S_AXIS128", m); + m = new HashMap<>(); + map.put("AIE_PL_S_AXIS32", m); + m.put("S_AXIS_TREADY", new HashSet<>(Arrays.asList("S_AXIS_ACLK"))); + m = new HashMap<>(); + map.put("AIE_PL_S_AXIS64", m); + m.put("S_AXIS_TREADY", new HashSet<>(Arrays.asList("S_AXIS_ACLK"))); + m = new HashMap<>(); + map.put("AIE_PL_S_EVENTS", m); + m = new HashMap<>(); + map.put("AND2B1L", m); + m.put("O", new HashSet<>(Arrays.asList("DI","SRI"))); + m = new HashMap<>(); + map.put("AUTOBUF", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("AXI32", m); + m = new HashMap<>(); + map.put("BFR_FT", m); + m = new HashMap<>(); + map.put("BIBUF", m); + m = new HashMap<>(); + map.put("BITSLICE_CONTROL", m); + m.put("RIU_RD_DATA[12]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT1[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[14]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[1]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT3[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("TX_BIT_CTRL_OUT5[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[10]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_VALID", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT2[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("DLY_RDY", new HashSet<>(Arrays.asList("RIU_CLK","PLL_CLK"))); + m.put("TX_BIT_CTRL_OUT0[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("TX_BIT_CTRL_OUT4[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[3]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[5]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[7]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT6[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[9]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[13]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[15]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT1[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[0]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[2]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("VTC_RDY", new HashSet<>(Arrays.asList("RIU_CLK","PLL_CLK"))); + m.put("TX_BIT_CTRL_OUT3[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[11]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT5[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("TX_BIT_CTRL_OUT2[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RX_BIT_CTRL_OUT0[20]", new HashSet<>(Arrays.asList("RX_BIT_CTRL_IN0[9]","PLL_CLK"))); + m.put("RIU_RD_DATA[4]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("RIU_RD_DATA[6]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT0[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("RIU_RD_DATA[8]", new HashSet<>(Arrays.asList("RIU_CLK"))); + m.put("TX_BIT_CTRL_OUT6[25]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m.put("TX_BIT_CTRL_OUT4[26]", new HashSet<>(Arrays.asList("PLL_CLK"))); + m = new HashMap<>(); + map.put("BSCANE2", m); + m = new HashMap<>(); + map.put("BUF", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFCE_LEAF", m); + m.put("O", new HashSet<>(Arrays.asList("CE","I"))); + m = new HashMap<>(); + map.put("BUFCE_ROW", m); + m.put("O", new HashSet<>(Arrays.asList("CE","I"))); + m = new HashMap<>(); + map.put("BUFDIV_LEAF", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFG", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFGCE", m); + m.put("O", new HashSet<>(Arrays.asList("CE","I"))); + m = new HashMap<>(); + map.put("BUFGCE_DIV", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFGCTRL", m); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","CE1","CE0"))); + m = new HashMap<>(); + map.put("BUFGP", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFG_FABRIC", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFG_GT", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFG_GT_SYNC", m); + m = new HashMap<>(); + map.put("BUFG_HM", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFG_PS", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFH", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFHCE", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFIO", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFMR", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFMRCE", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("BUFR", m); + m.put("O", new HashSet<>(Arrays.asList("CLR","I"))); + m = new HashMap<>(); + map.put("CAPTUREE2", m); + m = new HashMap<>(); + map.put("CARRY4", m); + m.put("O[2]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("O[3]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("CO[0]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("O[0]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("CO[3]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("O[1]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("CO[1]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m.put("CO[2]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","CYINIT"))); + m = new HashMap<>(); + map.put("CARRY8", m); + m.put("CO[7]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","DI[0]","CI","S[6]","S[7]","S[0]","S[1]","S[2]","S[3]","S[4]","S[5]","CI_TOP","DI[7]","DI[6]","DI[5]","DI[4]"))); + m.put("CO[5]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","DI[0]","CI","S[0]","S[1]","S[2]","S[3]","S[4]","S[5]","CI_TOP","DI[5]","DI[4]"))); + m.put("CO[6]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","DI[0]","CI","S[6]","S[0]","S[1]","S[2]","S[3]","S[4]","S[5]","CI_TOP","DI[6]","DI[5]","DI[4]"))); + m.put("CO[0]", new HashSet<>(Arrays.asList("S[0]","DI[0]","CI"))); + m.put("CO[3]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI"))); + m.put("CO[4]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","S[4]","CI_TOP","DI[4]"))); + m.put("CO[1]", new HashSet<>(Arrays.asList("DI[1]","S[0]","DI[0]","S[1]","CI"))); + m.put("CO[2]", new HashSet<>(Arrays.asList("DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","CI"))); + m.put("O[4]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI","S[4]","CI_TOP"))); + m.put("O[5]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","DI[0]","CI","S[0]","S[1]","S[2]","S[3]","S[4]","S[5]","CI_TOP","DI[4]"))); + m.put("O[2]", new HashSet<>(Arrays.asList("DI[1]","S[0]","DI[0]","S[1]","S[2]","CI"))); + m.put("O[3]", new HashSet<>(Arrays.asList("DI[2]","DI[1]","S[0]","DI[0]","S[1]","S[2]","S[3]","CI"))); + m.put("O[6]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","DI[0]","CI","S[6]","S[0]","S[1]","S[2]","S[3]","S[4]","S[5]","CI_TOP","DI[5]","DI[4]"))); + m.put("O[7]", new HashSet<>(Arrays.asList("DI[3]","DI[2]","DI[1]","DI[0]","CI","S[6]","S[7]","S[0]","S[1]","S[2]","S[3]","S[4]","S[5]","CI_TOP","DI[6]","DI[5]","DI[4]"))); + m.put("O[0]", new HashSet<>(Arrays.asList("S[0]","DI[0]","CI"))); + m.put("O[1]", new HashSet<>(Arrays.asList("S[0]","DI[0]","S[1]","CI"))); + m = new HashMap<>(); + map.put("CFGLUT5", m); + m.put("O5", new HashSet<>(Arrays.asList("CLK","I0","I1","I2","I3","I4"))); + m.put("O6", new HashSet<>(Arrays.asList("CLK","I0","I1","I2","I3","I4"))); + m.put("CDO", new HashSet<>(Arrays.asList("CLK","I0","I1","I2","I3","I4"))); + m = new HashMap<>(); + map.put("CLOCK_MOD_CLE_FF", m); + m.put("CLK_OUT", new HashSet<>(Arrays.asList("CLK_IN"))); + m = new HashMap<>(); + map.put("CLOCK_MOD_CLE_IMR", m); + m.put("CLK_OUT", new HashSet<>(Arrays.asList("CLK_IN"))); + m = new HashMap<>(); + map.put("CLOCK_MOD_IRI_FF", m); + m = new HashMap<>(); + map.put("CLOCK_MOD_IRI_IMR", m); + m = new HashMap<>(); + map.put("CPM", m); + m = new HashMap<>(); + map.put("DCIRESET", m); + m.put("LOCKED", new HashSet<>(Arrays.asList("RST"))); + m = new HashMap<>(); + map.put("DCM_ADV", m); + m = new HashMap<>(); + map.put("DCM_SP", m); + m = new HashMap<>(); + map.put("DDRMC", m); + m = new HashMap<>(); + map.put("DDRMC5", m); + m = new HashMap<>(); + map.put("DDRMC5C", m); + m = new HashMap<>(); + map.put("DDRMC5E", m); + m = new HashMap<>(); + map.put("DDRMC_RIU", m); + m = new HashMap<>(); + map.put("DFE_CFR", m); + m = new HashMap<>(); + map.put("DFE_CHANNELIZER", m); + m = new HashMap<>(); + map.put("DFE_FIR", m); + m = new HashMap<>(); + map.put("DFE_MATRIX_FIR", m); + m = new HashMap<>(); + map.put("DFE_NL_FIR", m); + m = new HashMap<>(); + map.put("DFE_PQ_DECIM", m); + m = new HashMap<>(); + map.put("DFE_PQ_INTERP", m); + m = new HashMap<>(); + map.put("DIFFINBUF", m); + m.put("O_B", new HashSet<>(Arrays.asList("OSC_EN[1]","OSC_EN[0]","OSC[3]","DIFF_IN_P","OSC[2]","OSC[1]","DIFF_IN_N","OSC[0]"))); + m.put("O", new HashSet<>(Arrays.asList("OSC_EN[1]","OSC_EN[0]","OSC[3]","DIFF_IN_P","OSC[2]","OSC[1]","DIFF_IN_N","OSC[0]"))); + m = new HashMap<>(); + map.put("DNA_PORT", m); + m.put("DOUT", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("DNA_PORTE2", m); + m.put("DOUT", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("DPHY_DIFFINBUF", m); + m.put("LPRX_O_N", new HashSet<>(Arrays.asList("IB","LPRX_DISABLE"))); + m.put("HSRX_O", new HashSet<>(Arrays.asList("HSRX_DISABLE","I","IB"))); + m.put("LPRX_O_P", new HashSet<>(Arrays.asList("I","LPRX_DISABLE"))); + m = new HashMap<>(); + map.put("DPLL", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("PSDONE", new HashSet<>(Arrays.asList("PSCLK"))); + m.put("CLKOUT3", new HashSet<>(Arrays.asList("CLKIN"))); + m.put("CLKOUT2", new HashSet<>(Arrays.asList("CLKIN"))); + m.put("CLKOUT1", new HashSet<>(Arrays.asList("CLKIN"))); + m.put("CLKOUT0", new HashSet<>(Arrays.asList("CLKIN"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("EFUSE_USR", m); + m = new HashMap<>(); + map.put("FDCE", m); + m.put("Q", new HashSet<>(Arrays.asList("C","CLR"))); + m = new HashMap<>(); + map.put("FDPE", m); + m.put("Q", new HashSet<>(Arrays.asList("PRE","C"))); + m = new HashMap<>(); + map.put("FDRE", m); + m.put("Q", new HashSet<>(Arrays.asList("C"))); + m = new HashMap<>(); + map.put("FDSE", m); + m.put("Q", new HashSet<>(Arrays.asList("C"))); + m = new HashMap<>(); + map.put("ICAPE2", m); + m.put("O", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("ICAPE3", m); + m.put("O[17]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[29]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[19]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[13]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[25]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[15]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[27]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[31]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[21]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[5]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[11]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[23]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[9]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("PRDONE", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[28]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[18]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[24]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[14]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[26]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[16]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[20]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[10]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[22]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[12]", new HashSet<>(Arrays.asList("CLK"))); + m.put("PRERROR", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[30]", new HashSet<>(Arrays.asList("CLK"))); + m.put("O[0]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("IDDR", m); + m.put("Q1", new HashSet<>(Arrays.asList("R","C","S"))); + m.put("Q2", new HashSet<>(Arrays.asList("R","C","S"))); + m = new HashMap<>(); + map.put("IDDRE1", m); + m.put("Q1", new HashSet<>(Arrays.asList("C","D","CB"))); + m.put("Q2", new HashSet<>(Arrays.asList("C","CB"))); + m = new HashMap<>(); + map.put("IDDR_2CLK", m); + m.put("Q1", new HashSet<>(Arrays.asList("R","C","S","CB"))); + m.put("Q2", new HashSet<>(Arrays.asList("R","C","S","CB"))); + m = new HashMap<>(); + map.put("IDELAYCTRL", m); + m.put("RDY", new HashSet<>(Arrays.asList("RST","REFCLK"))); + m = new HashMap<>(); + map.put("IDELAYE2", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("DATAOUT", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m = new HashMap<>(); + map.put("IDELAYE2_FINEDELAY", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("DATAOUT", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m = new HashMap<>(); + map.put("IDELAYE3", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("IDELAYE5", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("DATAOUT", new HashSet<>(Arrays.asList("CASC_RETURN","IDATAIN"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CASC_OUT", new HashSet<>(Arrays.asList("IDATAIN"))); + m = new HashMap<>(); + map.put("IMC_FF", m); + m.put("Q", new HashSet<>(Arrays.asList("CLK","D"))); + m = new HashMap<>(); + map.put("IMI_FF", m); + m.put("Q", new HashSet<>(Arrays.asList("CLK","D"))); + m = new HashMap<>(); + map.put("INBUF", m); + m.put("O", new HashSet<>(Arrays.asList("PAD","OSC[3]","OSC[2]","OSC[1]","OSC[0]","OSC_EN"))); + m = new HashMap<>(); + map.put("INV", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("ISERDES", m); + m.put("Q1", new HashSet<>(Arrays.asList("CLKDIV","SR"))); + m.put("Q2", new HashSet<>(Arrays.asList("CLKDIV","SR"))); + m.put("Q3", new HashSet<>(Arrays.asList("CLKDIV","SR"))); + m.put("Q4", new HashSet<>(Arrays.asList("CLKDIV","SR"))); + m.put("Q5", new HashSet<>(Arrays.asList("CLKDIV","SR"))); + m.put("Q6", new HashSet<>(Arrays.asList("CLKDIV","SR"))); + m.put("O", new HashSet<>(Arrays.asList("D"))); + m = new HashMap<>(); + map.put("ISERDESE1", m); + m.put("Q1", new HashSet<>(Arrays.asList("RST","CLK","CLKDIV"))); + m.put("Q2", new HashSet<>(Arrays.asList("RST","CLK","CLKDIV"))); + m.put("Q3", new HashSet<>(Arrays.asList("RST","CLK","CLKDIV"))); + m.put("Q4", new HashSet<>(Arrays.asList("RST","CLK","CLKDIV"))); + m.put("Q5", new HashSet<>(Arrays.asList("RST","CLK","CLKDIV"))); + m.put("Q6", new HashSet<>(Arrays.asList("RST","CLK","CLKDIV"))); + m.put("O", new HashSet<>(Arrays.asList("DDLY","D","OFB"))); + m = new HashMap<>(); + map.put("ISERDESE2", m); + m.put("Q1", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q2", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q3", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q4", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q5", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q6", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q7", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("Q8", new HashSet<>(Arrays.asList("CLK","CLKDIVP","CLKDIV"))); + m.put("O", new HashSet<>(Arrays.asList("DDLY","D","OFB"))); + m = new HashMap<>(); + map.put("ISERDESE3", m); + m.put("Q[1]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("Q[0]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("Q[3]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("Q[2]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("Q[5]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("INTERNAL_DIVCLK", new HashSet<>(Arrays.asList("CLK"))); + m.put("Q[4]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("Q[7]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("Q[6]", new HashSet<>(Arrays.asList("CLK","CLK_B","FIFO_RD_CLK"))); + m.put("FIFO_EMPTY", new HashSet<>(Arrays.asList("CLK","FIFO_RD_CLK"))); + m = new HashMap<>(); + map.put("ISERDES_NODELAY", m); + m = new HashMap<>(); + map.put("JTAG_SIME2", m); + m = new HashMap<>(); + map.put("KEEPER", m); + m = new HashMap<>(); + map.put("LCLK_DELAY", m); + m.put("O_CASC", new HashSet<>(Arrays.asList("I","I_CASC"))); + m.put("O", new HashSet<>(Arrays.asList("I","I_CASC"))); + m = new HashMap<>(); + map.put("LDCE", m); + m.put("Q", new HashSet<>(Arrays.asList("D","G","CLR","GE"))); + m = new HashMap<>(); + map.put("LDPE", m); + m.put("Q", new HashSet<>(Arrays.asList("PRE","D","G","GE"))); + m = new HashMap<>(); + map.put("LOOKAHEAD8", m); + m.put("COUTB", new HashSet<>(Arrays.asList("GEA","PROPB","PROPA","GEB","CIN","CYA","CYB"))); + m.put("COUTH", new HashSet<>(Arrays.asList("PROPH","PROPG","CYA","CYC","PROPD","CYB","PROPC","CYE","PROPF","CYD","PROPE","CYG","CYF","CYH","GEA","GEC","GEB","GEE","GED","GEG","CIN","GEF","GEH","PROPB","PROPA"))); + m.put("COUTD", new HashSet<>(Arrays.asList("GEA","GEC","GEB","GED","CIN","CYA","CYC","PROPD","CYB","PROPC","CYD","PROPB","PROPA"))); + m.put("COUTF", new HashSet<>(Arrays.asList("GEA","GEC","GEB","GEE","GED","CIN","GEF","CYA","CYC","PROPD","CYB","PROPC","CYE","PROPF","CYD","PROPE","CYF","PROPB","PROPA"))); + m = new HashMap<>(); + map.put("LUT1", m); + m.put("O", new HashSet<>(Arrays.asList("I0"))); + m = new HashMap<>(); + map.put("LUT2", m); + m.put("O", new HashSet<>(Arrays.asList("I0","I1"))); + m = new HashMap<>(); + map.put("LUT3", m); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","I2"))); + m = new HashMap<>(); + map.put("LUT4", m); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","I2","I3"))); + m = new HashMap<>(); + map.put("LUT5", m); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4"))); + m = new HashMap<>(); + map.put("LUT6", m); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4","I5"))); + m = new HashMap<>(); + map.put("LUT6CY", m); + m = new HashMap<>(); + map.put("LUT6_2", m); + m.put("O5", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4"))); + m.put("O6", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4","I5"))); + m = new HashMap<>(); + map.put("LUTCY1", m); + m.put("PROP", new HashSet<>(Arrays.asList("I0","I1","I2","I3"))); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4"))); + m = new HashMap<>(); + map.put("LUTCY2", m); + m.put("GE", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4"))); + m.put("O", new HashSet<>(Arrays.asList("I0","I1","I2","I3","I4"))); + m = new HashMap<>(); + map.put("MASTER_JTAG", m); + m = new HashMap<>(); + map.put("MBUFGCE", m); + m.put("O1", new HashSet<>(Arrays.asList("CE","I"))); + m.put("O2", new HashSet<>(Arrays.asList("CE","I"))); + m.put("O3", new HashSet<>(Arrays.asList("CE","I"))); + m.put("O4", new HashSet<>(Arrays.asList("CE","I"))); + m = new HashMap<>(); + map.put("MBUFGCE_DIV", m); + m.put("O1", new HashSet<>(Arrays.asList("I"))); + m.put("O2", new HashSet<>(Arrays.asList("I"))); + m.put("O3", new HashSet<>(Arrays.asList("I"))); + m.put("O4", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("MBUFGCTRL", m); + m.put("O1", new HashSet<>(Arrays.asList("I0","I1","S0","CE1","S1","CE0"))); + m.put("O2", new HashSet<>(Arrays.asList("I0","I1","S0","CE1","S1","CE0"))); + m.put("O3", new HashSet<>(Arrays.asList("I0","I1","S0","CE1","S1","CE0"))); + m.put("O4", new HashSet<>(Arrays.asList("I0","I1","S0","CE1","S1","CE0"))); + m = new HashMap<>(); + map.put("MBUFG_GT", m); + m.put("O1", new HashSet<>(Arrays.asList("I"))); + m.put("O2", new HashSet<>(Arrays.asList("I"))); + m.put("O3", new HashSet<>(Arrays.asList("I"))); + m.put("O4", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("MBUFG_HM", m); + m.put("O1", new HashSet<>(Arrays.asList("I"))); + m.put("O2", new HashSet<>(Arrays.asList("I"))); + m.put("O3", new HashSet<>(Arrays.asList("I"))); + m.put("O4", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("MBUFG_PS", m); + m.put("O1", new HashSet<>(Arrays.asList("I"))); + m.put("O2", new HashSet<>(Arrays.asList("I"))); + m.put("O3", new HashSet<>(Arrays.asList("I"))); + m.put("O4", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("MMCME2_ADV", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("LOCKED", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("PSDONE", new HashSet<>(Arrays.asList("PSCLK"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("MMCME2_BASE", m); + m = new HashMap<>(); + map.put("MMCME3_ADV", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("LOCKED", new HashSet<>(Arrays.asList("PWRDWN","CLKIN1","CLKIN2"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("CLKINSTOPPED", new HashSet<>(Arrays.asList("PWRDWN"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("CLKFBSTOPPED", new HashSet<>(Arrays.asList("PWRDWN"))); + m.put("PSDONE", new HashSet<>(Arrays.asList("PSCLK"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("MMCME3_BASE", m); + m = new HashMap<>(); + map.put("MMCME4_ADV", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("PSDONE", new HashSet<>(Arrays.asList("PSCLK"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("MMCME4_BASE", m); + m = new HashMap<>(); + map.put("MMCME5", m); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("CLKFBOUT", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("PSDONE", new HashSet<>(Arrays.asList("PSCLK"))); + m.put("CLKOUT3", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("CLKOUT2", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("CLKOUT1", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("CLKOUT0", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("CLKOUT6", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("CLKOUT5", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m.put("CLKOUT4", new HashSet<>(Arrays.asList("CLKIN1","CLKIN2"))); + m = new HashMap<>(); + map.put("MUXCY", m); + m.put("O", new HashSet<>(Arrays.asList("S","DI","CI"))); + m = new HashMap<>(); + map.put("MUXF7", m); + m.put("O", new HashSet<>(Arrays.asList("S","I0","I1"))); + m = new HashMap<>(); + map.put("MUXF8", m); + m.put("O", new HashSet<>(Arrays.asList("S","I0","I1"))); + m = new HashMap<>(); + map.put("MUXF9", m); + m.put("O", new HashSet<>(Arrays.asList("S","I0","I1"))); + m = new HashMap<>(); + map.put("NOC2_NMU128", m); + m = new HashMap<>(); + map.put("NOC2_NMU256", m); + m = new HashMap<>(); + map.put("NOC2_NMU512", m); + m = new HashMap<>(); + map.put("NOC2_NPS5555", m); + m = new HashMap<>(); + map.put("NOC2_NPS6X", m); + m = new HashMap<>(); + map.put("NOC2_NPS7575", m); + m = new HashMap<>(); + map.put("NOC2_NSU128", m); + m = new HashMap<>(); + map.put("NOC2_NSU256", m); + m = new HashMap<>(); + map.put("NOC2_NSU512", m); + m = new HashMap<>(); + map.put("NOC2_XBR2X4", m); + m = new HashMap<>(); + map.put("NOC2_XBR4X2", m); + m = new HashMap<>(); + map.put("NOC_NCRB", m); + m = new HashMap<>(); + map.put("NOC_NCRB_SSIT", m); + m = new HashMap<>(); + map.put("NOC_NIDB", m); + m = new HashMap<>(); + map.put("NOC_NMU128", m); + m = new HashMap<>(); + map.put("NOC_NMU256", m); + m = new HashMap<>(); + map.put("NOC_NMU512", m); + m = new HashMap<>(); + map.put("NOC_NMU_HBM2E", m); + m = new HashMap<>(); + map.put("NOC_NPP_RPTR", m); + m = new HashMap<>(); + map.put("NOC_NPS4", m); + m = new HashMap<>(); + map.put("NOC_NPS5555", m); + m = new HashMap<>(); + map.put("NOC_NPS6", m); + m = new HashMap<>(); + map.put("NOC_NPS7575", m); + m = new HashMap<>(); + map.put("NOC_NPS_VNOC", m); + m = new HashMap<>(); + map.put("NOC_NSU128", m); + m = new HashMap<>(); + map.put("NOC_NSU512", m); + m = new HashMap<>(); + map.put("NPI_NIR", m); + m = new HashMap<>(); + map.put("OBUF", m); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("OBUFDS", m); + m.put("OB", new HashSet<>(Arrays.asList("I"))); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("OBUFDS_COMP", m); + m.put("OB", new HashSet<>(Arrays.asList("I"))); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("OBUFDS_COMP_ODDR", m); + m = new HashMap<>(); + map.put("OBUFDS_DPHY", m); + m.put("OB", new HashSet<>(Arrays.asList("HSTX_T","LPTX_T","LPTX_I_N","HSTX_I"))); + m.put("O", new HashSet<>(Arrays.asList("HSTX_T","LPTX_T","LPTX_I_P","HSTX_I"))); + m = new HashMap<>(); + map.put("OBUFDS_DPHY_COMP", m); + m = new HashMap<>(); + map.put("OBUFDS_GTE3", m); + m.put("OB", new HashSet<>(Arrays.asList("I"))); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("OBUFDS_GTE3_ADV", m); + m.put("OB", new HashSet<>(Arrays.asList("CEB","I[1]","I[0]","I[3]","I[2]"))); + m.put("O", new HashSet<>(Arrays.asList("CEB","I[1]","I[0]","I[3]","I[2]"))); + m = new HashMap<>(); + map.put("OBUFDS_GTE4", m); + m.put("OB", new HashSet<>(Arrays.asList("I"))); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("OBUFDS_GTE4_ADV", m); + m.put("OB", new HashSet<>(Arrays.asList("CEB","I[1]","I[0]","I[3]","I[2]"))); + m.put("O", new HashSet<>(Arrays.asList("CEB","I[1]","I[0]","I[3]","I[2]"))); + m = new HashMap<>(); + map.put("OBUFDS_GTE5", m); + m = new HashMap<>(); + map.put("OBUFDS_GTE5_ADV", m); + m = new HashMap<>(); + map.put("OBUFDS_GTM", m); + m.put("OB", new HashSet<>(Arrays.asList("I"))); + m.put("O", new HashSet<>(Arrays.asList("I"))); + m = new HashMap<>(); + map.put("OBUFDS_GTME5", m); + m = new HashMap<>(); + map.put("OBUFDS_GTME5_ADV", m); + m = new HashMap<>(); + map.put("OBUFDS_GTM_ADV", m); + m.put("OB", new HashSet<>(Arrays.asList("CEB","I[1]","I[0]","I[3]","I[2]"))); + m.put("O", new HashSet<>(Arrays.asList("CEB","I[1]","I[0]","I[3]","I[2]"))); + m = new HashMap<>(); + map.put("OBUFDS_ODDR", m); + m = new HashMap<>(); + map.put("OBUFT", m); + m.put("O", new HashSet<>(Arrays.asList("T","I"))); + m = new HashMap<>(); + map.put("OBUFTDS", m); + m.put("OB", new HashSet<>(Arrays.asList("T","I"))); + m.put("O", new HashSet<>(Arrays.asList("T","I"))); + m = new HashMap<>(); + map.put("OBUFTDS_COMP", m); + m.put("OB", new HashSet<>(Arrays.asList("T","I"))); + m.put("O", new HashSet<>(Arrays.asList("T","I"))); + m = new HashMap<>(); + map.put("OBUFTDS_COMP_ODDR", m); + m = new HashMap<>(); + map.put("OBUFTDS_DCIEN", m); + m.put("OB", new HashSet<>(Arrays.asList("DCITERMDISABLE","T","I"))); + m.put("O", new HashSet<>(Arrays.asList("DCITERMDISABLE","T","I"))); + m = new HashMap<>(); + map.put("OBUFTDS_ODDR", m); + m = new HashMap<>(); + map.put("OBUFT_DCIEN", m); + m.put("O", new HashSet<>(Arrays.asList("DCITERMDISABLE","T","I"))); + m = new HashMap<>(); + map.put("OBUFT_ODDR", m); + m = new HashMap<>(); + map.put("OBUF_ODDR", m); + m = new HashMap<>(); + map.put("ODDR", m); + m.put("Q", new HashSet<>(Arrays.asList("R","C","S"))); + m = new HashMap<>(); + map.put("ODDRE1", m); + m.put("Q", new HashSet<>(Arrays.asList("C"))); + m = new HashMap<>(); + map.put("ODELAYE2", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("DATAOUT", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m = new HashMap<>(); + map.put("ODELAYE2_FINEDELAY", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("DATAOUT", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CINVCTRL","C"))); + m = new HashMap<>(); + map.put("ODELAYE3", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("ODELAYE5", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("TDATAOUT", new HashSet<>(Arrays.asList("TDATAIN"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("DATAOUT", new HashSet<>(Arrays.asList("CASC_IN","ODATAIN"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("OR2L", m); + m.put("O", new HashSet<>(Arrays.asList("DI","SRI"))); + m = new HashMap<>(); + map.put("OSERDES", m); + m.put("OQ", new HashSet<>(Arrays.asList("REV","CLK","SR"))); + m.put("TQ", new HashSet<>(Arrays.asList("REV","CLK","T1","SR"))); + m = new HashMap<>(); + map.put("OSERDESE1", m); + m.put("OQ", new HashSet<>(Arrays.asList("CLK","CLKPERF","CLKPERFDELAY"))); + m.put("OFB", new HashSet<>(Arrays.asList("CLK"))); + m.put("TQ", new HashSet<>(Arrays.asList("CLK","CLKPERF","CLKPERFDELAY","T1"))); + m = new HashMap<>(); + map.put("OSERDESE2", m); + m.put("TFB", new HashSet<>(Arrays.asList("CLK"))); + m.put("OQ", new HashSet<>(Arrays.asList("CLK"))); + m.put("OFB", new HashSet<>(Arrays.asList("CLK"))); + m.put("TQ", new HashSet<>(Arrays.asList("CLK","TBYTEIN","T1"))); + m.put("TBYTEOUT", new HashSet<>(Arrays.asList("T1"))); + m = new HashMap<>(); + map.put("OSERDESE3", m); + m.put("OQ", new HashSet<>(Arrays.asList("D[4]","D[3]","D[2]","CLK","D[1]","D[0]","CLKDIV","D[7]","D[6]","D[5]"))); + m.put("T_OUT", new HashSet<>(Arrays.asList("D[4]","D[3]","D[2]","CLK","D[1]","D[0]","T","CLKDIV","D[7]","D[6]","D[5]"))); + m = new HashMap<>(); + map.put("PLLE2_ADV", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("LOCKED", new HashSet<>(Arrays.asList("RST","CLKIN1","CLKIN2"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("PLLE2_BASE", m); + m = new HashMap<>(); + map.put("PLLE3_ADV", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("LOCKED", new HashSet<>(Arrays.asList("RST","PWRDWN"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("PLLE3_BASE", m); + m.put("LOCKED", new HashSet<>(Arrays.asList("RST"))); + m = new HashMap<>(); + map.put("PLLE4_ADV", m); + m.put("DO[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[9]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DO[1]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("PLLE4_BASE", m); + m = new HashMap<>(); + map.put("PS11", m); + m = new HashMap<>(); + map.put("PULLDOWN", m); + m = new HashMap<>(); + map.put("PULLUP", m); + m = new HashMap<>(); + map.put("PVT_SAS", m); + m = new HashMap<>(); + map.put("RAM128X1D", m); + m.put("DPO", new HashSet<>(Arrays.asList("DPRA[0]","DPRA[1]","WCLK","DPRA[4]","DPRA[5]","DPRA[2]","DPRA[3]","DPRA[6]"))); + m.put("SPO", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]","A[6]"))); + m = new HashMap<>(); + map.put("RAM128X1S", m); + m.put("O", new HashSet<>(Arrays.asList("A1","A2","A3","WCLK","A4","A5","A6","A0"))); + m = new HashMap<>(); + map.put("RAM256X1D", m); + m.put("DPO", new HashSet<>(Arrays.asList("DPRA[0]","DPRA[1]","WCLK","DPRA[4]","DPRA[5]","DPRA[2]","DPRA[3]","DPRA[6]","DPRA[7]"))); + m.put("SPO", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]","A[7]","A[6]"))); + m = new HashMap<>(); + map.put("RAM256X1S", m); + m.put("O", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]","A[7]","A[6]"))); + m = new HashMap<>(); + map.put("RAM32M", m); + m.put("DOA[1]", new HashSet<>(Arrays.asList("WCLK","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m.put("DOC[0]", new HashSet<>(Arrays.asList("ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m.put("DOB[1]", new HashSet<>(Arrays.asList("WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOB[0]", new HashSet<>(Arrays.asList("WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOA[0]", new HashSet<>(Arrays.asList("WCLK","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m.put("DOD[0]", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOD[1]", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOC[1]", new HashSet<>(Arrays.asList("ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m = new HashMap<>(); + map.put("RAM32M16", m); + m.put("DOG[0]", new HashSet<>(Arrays.asList("ADDRG[0]","ADDRG[2]","WCLK","ADDRG[1]","ADDRG[4]","ADDRG[3]"))); + m.put("DOD[0]", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOE[0]", new HashSet<>(Arrays.asList("ADDRE[3]","ADDRE[4]","ADDRE[1]","WCLK","ADDRE[2]","ADDRE[0]"))); + m.put("DOD[1]", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOC[1]", new HashSet<>(Arrays.asList("ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m.put("DOH[1]", new HashSet<>(Arrays.asList("ADDRH[0]","WCLK","ADDRH[1]","ADDRH[2]","ADDRH[3]","ADDRH[4]"))); + m.put("DOF[0]", new HashSet<>(Arrays.asList("ADDRF[1]","ADDRF[0]","ADDRF[3]","WCLK","ADDRF[2]","ADDRF[4]"))); + m.put("DOE[1]", new HashSet<>(Arrays.asList("ADDRE[3]","ADDRE[4]","ADDRE[1]","WCLK","ADDRE[2]","ADDRE[0]"))); + m.put("DOH[0]", new HashSet<>(Arrays.asList("ADDRH[0]","WCLK","ADDRH[1]","ADDRH[2]","ADDRH[3]","ADDRH[4]"))); + m.put("DOG[1]", new HashSet<>(Arrays.asList("ADDRG[0]","ADDRG[2]","WCLK","ADDRG[1]","ADDRG[4]","ADDRG[3]"))); + m.put("DOF[1]", new HashSet<>(Arrays.asList("ADDRF[1]","ADDRF[0]","ADDRF[3]","WCLK","ADDRF[2]","ADDRF[4]"))); + m.put("DOA[1]", new HashSet<>(Arrays.asList("WCLK","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m.put("DOC[0]", new HashSet<>(Arrays.asList("ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m.put("DOB[1]", new HashSet<>(Arrays.asList("WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOB[0]", new HashSet<>(Arrays.asList("WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOA[0]", new HashSet<>(Arrays.asList("WCLK","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m = new HashMap<>(); + map.put("RAM32X16DR8", m); + m.put("DOB", new HashSet<>(Arrays.asList("ADDRB[5]","WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOA", new HashSet<>(Arrays.asList("WCLK","ADDRA[5]","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m.put("DOD", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[5]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOC", new HashSet<>(Arrays.asList("ADDRC[5]","ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m.put("DOF", new HashSet<>(Arrays.asList("ADDRF[1]","ADDRF[0]","ADDRF[3]","WCLK","ADDRF[2]","ADDRF[5]","ADDRF[4]"))); + m.put("DOE", new HashSet<>(Arrays.asList("ADDRE[3]","ADDRE[4]","ADDRE[1]","WCLK","ADDRE[2]","ADDRE[0]","ADDRE[5]"))); + m.put("DOG", new HashSet<>(Arrays.asList("ADDRG[0]","ADDRG[2]","WCLK","ADDRG[1]","ADDRG[4]","ADDRG[3]","ADDRG[5]"))); + m.put("DOH[1]", new HashSet<>(Arrays.asList("ADDRH[0]","WCLK","ADDRH[1]","ADDRH[2]","ADDRH[3]","ADDRH[4]"))); + m.put("DOH[0]", new HashSet<>(Arrays.asList("ADDRH[0]","WCLK","ADDRH[1]","ADDRH[2]","ADDRH[3]","ADDRH[4]"))); + m = new HashMap<>(); + map.put("RAM32X1D", m); + m.put("DPO", new HashSet<>(Arrays.asList("WCLK","DPRA2","DPRA1","DPRA0","DPRA4","DPRA3"))); + m.put("SPO", new HashSet<>(Arrays.asList("A1","A2","A3","WCLK","A4","A0"))); + m = new HashMap<>(); + map.put("RAM32X1S", m); + m.put("O", new HashSet<>(Arrays.asList("A1","A2","A3","WCLK","A4","A0"))); + m = new HashMap<>(); + map.put("RAM512X1S", m); + m.put("O", new HashSet<>(Arrays.asList("A[8]","WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]","A[7]","A[6]"))); + m = new HashMap<>(); + map.put("RAM64M", m); + m.put("DOB", new HashSet<>(Arrays.asList("ADDRB[5]","WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOA", new HashSet<>(Arrays.asList("WCLK","ADDRA[5]","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m.put("DOD", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[5]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOC", new HashSet<>(Arrays.asList("ADDRC[5]","ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m = new HashMap<>(); + map.put("RAM64M8", m); + m.put("DOB", new HashSet<>(Arrays.asList("ADDRB[5]","WCLK","ADDRB[4]","ADDRB[3]","ADDRB[2]","ADDRB[1]","ADDRB[0]"))); + m.put("DOA", new HashSet<>(Arrays.asList("WCLK","ADDRA[5]","ADDRA[4]","ADDRA[3]","ADDRA[2]","ADDRA[1]","ADDRA[0]"))); + m.put("DOD", new HashSet<>(Arrays.asList("ADDRD[4]","ADDRD[5]","ADDRD[2]","WCLK","ADDRD[3]","ADDRD[0]","ADDRD[1]"))); + m.put("DOC", new HashSet<>(Arrays.asList("ADDRC[5]","ADDRC[3]","WCLK","ADDRC[4]","ADDRC[1]","ADDRC[2]","ADDRC[0]"))); + m.put("DOF", new HashSet<>(Arrays.asList("ADDRF[1]","ADDRF[0]","ADDRF[3]","WCLK","ADDRF[2]","ADDRF[5]","ADDRF[4]"))); + m.put("DOE", new HashSet<>(Arrays.asList("ADDRE[3]","ADDRE[4]","ADDRE[1]","WCLK","ADDRE[2]","ADDRE[0]","ADDRE[5]"))); + m.put("DOH", new HashSet<>(Arrays.asList("ADDRH[0]","WCLK","ADDRH[1]","ADDRH[2]","ADDRH[3]","ADDRH[4]","ADDRH[5]"))); + m.put("DOG", new HashSet<>(Arrays.asList("ADDRG[0]","ADDRG[2]","WCLK","ADDRG[1]","ADDRG[4]","ADDRG[3]","ADDRG[5]"))); + m = new HashMap<>(); + map.put("RAM64X1D", m); + m.put("DPO", new HashSet<>(Arrays.asList("WCLK","DPRA2","DPRA1","DPRA0","DPRA5","DPRA4","DPRA3"))); + m.put("SPO", new HashSet<>(Arrays.asList("A1","A2","A3","WCLK","A4","A5","A0"))); + m = new HashMap<>(); + map.put("RAM64X1S", m); + m.put("O", new HashSet<>(Arrays.asList("A1","A2","A3","WCLK","A4","A5","A0"))); + m = new HashMap<>(); + map.put("RAM64X8SW", m); + m.put("O[4]", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[5]", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[2]", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[3]", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[6]", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[7]", new HashSet<>(Arrays.asList("WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[0]", new HashSet<>(Arrays.asList("A[-2]","WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m.put("O[1]", new HashSet<>(Arrays.asList("A[-1]","WCLK","A[1]","A[0]","A[3]","A[2]","A[5]","A[4]"))); + m = new HashMap<>(); + map.put("RAMD32", m); + m.put("O", new HashSet<>(Arrays.asList("RADR0","CLK","RADR3","RADR4","RADR1","RADR2","I"))); + m = new HashMap<>(); + map.put("RAMD32M64", m); + m.put("O", new HashSet<>(Arrays.asList("WADR0","RADR0","WADR1","WADR2","CLK","WADR3","RADR3","WADR4","RADR4","RADR1","RADR2","RADR5"))); + m = new HashMap<>(); + map.put("RAMD64E", m); + m.put("O", new HashSet<>(Arrays.asList("RADR0","CLK","RADR3","RADR4","RADR1","RADR2","RADR5"))); + m = new HashMap<>(); + map.put("RAMD64E5", m); + m.put("O", new HashSet<>(Arrays.asList("CLK","ADR5","ADR3","ADR4","ADR1","ADR2","ADR0"))); + m = new HashMap<>(); + map.put("RAMS32", m); + m.put("O", new HashSet<>(Arrays.asList("CLK","I","ADR3","ADR4","ADR1","ADR2","ADR0"))); + m = new HashMap<>(); + map.put("RAMS64E", m); + m.put("O", new HashSet<>(Arrays.asList("CLK","ADR5","ADR3","ADR4","ADR1","ADR2","ADR0"))); + m = new HashMap<>(); + map.put("RAMS64E1", m); + m.put("O", new HashSet<>(Arrays.asList("CLK","ADR5","ADR3","ADR4","ADR1","ADR2","ADR0"))); + m = new HashMap<>(); + map.put("RAMS64E5", m); + m.put("O", new HashSet<>(Arrays.asList("CLK","ADR5","ADR3","ADR4","ADR1","ADR2","ADR0"))); + m = new HashMap<>(); + map.put("RFADCE5", m); + m = new HashMap<>(); + map.put("RFDAC", m); + m.put("STATUS_DAC1[8]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC0[9]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DRDY", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC1[10]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC1[12]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC3[8]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC2[9]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[4]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC3[11]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[0]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[2]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[15]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC2[11]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[13]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC0[12]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[8]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[11]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC0[10]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC0[8]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC1[11]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_COMMON[6]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC3[9]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC2[8]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC1[9]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[3]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC3[10]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[5]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC3[12]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[1]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[14]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[12]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC2[12]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[7]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("DOUT[10]", new HashSet<>(Arrays.asList("DCLK"))); + m.put("STATUS_DAC2[10]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("STATUS_DAC0[11]", new HashSet<>(Arrays.asList("FABRIC_CLK"))); + m.put("DOUT[9]", new HashSet<>(Arrays.asList("DCLK"))); + m = new HashMap<>(); + map.put("RFDACE5", m); + m = new HashMap<>(); + map.put("RIU_OR", m); + m.put("RIU_RD_DATA[13]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[13]","RIU_RD_DATA_UPP[13]"))); + m.put("RIU_RD_DATA[12]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[12]","RIU_RD_DATA_UPP[12]"))); + m.put("RIU_RD_DATA[15]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[15]","RIU_RD_DATA_UPP[15]"))); + m.put("RIU_RD_DATA[14]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[14]","RIU_RD_DATA_UPP[14]"))); + m.put("RIU_RD_DATA[0]", new HashSet<>(Arrays.asList("RIU_RD_DATA_UPP[0]","RIU_RD_DATA_LOW[0]"))); + m.put("RIU_RD_DATA[2]", new HashSet<>(Arrays.asList("RIU_RD_DATA_UPP[2]","RIU_RD_DATA_LOW[2]"))); + m.put("RIU_RD_DATA[1]", new HashSet<>(Arrays.asList("RIU_RD_DATA_UPP[1]","RIU_RD_DATA_LOW[1]"))); + m.put("RIU_RD_DATA[11]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[11]","RIU_RD_DATA_UPP[11]"))); + m.put("RIU_RD_DATA[10]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[10]","RIU_RD_DATA_UPP[10]"))); + m.put("RIU_RD_VALID", new HashSet<>(Arrays.asList("RIU_RD_VALID_LOW","RIU_RD_VALID_UPP"))); + m.put("RIU_RD_DATA[4]", new HashSet<>(Arrays.asList("RIU_RD_DATA_UPP[4]","RIU_RD_DATA_LOW[4]"))); + m.put("RIU_RD_DATA[3]", new HashSet<>(Arrays.asList("RIU_RD_DATA_UPP[3]","RIU_RD_DATA_LOW[3]"))); + m.put("RIU_RD_DATA[6]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[6]","RIU_RD_DATA_UPP[6]"))); + m.put("RIU_RD_DATA[5]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[5]","RIU_RD_DATA_UPP[5]"))); + m.put("RIU_RD_DATA[8]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[8]","RIU_RD_DATA_UPP[8]"))); + m.put("RIU_RD_DATA[7]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[7]","RIU_RD_DATA_UPP[7]"))); + m.put("RIU_RD_DATA[9]", new HashSet<>(Arrays.asList("RIU_RD_DATA_LOW[9]","RIU_RD_DATA_UPP[9]"))); + m = new HashMap<>(); + map.put("RXTX_BITSLICE", m); + m.put("RX_CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("RX_CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("RX_CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("FIFO_WRCLK_OUT", new HashSet<>(Arrays.asList("RX_BIT_CTRL_IN[20]"))); + m.put("RX_CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("TX_CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("T_OUT", new HashSet<>(Arrays.asList("D[1]"))); + m.put("O", new HashSet<>(Arrays.asList("D[0]"))); + m.put("Q[1]", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("Q[3]", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("Q[5]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("Q[7]", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("RX_CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("RX_CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("RX_CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("RX_CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("TX_CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("TX_CLK"))); + m.put("RX_CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("RX_CLK"))); + m.put("Q[0]", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("Q[2]", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("Q[4]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("Q[6]", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("RX_BIT_CTRL_OUT[9]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("FIFO_EMPTY", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m = new HashMap<>(); + map.put("RX_BITSLICE", m); + m.put("RX_BIT_CTRL_OUT[34]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[22]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[14]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[38]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[26]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[18]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[3]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("FIFO_WRCLK_OUT", new HashSet<>(Arrays.asList("RX_BIT_CTRL_IN[0]","RX_BIT_CTRL_IN[17]","RX_BIT_CTRL_IN[39]","RX_BIT_CTRL_IN[27]","RX_BIT_CTRL_IN[2]","RX_BIT_CTRL_IN[19]","RX_BIT_CTRL_IN[29]","RX_BIT_CTRL_IN[13]","RX_BIT_CTRL_IN[35]","RX_BIT_CTRL_IN[23]","RX_BIT_CTRL_IN[15]","RX_BIT_CTRL_IN[37]","RX_BIT_CTRL_IN[25]","RX_BIT_CTRL_IN[8]","RX_BIT_CTRL_IN[4]","RX_BIT_CTRL_IN[6]","RX_BIT_CTRL_IN[31]","RX_BIT_CTRL_IN[11]","RX_BIT_CTRL_IN[33]","RX_BIT_CTRL_IN[21]","RX_BIT_CTRL_IN[28]","RX_BIT_CTRL_IN[16]","RX_BIT_CTRL_IN[38]","RX_BIT_CTRL_IN[1]","RX_BIT_CTRL_IN[18]","RX_BIT_CTRL_IN[24]","RX_BIT_CTRL_IN[12]","RX_BIT_CTRL_IN[34]","RX_BIT_CTRL_IN[26]","RX_BIT_CTRL_IN[14]","RX_BIT_CTRL_IN[36]","RX_BIT_CTRL_IN[7]","RX_BIT_CTRL_IN[9]","RX_BIT_CTRL_IN[3]","RX_BIT_CTRL_IN[5]","RX_BIT_CTRL_IN[20]","RX_BIT_CTRL_IN[30]","RX_BIT_CTRL_IN[22]","RX_BIT_CTRL_IN[10]","RX_BIT_CTRL_IN[32]"))); + m.put("RX_BIT_CTRL_OUT[30]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[10]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT_EXT[3]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("Q[3]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("CNTVALUEOUT_EXT[7]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("Q[7]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("RX_BIT_CTRL_OUT[4]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[19]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[8]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[33]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[25]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[13]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[0]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[37]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[29]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[17]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[21]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT_EXT[4]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("Q[2]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("CNTVALUEOUT_EXT[8]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("Q[6]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("RX_BIT_CTRL_OUT[5]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[9]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("FIFO_EMPTY", new HashSet<>(Arrays.asList("FIFO_RD_CLK"))); + m.put("CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[12]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[36]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[24]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[16]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[1]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[28]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT_EXT[0]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("RX_BIT_CTRL_OUT[32]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[20]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("Q[1]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("CNTVALUEOUT_EXT[1]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("Q[5]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("CNTVALUEOUT_EXT[5]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[6]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[23]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[11]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[35]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[27]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[15]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[2]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[39]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("RX_BIT_CTRL_OUT[31]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("Q[0]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("CNTVALUEOUT_EXT[2]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("Q[4]", new HashSet<>(Arrays.asList("DATAIN","FIFO_RD_CLK"))); + m.put("CNTVALUEOUT_EXT[6]", new HashSet<>(Arrays.asList("CLK_EXT"))); + m.put("CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("RX_BIT_CTRL_OUT[7]", new HashSet<>(Arrays.asList("DATAIN"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("SRL16E", m); + m.put("Q", new HashSet<>(Arrays.asList("A1","A2","A3","CLK","A0"))); + m = new HashMap<>(); + map.put("SRLC16E", m); + m.put("Q", new HashSet<>(Arrays.asList("A1","A2","A3","CLK","A0"))); + m.put("Q15", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("SRLC32E", m); + m.put("Q", new HashSet<>(Arrays.asList("CLK","A[1]","A[0]","A[3]","A[2]","A[4]"))); + m.put("Q31", new HashSet<>(Arrays.asList("CLK"))); + + m = new HashMap<>(); + map.put("TX_BITSLICE", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("T_OUT", new HashSet<>(Arrays.asList("D[1]"))); + m.put("O", new HashSet<>(Arrays.asList("D[0]"))); + m.put("CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("CLK"))); + m = new HashMap<>(); + map.put("TX_BITSLICE_TRI", m); + m.put("CNTVALUEOUT[0]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[2]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[1]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[8]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[7]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[4]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[3]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[6]", new HashSet<>(Arrays.asList("CLK"))); + m.put("CNTVALUEOUT[5]", new HashSet<>(Arrays.asList("CLK"))); + } + + public static void main(String[] args) { + if (args.length != 2) { + System.out.println(" "); + return; + } + EDIFNetlist n = args[0].endsWith(".dcp") ? Design.readCheckpoint(args[0]).getNetlist() : EDIFTools.readEdifFile(args[0]); + Set clks = getClockNetsUpstreamFromPin(args[1], n); + + + // Run search on all leaf cell pins +// for (EDIFHierCellInst i : n.getAllLeafHierCellInstances()) { +// for (EDIFHierPortInst p : i.getHierPortInsts()) { +// System.out.println(p + " -> " + getClockNetsUpstreamFromPin(p)); +// } +// } + + System.out.println(clks); + } +}