| #!/usr/bin/env python3 | |
| # | |
| # Copyright (C) 2015 Clifford Wolf <clifford@clifford.at> | |
| # | |
| # Permission to use, copy, modify, and/or distribute this software for any | |
| # purpose with or without fee is hereby granted, provided that the above | |
| # copyright notice and this permission notice appear in all copies. | |
| # | |
| # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
| # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
| # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
| # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
| # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
| # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
| # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
| # | |
| import iceboxdb | |
| import re, sys, functools | |
| if True: | |
| # icebox uses lots of regular expressions. | |
| # Supply cached versions of common re functions | |
| # to avoid re-calculating regular expression results | |
| # over and over again. | |
| re_cache_sizes = 2**14 | |
| @functools.lru_cache(maxsize=re_cache_sizes) | |
| def re_match_cached(*args): | |
| return re.match(*args) | |
| @functools.lru_cache(maxsize=re_cache_sizes) | |
| def re_sub_cached(*args): | |
| return re.sub(*args) | |
| @functools.lru_cache(maxsize=re_cache_sizes) | |
| def re_search_cached(*args): | |
| return re.search(*args) | |
| else: | |
| # Disable regular expression caching. | |
| re_match_cached = re.match | |
| re_sub_cached = re.sub | |
| re_search_cached = re.search | |
| class iceconfig: | |
| def __init__(self): | |
| self.clear() | |
| def clear(self): | |
| self.max_x = 0 | |
| self.max_y = 0 | |
| self.device = "" | |
| self.warmboot = True | |
| self.logic_tiles = dict() | |
| self.io_tiles = dict() | |
| self.ramb_tiles = dict() | |
| self.ramt_tiles = dict() | |
| self.dsp_tiles = [dict() for i in range(4)] | |
| self.ipcon_tiles = dict() | |
| self.ram_data = dict() | |
| self.extra_bits = set() | |
| self.symbols = dict() | |
| self.tile_has_net.cache_clear() | |
| def setup_empty_384(self): | |
| self.clear() | |
| self.device = "384" | |
| self.max_x = 7 | |
| self.max_y = 9 | |
| for x in range(1, self.max_x): | |
| for y in range(1, self.max_y): | |
| self.logic_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| for x in range(1, self.max_x): | |
| self.io_tiles[(x, 0)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(x, self.max_y)] = ["0" * 18 for i in range(16)] | |
| for y in range(1, self.max_y): | |
| self.io_tiles[(0, y)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(self.max_x, y)] = ["0" * 18 for i in range(16)] | |
| def setup_empty_1k(self): | |
| self.clear() | |
| self.device = "1k" | |
| self.max_x = 13 | |
| self.max_y = 17 | |
| for x in range(1, self.max_x): | |
| for y in range(1, self.max_y): | |
| if x in (3, 10): | |
| if y % 2 == 1: | |
| self.ramb_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.ramt_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.logic_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| for x in range(1, self.max_x): | |
| self.io_tiles[(x, 0)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(x, self.max_y)] = ["0" * 18 for i in range(16)] | |
| for y in range(1, self.max_y): | |
| self.io_tiles[(0, y)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(self.max_x, y)] = ["0" * 18 for i in range(16)] | |
| def setup_empty_lm4k(self): | |
| self.clear() | |
| self.device = "lm4k" | |
| self.max_x = 25 | |
| self.max_y = 21 | |
| for x in range(1, self.max_x): | |
| for y in range(1, self.max_y): | |
| if x in (6, 19): | |
| if y % 2 == 1: | |
| self.ramb_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.ramt_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.logic_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| for x in range(1, self.max_x): | |
| self.io_tiles[(x, 0)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(x, self.max_y)] = ["0" * 18 for i in range(16)] | |
| for y in range(1, self.max_y): | |
| self.io_tiles[(0, y)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(self.max_x, y)] = ["0" * 18 for i in range(16)] | |
| def setup_empty_u4k(self): | |
| self.clear() | |
| self.device = "u4k" | |
| self.max_x = 25 | |
| self.max_y = 21 | |
| for x in range(1, self.max_x): | |
| for y in range(1, self.max_y): | |
| if x in (6, 19): | |
| if y % 2 == 1: | |
| self.ramb_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.ramt_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.logic_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| for x in range(1, self.max_x): | |
| self.io_tiles[(x, 0)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(x, self.max_y)] = ["0" * 18 for i in range(16)] | |
| for x in [0, self.max_x]: | |
| for y in range(1, self.max_y): | |
| if y in [5, 13]: | |
| self.dsp_tiles[0][(x, y)] = ["0" * 54 for i in range(16)] | |
| elif y in [6, 14]: | |
| self.dsp_tiles[1][(x, y)] = ["0" * 54 for i in range(16)] | |
| elif y in [7, 15]: | |
| self.dsp_tiles[2][(x, y)] = ["0" * 54 for i in range(16)] | |
| elif y in [8, 16]: | |
| self.dsp_tiles[3][(x, y)] = ["0" * 54 for i in range(16)] | |
| else: | |
| self.ipcon_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| def setup_empty_5k(self): | |
| self.clear() | |
| self.device = "5k" | |
| self.max_x = 25 | |
| self.max_y = 31 | |
| for x in range(1, self.max_x): | |
| for y in range(1, self.max_y): | |
| if x in (6, 19): | |
| if y % 2 == 1: | |
| self.ramb_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.ramt_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.logic_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| for x in range(1, self.max_x): | |
| self.io_tiles[(x, 0)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(x, self.max_y)] = ["0" * 18 for i in range(16)] | |
| for x in [0, self.max_x]: | |
| for y in range(1, self.max_y): | |
| if y in [5, 10, 15, 23]: | |
| self.dsp_tiles[0][(x, y)] = ["0" * 54 for i in range(16)] | |
| elif y in [6, 11, 16, 24]: | |
| self.dsp_tiles[1][(x, y)] = ["0" * 54 for i in range(16)] | |
| elif y in [7, 12, 17, 25]: | |
| self.dsp_tiles[2][(x, y)] = ["0" * 54 for i in range(16)] | |
| elif y in [8, 13, 18, 26]: | |
| self.dsp_tiles[3][(x, y)] = ["0" * 54 for i in range(16)] | |
| else: | |
| self.ipcon_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| def setup_empty_8k(self): | |
| self.clear() | |
| self.device = "8k" | |
| self.max_x = 33 | |
| self.max_y = 33 | |
| for x in range(1, self.max_x): | |
| for y in range(1, self.max_y): | |
| if x in (8, 25): | |
| if y % 2 == 1: | |
| self.ramb_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.ramt_tiles[(x, y)] = ["0" * 42 for i in range(16)] | |
| else: | |
| self.logic_tiles[(x, y)] = ["0" * 54 for i in range(16)] | |
| for x in range(1, self.max_x): | |
| self.io_tiles[(x, 0)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(x, self.max_y)] = ["0" * 18 for i in range(16)] | |
| for y in range(1, self.max_y): | |
| self.io_tiles[(0, y)] = ["0" * 18 for i in range(16)] | |
| self.io_tiles[(self.max_x, y)] = ["0" * 18 for i in range(16)] | |
| def lookup_extra_bit(self, bit): | |
| assert self.device in extra_bits_db | |
| if bit in extra_bits_db[self.device]: | |
| return extra_bits_db[self.device][bit] | |
| return ("UNKNOWN_FUNCTION",) | |
| def tile(self, x, y): | |
| if (x, y) in self.io_tiles: return self.io_tiles[(x, y)] | |
| if (x, y) in self.logic_tiles: return self.logic_tiles[(x, y)] | |
| if (x, y) in self.ramb_tiles: return self.ramb_tiles[(x, y)] | |
| if (x, y) in self.ramt_tiles: return self.ramt_tiles[(x, y)] | |
| for i in range(4): | |
| if (x, y) in self.dsp_tiles[i]: return self.dsp_tiles[i][(x, y)] | |
| if (x, y) in self.ipcon_tiles: return self.ipcon_tiles[(x, y)] | |
| return None | |
| def pinloc_db(self, package = None): | |
| if package is None: | |
| if self.device == "384": return pinloc_db["384-qn32"] | |
| if self.device == "1k": return pinloc_db["1k-tq144"] | |
| if self.device == "lm4k": return pinloc_db["lm4k-cm49"] | |
| if self.device == "u4k": return pinloc_db["u4k-sg48"] | |
| if self.device == "5k": return pinloc_db["5k-sg48"] | |
| if self.device == "8k": return pinloc_db["8k-ct256"] | |
| else: | |
| return pinloc_db[self.device + "-" + package] | |
| assert False | |
| def gbufin_db(self): | |
| return gbufin_db[self.device] | |
| def iolatch_db(self): | |
| return iolatch_db[self.device] | |
| def padin_pio_db(self): | |
| return padin_pio_db[self.device] | |
| def extra_bits_db(self): | |
| return extra_bits_db[self.device] | |
| def ieren_db(self): | |
| return ieren_db[self.device] | |
| def pll_list(self): | |
| if self.device == "1k": | |
| return ["1k"] | |
| if self.device == "lm4k": | |
| return ["lm4k"] | |
| if self.device == "u4k": | |
| return ["u4k"] | |
| if self.device == "5k": | |
| return ["5k"] | |
| if self.device == "8k": | |
| return ["8k_0", "8k_1"] | |
| if self.device == "384": | |
| return [ ] | |
| assert False | |
| # Return true if device is Ultra/UltraPlus series, i.e. has | |
| # IpConnect/DSP at the sides instead of IO | |
| def is_ultra(self): | |
| return self.device in ["5k", "u4k"] | |
| def colbuf_db(self): | |
| if self.device == "1k": | |
| entries = list() | |
| for x in range(self.max_x+1): | |
| for y in range(self.max_y+1): | |
| src_y = None | |
| if 0 <= y <= 4: src_y = 4 | |
| if 5 <= y <= 8: src_y = 5 | |
| if 9 <= y <= 12: src_y = 12 | |
| if 13 <= y <= 17: src_y = 13 | |
| if x in [3, 10] and src_y == 4: src_y = 3 | |
| if x in [3, 10] and src_y == 12: src_y = 11 | |
| entries.append((x, src_y, x, y)) | |
| return entries | |
| # TODO(awygle) - actually capture 0 and 21 here | |
| if self.device == "lm4k": | |
| entries = list() | |
| for x in range(self.max_x+1): | |
| for y in range(self.max_y+1): | |
| src_y = None | |
| if 0 <= y <= 4: src_y = 4 | |
| if 5 <= y <= 10: src_y = 5 | |
| if 11 <= y <= 16: src_y = 16 | |
| if 17 <= y <= 21: src_y = 17 | |
| entries.append((x, src_y, x, y)) | |
| return entries | |
| if self.device == "u4k": | |
| entries = list() | |
| for x in range(self.max_x+1): | |
| for y in range(self.max_y+1): | |
| src_y = None | |
| if 0 <= y <= 4: src_y = 4 | |
| if 5 <= y <= 10: src_y = 5 | |
| if 11 <= y <= 16: src_y = 16 | |
| if 17 <= y <= 21: src_y = 17 | |
| entries.append((x, src_y, x, y)) | |
| return entries | |
| if self.device == "8k": | |
| entries = list() | |
| for x in range(self.max_x+1): | |
| for y in range(self.max_y+1): | |
| src_y = None | |
| if 0 <= y <= 8: src_y = 8 | |
| if 9 <= y <= 16: src_y = 9 | |
| if 17 <= y <= 24: src_y = 24 | |
| if 25 <= y <= 33: src_y = 25 | |
| entries.append((x, src_y, x, y)) | |
| return entries | |
| if self.device == "5k": #Interesting, seems the 5k has more colbufs? | |
| entries = list() | |
| for x in range(self.max_x+1): | |
| for y in range(self.max_y+1): | |
| src_y = None | |
| if 0 <= y <= 4: src_y = 4 | |
| if 5 <= y <= 10: src_y = 5 | |
| if 11 <= y <= 14: src_y = 14 | |
| if 15 <= y <= 20: src_y = 15 | |
| if 21 <= y <= 26: src_y = 26 | |
| if 27 <= y <= 31: src_y = 27 | |
| entries.append((x, src_y, x, y)) | |
| return entries | |
| if self.device == "384": | |
| entries = list() | |
| for x in range(self.max_x+1): | |
| for y in range(self.max_y+1): | |
| src_y = None #Is ColBufCtrl relevant? | |
| if 0 <= y <= 2: src_y = 2 #384? | |
| if 3 <= y <= 4: src_y = 3 #384? | |
| if 5 <= y <= 6: src_y = 6 #384? | |
| if 7 <= y <= 9: src_y = 7 #384? | |
| entries.append((x, src_y, x, y)) | |
| return entries | |
| assert False | |
| # Return a map between HDL name and routing net and location for a given DSP cell | |
| def get_dsp_nets_db(self, x, y): | |
| assert ((x, y) in self.dsp_tiles[0]) | |
| # Control signals | |
| nets = { | |
| "CLK": (x, y+2, "lutff_global/clk"), | |
| "CE": (x, y+2, "lutff_global/cen"), | |
| "IRSTTOP": (x, y+1, "lutff_global/s_r"), | |
| "IRSTBOT": (x, y+0, "lutff_global/s_r"), | |
| "ORSTTOP": (x, y+3, "lutff_global/s_r"), | |
| "ORSTBOT": (x, y+2, "lutff_global/s_r"), | |
| "AHOLD": (x, y+2, "lutff_0/in_0"), | |
| "BHOLD": (x, y+1, "lutff_0/in_0"), | |
| "CHOLD": (x, y+3, "lutff_0/in_0"), | |
| "DHOLD": (x, y+0, "lutff_0/in_0"), | |
| "OHOLDTOP": (x, y+3, "lutff_1/in_0"), | |
| "OHOLDBOT": (x, y+0, "lutff_1/in_0"), | |
| "ADDSUBTOP": (x, y+3, "lutff_3/in_0"), | |
| "ADDSUBBOT": (x, y+0, "lutff_3/in_0"), | |
| "OLOADTOP": (x, y+3, "lutff_2/in_0"), | |
| "OLOADBOT": (x, y+0, "lutff_2/in_0"), | |
| "CI": (x, y+0, "lutff_4/in_0"), | |
| "CO": (x, y+4, "slf_op_0") | |
| } | |
| #Data ports | |
| for i in range(8): | |
| nets["C_%d" % i] = (x, y+3, "lutff_%d/in_3" % i) | |
| nets["C_%d" % (i+8)] = (x, y+3, "lutff_%d/in_1" % i) | |
| nets["A_%d" % i] = (x, y+2, "lutff_%d/in_3" % i) | |
| nets["A_%d" % (i+8)] = (x, y+2, "lutff_%d/in_1" % i) | |
| nets["B_%d" % i] = (x, y+1, "lutff_%d/in_3" % i) | |
| nets["B_%d" % (i+8)] = (x, y+1, "lutff_%d/in_1" % i) | |
| nets["D_%d" % i] = (x, y+0, "lutff_%d/in_3" % i) | |
| nets["D_%d" % (i+8)] = (x, y+0, "lutff_%d/in_1" % i) | |
| for i in range(32): | |
| nets["O_%d" % i] = (x, y+(i//8), "mult/O_%d" % i) | |
| return nets | |
| # Return the location of configuration bits for a given DSP cell | |
| def get_dsp_config_db(self, x, y): | |
| assert ((x, y) in self.dsp_tiles[0]) | |
| override = { } | |
| if (("%s_%d_%d" % (self.device, x, y)) in dsp_config_db): | |
| override = dsp_config_db["%s_%d_%d" % (self.device, x, y)] | |
| default_db = dsp_config_db["default"] | |
| merged = { } | |
| for cfgkey in default_db: | |
| cx, cy, cbit = default_db[cfgkey] | |
| if cfgkey in override: | |
| cx, cy, cbit = override[cfgkey] | |
| merged[cfgkey] = (x + cx, y + cy, cbit) | |
| return merged | |
| def tile_db(self, x, y): | |
| # Only these devices have IO on the left and right sides. | |
| if self.device in ["384", "1k", "lm4k", "8k"]: | |
| if x == 0: return iotile_l_db | |
| if x == self.max_x: return iotile_r_db | |
| # The 5k needs an IO db including the extra bits | |
| if self.device == "5k" or self.device == "u4k": | |
| if y == 0: return iotile_b_5k_db | |
| if y == self.max_y: return iotile_t_5k_db | |
| else: | |
| if y == 0: return iotile_b_db | |
| if y == self.max_y: return iotile_t_db | |
| if self.device == "1k": | |
| if (x, y) in self.logic_tiles: return logictile_db | |
| if (x, y) in self.ramb_tiles: return rambtile_db | |
| if (x, y) in self.ramt_tiles: return ramttile_db | |
| elif self.device == "5k" or self.device == "u4k": | |
| if (x, y) in self.logic_tiles: return logictile_5k_db | |
| if (x, y) in self.ramb_tiles: return rambtile_8k_db | |
| if (x, y) in self.ramt_tiles: return ramttile_8k_db | |
| if (x, y) in self.ipcon_tiles: return ipcon_5k_db | |
| if (x, y) in self.dsp_tiles[0]: return dsp0_5k_db | |
| if (x, y) in self.dsp_tiles[1]: return dsp1_5k_db | |
| if (x, y) in self.dsp_tiles[2]: return dsp2_5k_db | |
| if (x, y) in self.dsp_tiles[3]: return dsp3_5k_db | |
| elif self.device == "8k" or self.device == "lm4k": | |
| if (x, y) in self.logic_tiles: return logictile_8k_db | |
| if (x, y) in self.ramb_tiles: return rambtile_8k_db | |
| if (x, y) in self.ramt_tiles: return ramttile_8k_db | |
| elif self.device == "384": | |
| if (x, y) in self.logic_tiles: return logictile_384_db | |
| print("Tile type unknown at (%d, %d)" % (x, y)) | |
| assert False | |
| def tile_type(self, x, y): | |
| if x == 0 and (not self.is_ultra()): return "IO" | |
| if y == 0: return "IO" | |
| if x == self.max_x and (not self.is_ultra()): return "IO" | |
| if y == self.max_y: return "IO" | |
| if (x, y) in self.ramb_tiles: return "RAMB" | |
| if (x, y) in self.ramt_tiles: return "RAMT" | |
| if (x, y) in self.logic_tiles: return "LOGIC" | |
| if (x == 0 or x == self.max_x) and self.is_ultra(): | |
| if (x, y) in self.dsp_tiles[0]: return "DSP0" | |
| elif (x, y) in self.dsp_tiles[1]: return "DSP1" | |
| elif (x, y) in self.dsp_tiles[2]: return "DSP2" | |
| elif (x, y) in self.dsp_tiles[3]: return "DSP3" | |
| else: return "IPCON" | |
| assert False | |
| def tile_pos(self, x, y): | |
| if x == 0 and 0 < y < self.max_y: return "l" | |
| if y == 0 and 0 < x < self.max_x: return "b" | |
| if x == self.max_x and 0 < y < self.max_y: return "r" | |
| if y == self.max_y and 0 < x < self.max_x: return "t" | |
| if 0 < x < self.max_x and 0 < y < self.max_y: return "x" | |
| return None | |
| def tile_has_entry(self, x, y, entry): | |
| if entry[1] in ("routing", "buffer"): | |
| return self.tile_has_net(x, y, entry[2]) and self.tile_has_net(x, y, entry[3]) | |
| return True | |
| @functools.lru_cache(maxsize=2**16) | |
| def tile_has_net(self, x, y, netname): | |
| if netname.startswith("logic_op_"): | |
| if netname.startswith("logic_op_bot_"): | |
| if y == self.max_y and 0 < x < self.max_x: return True | |
| if netname.startswith("logic_op_bnl_"): | |
| if x == self.max_x and 1 < y < self.max_y and (not self.is_ultra()): return True | |
| if y == self.max_y and 1 < x < self.max_x: return True | |
| if netname.startswith("logic_op_bnr_"): | |
| if x == 0 and 1 < y < self.max_y and (not self.is_ultra()): return True | |
| if y == self.max_y and 0 < x < self.max_x-1: return True | |
| if netname.startswith("logic_op_top_"): | |
| if y == 0 and 0 < x < self.max_x: return True | |
| if netname.startswith("logic_op_tnl_"): | |
| if x == self.max_x and 0 < y < self.max_y-1 and (not self.is_ultra()): return True | |
| if y == 0 and 1 < x < self.max_x: return True | |
| if netname.startswith("logic_op_tnr_"): | |
| if x == 0 and 0 < y < self.max_y-1 and (not self.is_ultra()): return True | |
| if y == 0 and 0 < x < self.max_x-1: return True | |
| if netname.startswith("logic_op_lft_"): | |
| if x == self.max_x and (not self.is_ultra()): return True | |
| if netname.startswith("logic_op_rgt_"): | |
| if x == 0 and (not self.is_ultra()): return True | |
| return False | |
| if not 0 <= x <= self.max_x: return False | |
| if not 0 <= y <= self.max_y: return False | |
| return pos_has_net(self.tile_pos(x, y), netname) | |
| def tile_follow_net(self, x, y, direction, netname): | |
| if x == 1 and y not in (0, self.max_y) and direction == 'l': return pos_follow_net("x", "L", netname, self.is_ultra()) | |
| if y == 1 and x not in (0, self.max_x) and direction == 'b': return pos_follow_net("x", "B", netname, self.is_ultra()) | |
| if x == self.max_x-1 and y not in (0, self.max_y) and direction == 'r': return pos_follow_net("x", "R", netname, self.is_ultra()) | |
| if y == self.max_y-1 and x not in (0, self.max_x) and direction == 't': return pos_follow_net("x", "T", netname, self.is_ultra()) | |
| if self.is_ultra(): # Pass through corner positions as they must be handled differently | |
| if y == 1 and x in (0, self.max_x) and direction == 'b': return pos_follow_net(self.tile_pos(x, y), "B", netname, self.is_ultra()) | |
| if y == self.max_y-1 and x in (0, self.max_x) and direction == 't': return pos_follow_net(self.tile_pos(x, y), "T", netname, self.is_ultra()) | |
| if x == 1 and y in (0, self.max_y) and direction == 'l': return pos_follow_net(self.tile_pos(x, y), "L", netname, self.is_ultra()) | |
| if x == self.max_x-1 and y in (0, self.max_y) and direction == 'r': return pos_follow_net(self.tile_pos(x, y), "R", netname, self.is_ultra()) | |
| return pos_follow_net(self.tile_pos(x, y), direction, netname, self.is_ultra()) | |
| def follow_funcnet(self, x, y, func): | |
| neighbours = set() | |
| def do_direction(name, nx, ny): | |
| if (0 < nx < self.max_x or self.is_ultra()) and 0 < ny < self.max_y: | |
| neighbours.add((nx, ny, "neigh_op_%s_%d" % (name, func))) | |
| if nx in (0, self.max_x) and 0 < ny < self.max_y and nx != x and (not self.is_ultra()): | |
| neighbours.add((nx, ny, "logic_op_%s_%d" % (name, func))) | |
| if ny in (0, self.max_y) and 0 < nx < self.max_x and ny != y: | |
| neighbours.add((nx, ny, "logic_op_%s_%d" % (name, func))) | |
| do_direction("bot", x, y+1) | |
| do_direction("bnl", x+1, y+1) | |
| do_direction("bnr", x-1, y+1) | |
| do_direction("top", x, y-1) | |
| do_direction("tnl", x+1, y-1) | |
| do_direction("tnr", x-1, y-1) | |
| do_direction("lft", x+1, y ) | |
| do_direction("rgt", x-1, y ) | |
| return neighbours | |
| def lookup_funcnet(self, nx, ny, x, y, func): | |
| npos = self.tile_pos(nx, ny) | |
| pos = self.tile_pos(x, y) | |
| if npos is not None and pos is not None: | |
| if npos == "x": | |
| if (nx, ny) in self.logic_tiles: | |
| return (nx, ny, "lutff_%d/out" % func) | |
| for i in range(4): | |
| if (nx, ny) in self.dsp_tiles[i]: #TODO: check this | |
| return (nx, ny, "mult/O_%d" % (i * 8 + func)) | |
| if (nx, ny) in self.ramb_tiles: | |
| if self.device == "1k": | |
| return (nx, ny, "ram/RDATA_%d" % func) | |
| elif self.device == "5k" or self.device == "u4k": | |
| return (nx, ny, "ram/RDATA_%d" % (15-func)) | |
| elif self.device == "8k" or self.device == "lm4k": | |
| return (nx, ny, "ram/RDATA_%d" % (15-func)) | |
| else: | |
| assert False | |
| if (nx, ny) in self.ramt_tiles: | |
| if self.device == "1k": | |
| return (nx, ny, "ram/RDATA_%d" % (8+func)) | |
| elif self.device == "5k" or self.device == "u4k": | |
| return (nx, ny, "ram/RDATA_%d" % (7-func)) | |
| elif self.device == "8k" or self.device == "lm4k": | |
| return (nx, ny, "ram/RDATA_%d" % (7-func)) | |
| else: | |
| assert False | |
| elif pos == "x" and ((npos in ("t", "b")) or ((not self.is_ultra()) and (npos in ("l", "r")))): | |
| if func in (0, 4): return (nx, ny, "io_0/D_IN_0") | |
| if func in (1, 5): return (nx, ny, "io_0/D_IN_1") | |
| if func in (2, 6): return (nx, ny, "io_1/D_IN_0") | |
| if func in (3, 7): return (nx, ny, "io_1/D_IN_1") | |
| return None | |
| def rlookup_funcnet(self, x, y, netname): | |
| funcnets = set() | |
| if netname == "io_0/D_IN_0": | |
| for net in self.follow_funcnet(x, y, 0) | self.follow_funcnet(x, y, 4): | |
| if self.tile_pos(net[0], net[1]) == "x": funcnets.add(net) | |
| if netname == "io_0/D_IN_1": | |
| for net in self.follow_funcnet(x, y, 1) | self.follow_funcnet(x, y, 5): | |
| if self.tile_pos(net[0], net[1]) == "x": funcnets.add(net) | |
| if netname == "io_1/D_IN_0": | |
| for net in self.follow_funcnet(x, y, 2) | self.follow_funcnet(x, y, 6): | |
| if self.tile_pos(net[0], net[1]) == "x": funcnets.add(net) | |
| if netname == "io_1/D_IN_1": | |
| for net in self.follow_funcnet(x, y, 3) | self.follow_funcnet(x, y, 7): | |
| if self.tile_pos(net[0], net[1]) == "x": funcnets.add(net) | |
| match = re_match_cached(r"lutff_(\d+)/out", netname) | |
| if match: | |
| funcnets |= self.follow_funcnet(x, y, int(match.group(1))) | |
| match = re_match_cached(r"ram/RDATA_(\d+)", netname) | |
| if match: | |
| if self.device == "1k": | |
| funcnets |= self.follow_funcnet(x, y, int(match.group(1)) % 8) | |
| elif self.device == "5k" or self.device == "u4k": | |
| funcnets |= self.follow_funcnet(x, y, 7 - int(match.group(1)) % 8) | |
| elif self.device == "8k" or self.device == "lm4k": | |
| funcnets |= self.follow_funcnet(x, y, 7 - int(match.group(1)) % 8) | |
| else: | |
| assert False | |
| return funcnets | |
| def ultraplus_follow_corner(self, corner, direction, netname): | |
| m = re_match_cached("span4_(horz|vert)_([lrtb])_(\d+)$", netname) | |
| if not m: | |
| return None | |
| cur_edge = m.group(2) | |
| cur_index = int(m.group(3)) | |
| if direction not in corner: | |
| return None | |
| if direction != cur_edge: | |
| return None | |
| h_idx, v_idx = self.ultraplus_trace_corner_idx(corner, cur_index) | |
| if h_idx is None and (direction == "b" or direction == "t"): | |
| return None | |
| if v_idx is None and (direction == "l" or direction == "r"): | |
| return None | |
| if corner == "bl" and direction == "l": | |
| return (0, 1, sp4v_normalize("sp4_v_b_%d" % v_idx)) | |
| if corner == "bl" and direction == "b": | |
| return (1, 0, ultra_span4_horz_normalize("span4_horz_l_%d" % h_idx)) | |
| if corner == "br" and direction == "r": | |
| return (self.max_x, 1, sp4v_normalize("sp4_v_b_%d" % v_idx)) | |
| if corner == "br" and direction == "b": | |
| return (self.max_x-1, 0, ultra_span4_horz_normalize("span4_horz_r_%d" % h_idx)) | |
| if corner == "tl" and direction == "l": | |
| return (0, self.max_y-1, sp4v_normalize("sp4_v_t_%d" % v_idx)) | |
| if corner == "tl" and direction == "t": | |
| return (1, self.max_y, ultra_span4_horz_normalize("span4_horz_l_%d" % h_idx)) | |
| if corner == "tr" and direction == "r": | |
| return (self.max_x, self.max_y-1, sp4v_normalize("sp4_v_t_%d" % v_idx)) | |
| if corner == "tr" and direction == "t": | |
| return (self.max_x-1, self.max_y, ultra_span4_horz_normalize("span4_horz_r_%d" % h_idx)) | |
| assert False | |
| #UltraPlus corner routing: given the corner name and net index, | |
| #return a tuple containing H and V indexes, or none if NA | |
| def ultraplus_trace_corner_idx(self, corner, idx): | |
| h_idx = None | |
| v_idx = None | |
| if corner == "bl" or corner == "br": | |
| if idx < 16: | |
| v_idx = idx + 32 | |
| if idx >= 32 and idx < 48: | |
| h_idx = idx - 32 | |
| elif corner == "tl" or corner == "tr": | |
| if idx >= 0 and idx < 16: | |
| v_idx = idx | |
| h_idx = idx | |
| return (h_idx, v_idx) | |
| def get_corner(self, x, y): | |
| corner = "" | |
| if y == 0: | |
| corner += "b" | |
| elif y == self.max_y: | |
| corner += "t" | |
| else: | |
| corner += "x" | |
| if x == 0: | |
| corner += "l" | |
| elif x == self.max_x: | |
| corner += "r" | |
| else: | |
| corner += "x" | |
| return corner | |
| def follow_net(self, netspec): | |
| x, y, netname = netspec | |
| neighbours = self.rlookup_funcnet(x, y, netname) | |
| #print(netspec) | |
| #print('\t', neighbours) | |
| if netname == "carry_in" and y > 1: | |
| neighbours.add((x, y-1, "lutff_7/cout")) | |
| if netname == "lutff_7/cout" and y+1 < self.max_y: | |
| neighbours.add((x, y+1, "carry_in")) | |
| if netname.startswith("glb_netwk_"): | |
| for nx in range(self.max_x+1): | |
| for ny in range(self.max_y+1): | |
| if self.tile_pos(nx, ny) is not None: | |
| neighbours.add((nx, ny, netname)) | |
| match = re_match_cached(r"sp4_r_v_b_(\d+)", netname) | |
| if match and ((0 < x < self.max_x-1) or (self.is_ultra() and (x < self.max_x))): | |
| neighbours.add((x+1, y, sp4v_normalize("sp4_v_b_" + match.group(1)))) | |
| #print('\tafter r_v_b', neighbours) | |
| match = re_match_cached(r"sp4_v_[bt]_(\d+)", netname) | |
| if match and (1 < x < self.max_x or (self.is_ultra() and (x > 0))): | |
| n = sp4v_normalize(netname, "b") | |
| if n is not None: | |
| n = n.replace("sp4_", "sp4_r_") | |
| neighbours.add((x-1, y, n)) | |
| #print('\tafter v_[bt]', neighbours) | |
| match = re_match_cached(r"(logic|neigh)_op_(...)_(\d+)", netname) | |
| if match: | |
| if match.group(2) == "bot": nx, ny = (x, y-1) | |
| if match.group(2) == "bnl": nx, ny = (x-1, y-1) | |
| if match.group(2) == "bnr": nx, ny = (x+1, y-1) | |
| if match.group(2) == "top": nx, ny = (x, y+1) | |
| if match.group(2) == "tnl": nx, ny = (x-1, y+1) | |
| if match.group(2) == "tnr": nx, ny = (x+1, y+1) | |
| if match.group(2) == "lft": nx, ny = (x-1, y ) | |
| if match.group(2) == "rgt": nx, ny = (x+1, y ) | |
| n = self.lookup_funcnet(nx, ny, x, y, int(match.group(3))) | |
| if n is not None: | |
| neighbours.add(n) | |
| for direction in ["l", "r", "t", "b"]: | |
| n = self.tile_follow_net(x, y, direction, netname) | |
| if n is not None: | |
| if direction == "l": s = (x-1, y, n) | |
| if direction == "r": s = (x+1, y, n) | |
| if direction == "t": s = (x, y+1, n) | |
| if direction == "b": s = (x, y-1, n) | |
| if s[0] in (0, self.max_x) and s[1] in (0, self.max_y): | |
| if self.is_ultra(): | |
| s = self.ultraplus_follow_corner(self.get_corner(s[0], s[1]), direction, n) | |
| if s is None: | |
| continue | |
| elif re_match_cached("span4_(vert|horz)_[lrtb]_\d+$", n) and not self.is_ultra(): | |
| m = re_match_cached("span4_(vert|horz)_([lrtb])_\d+$", n) | |
| vert_net = n.replace("_l_", "_t_").replace("_r_", "_b_").replace("_horz_", "_vert_") | |
| horz_net = n.replace("_t_", "_l_").replace("_b_", "_r_").replace("_vert_", "_horz_") | |
| if s[0] == 0 and s[1] == 0: | |
| if direction == "l": s = (0, 1, vert_net) | |
| if direction == "b": s = (1, 0, horz_net) | |
| if s[0] == self.max_x and s[1] == self.max_y: | |
| if direction == "r": s = (self.max_x, self.max_y-1, vert_net) | |
| if direction == "t": s = (self.max_x-1, self.max_y, horz_net) | |
| vert_net = netname.replace("_l_", "_t_").replace("_r_", "_b_").replace("_horz_", "_vert_") | |
| horz_net = netname.replace("_t_", "_l_").replace("_b_", "_r_").replace("_vert_", "_horz_") | |
| if s[0] == 0 and s[1] == self.max_y: | |
| if direction == "l": s = (0, self.max_y-1, vert_net) | |
| if direction == "t": s = (1, self.max_y, horz_net) | |
| if s[0] == self.max_x and s[1] == 0: | |
| if direction == "r": s = (self.max_x, 1, vert_net) | |
| if direction == "b": s = (self.max_x-1, 0, horz_net) | |
| if self.tile_has_net(s[0], s[1], s[2]): | |
| neighbours.add((s[0], s[1], s[2])) | |
| #print('\tafter directions', neighbours) | |
| return neighbours | |
| def get_net_number(self, segment): | |
| if not hasattr(self, 'net_map') or self.net_map is None: | |
| self.net_map = {} | |
| for netidx, group in enumerate(sorted(self.all_group_segments())): | |
| for seg in group: | |
| self.net_map[seg] = netidx | |
| return self.net_map[segment] | |
| def all_group_segments(self): | |
| if not hasattr(self, 'all_groups') or self.all_groups is None: | |
| all_tiles = set() | |
| for x in range(self.max_x + 1): | |
| for y in range(self.max_y + 1): | |
| if self.tile(x, y) is not None: | |
| all_tiles.add((x, y)) | |
| self.all_groups = self.group_segments(all_tiles, connect_gb=False) | |
| return self.all_groups | |
| def group_segments(self, all_from_tiles=set(), extra_connections=list(), extra_segments=list(), connect_gb=True): | |
| seed_segments = set() | |
| seen_segments = set() | |
| connected_segments = dict() | |
| grouped_segments = set() | |
| for seg in extra_segments: | |
| seed_segments.add(seg) | |
| for conn in extra_connections: | |
| s1, s2 = conn | |
| connected_segments.setdefault(s1, set()).add(s2) | |
| connected_segments.setdefault(s2, set()).add(s1) | |
| seed_segments.add(s1) | |
| seed_segments.add(s2) | |
| for idx, tile in self.io_tiles.items(): | |
| tc = tileconfig(tile) | |
| pintypes = [ list("000000"), list("000000") ] | |
| for entry in self.tile_db(idx[0], idx[1]): | |
| if entry[1].startswith("IOB_") and entry[2].startswith("PINTYPE_") and tc.match(entry[0]): | |
| pintypes[int(entry[1][-1])][int(entry[2][-1])] = "1" | |
| if "".join(pintypes[0][2:6]) != "0000": | |
| seed_segments.add((idx[0], idx[1], "io_0/D_OUT_0")) | |
| if "".join(pintypes[1][2:6]) != "0000": | |
| seed_segments.add((idx[0], idx[1], "io_1/D_OUT_0")) | |
| def add_seed_segments(idx, tile, db): | |
| tc = tileconfig(tile) | |
| for entry in db: | |
| if entry[1] in ("routing", "buffer"): | |
| config_match = tc.match(entry[0]) | |
| if idx in all_from_tiles or config_match: | |
| if not self.tile_has_net(idx[0], idx[1], entry[2]): continue | |
| if not self.tile_has_net(idx[0], idx[1], entry[3]): continue | |
| s1 = (idx[0], idx[1], entry[2]) | |
| s2 = (idx[0], idx[1], entry[3]) | |
| if config_match: | |
| connected_segments.setdefault(s1, set()).add(s2) | |
| connected_segments.setdefault(s2, set()).add(s1) | |
| seed_segments.add(s1) | |
| seed_segments.add(s2) | |
| for idx, tile in self.io_tiles.items(): | |
| add_seed_segments(idx, tile, self.tile_db(idx[0], idx[1])) | |
| for idx, tile in self.logic_tiles.items(): | |
| if idx in all_from_tiles: | |
| seed_segments.add((idx[0], idx[1], "lutff_7/cout")) | |
| if self.device == "1k": | |
| add_seed_segments(idx, tile, logictile_db) | |
| elif self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, logictile_5k_db) | |
| elif self.device == "8k" or self.device == "lm4k": | |
| add_seed_segments(idx, tile, logictile_8k_db) | |
| elif self.device == "384": | |
| add_seed_segments(idx, tile, logictile_384_db) | |
| else: | |
| assert False | |
| for idx, tile in self.ramb_tiles.items(): | |
| if self.device == "1k": | |
| add_seed_segments(idx, tile, rambtile_db) | |
| elif self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, rambtile_8k_db) | |
| elif self.device == "8k" or self.device == "lm4k": | |
| add_seed_segments(idx, tile, rambtile_8k_db) | |
| else: | |
| assert False | |
| for idx, tile in self.ramt_tiles.items(): | |
| if self.device == "1k": | |
| add_seed_segments(idx, tile, ramttile_db) | |
| elif self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, ramttile_8k_db) | |
| elif self.device == "8k" or self.device == "lm4k": | |
| add_seed_segments(idx, tile, ramttile_8k_db) | |
| else: | |
| assert False | |
| for idx, tile in self.dsp_tiles[0].items(): | |
| if self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, dsp0_5k_db) | |
| for idx, tile in self.dsp_tiles[1].items(): | |
| if self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, dsp1_5k_db) | |
| for idx, tile in self.dsp_tiles[2].items(): | |
| if self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, dsp2_5k_db) | |
| for idx, tile in self.dsp_tiles[3].items(): | |
| if self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, dsp3_5k_db) | |
| for idx, tile in self.ipcon_tiles.items(): | |
| if self.device == "5k" or self.device == "u4k": | |
| add_seed_segments(idx, tile, ipcon_5k_db) | |
| for padin, pio in enumerate(self.padin_pio_db()): | |
| s1 = (pio[0], pio[1], "padin_%d" % pio[2]) | |
| s2 = (pio[0], pio[1], "glb_netwk_%d" % padin) | |
| if s1 in seed_segments or (pio[0], pio[1]) in all_from_tiles: | |
| connected_segments.setdefault(s1, set()).add(s2) | |
| connected_segments.setdefault(s2, set()).add(s1) | |
| seed_segments.add(s1) | |
| seed_segments.add(s2) | |
| for entry in self.iolatch_db(): | |
| if entry[0] == 0 or entry[0] == self.max_x: | |
| iocells = [(entry[0], i) for i in range(1, self.max_y)] | |
| if entry[1] == 0 or entry[1] == self.max_y: | |
| iocells = [(i, entry[1]) for i in range(1, self.max_x)] | |
| for cell in iocells: | |
| s1 = (entry[0], entry[1], "fabout") | |
| s2 = (cell[0], cell[1], "io_global/latch") | |
| if s1 in seed_segments or s2 in seed_segments or \ | |
| (entry[0], entry[1]) in all_from_tiles or (cell[0], cell[1]) in all_from_tiles: | |
| connected_segments.setdefault(s1, set()).add(s2) | |
| connected_segments.setdefault(s2, set()).add(s1) | |
| seed_segments.add(s1) | |
| seed_segments.add(s2) | |
| if connect_gb: | |
| for entry in self.gbufin_db(): | |
| s1 = (entry[0], entry[1], "fabout") | |
| s2 = (entry[0], entry[1], "glb_netwk_%d" % entry[2]) | |
| if s1 in seed_segments or (pio[0], pio[1]) in all_from_tiles: | |
| connected_segments.setdefault(s1, set()).add(s2) | |
| connected_segments.setdefault(s2, set()).add(s1) | |
| seed_segments.add(s1) | |
| seed_segments.add(s2) | |
| while seed_segments: | |
| queue = set() | |
| segments = set() | |
| queue.add(seed_segments.pop()) | |
| while queue: | |
| next_segment = queue.pop() | |
| expanded = self.expand_net(next_segment) | |
| for s in expanded: | |
| if s not in segments: | |
| segments.add(s) | |
| if s in seen_segments: | |
| print("//", s, "has already been seen. Check your bitmapping.") | |
| assert False | |
| seen_segments.add(s) | |
| seed_segments.discard(s) | |
| if s in connected_segments: | |
| for cs in connected_segments[s]: | |
| if not cs in segments: | |
| queue.add(cs) | |
| for s in segments: | |
| assert s not in seed_segments | |
| grouped_segments.add(tuple(sorted(segments))) | |
| return grouped_segments | |
| def expand_net(self, netspec): | |
| queue = set() | |
| segments = set() | |
| queue.add(netspec) | |
| while queue: | |
| n = queue.pop() | |
| segments.add(n) | |
| for k in self.follow_net(n): | |
| if k not in segments: | |
| queue.add(k) | |
| return segments | |
| def read_file(self, filename): | |
| self.clear() | |
| current_data = None | |
| expected_data_lines = 0 | |
| with open(filename, "r") as f: | |
| for linenum, linetext in enumerate(f): | |
| # print("DEBUG: input line %d: %s" % (linenum, linetext.strip())) | |
| line = linetext.strip().split() | |
| if len(line) == 0: | |
| assert expected_data_lines == 0 | |
| continue | |
| if line[0][0] != ".": | |
| if expected_data_lines == -1: | |
| continue | |
| if line[0][0] not in "0123456789abcdef": | |
| print("Warning: ignoring data block in line %d: %s" % (linenum, linetext.strip())) | |
| expected_data_lines = 0 | |
| continue | |
| assert expected_data_lines != 0 | |
| current_data.append(line[0]) | |
| expected_data_lines -= 1 | |
| continue | |
| assert expected_data_lines <= 0 | |
| if line[0] in (".io_tile", ".logic_tile", ".ramb_tile", ".ramt_tile", ".ram_data", ".ipcon_tile", ".dsp0_tile", ".dsp1_tile", ".dsp2_tile", ".dsp3_tile"): | |
| current_data = list() | |
| expected_data_lines = 16 | |
| self.max_x = max(self.max_x, int(line[1])) | |
| self.max_y = max(self.max_y, int(line[2])) | |
| if line[0] == ".io_tile": | |
| self.io_tiles[(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| if line[0] == ".logic_tile": | |
| self.logic_tiles[(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| if line[0] == ".ramb_tile": | |
| self.ramb_tiles[(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| if line[0] == ".ramt_tile": | |
| self.ramt_tiles[(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| if line[0] == ".ipcon_tile": | |
| self.ipcon_tiles[(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| match = re_match_cached(r".dsp(\d)_tile", line[0]) | |
| if match: | |
| self.dsp_tiles[int(match.group(1))][(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| if line[0] == ".ram_data": | |
| self.ram_data[(int(line[1]), int(line[2]))] = current_data | |
| continue | |
| if line[0] == ".extra_bit": | |
| self.extra_bits.add((int(line[1]), int(line[2]), int(line[3]))) | |
| continue | |
| if line[0] == ".device": | |
| assert line[1] in ["1k", "lm4k", "u4k", "5k", "8k", "384"] | |
| self.device = line[1] | |
| continue | |
| if line[0] == ".warmboot": | |
| assert line[1] in ["disabled", "enabled"] | |
| self.warmboot = line[1] == "enabled" | |
| continue | |
| if line[0] == ".sym": | |
| self.symbols.setdefault(int(line[1]), set()).add(line[2]) | |
| continue | |
| if line[0] == ".comment": | |
| expected_data_lines = -1 | |
| continue | |
| print("Warning: ignoring line %d: %s" % (linenum, linetext.strip())) | |
| expected_data_lines = -1 | |
| def write_file(self, filename): | |
| with open(filename, "w") as f: | |
| print(".device %s" % self.device, file=f) | |
| if not self.warmboot: | |
| print(".warmboot disabled", file=f) | |
| for y in range(self.max_y+1): | |
| for x in range(self.max_x+1): | |
| if self.tile_pos(x, y) is not None: | |
| print(".%s_tile %d %d" % (self.tile_type(x, y).lower(), x, y), file=f) | |
| for line in self.tile(x, y): | |
| print(line, file=f) | |
| for x, y in sorted(self.ram_data): | |
| print(".ram_data %d %d" % (x, y), file=f) | |
| for line in self.ram_data[(x, y)]: | |
| print(line, file=f) | |
| for extra_bit in sorted(self.extra_bits): | |
| print(".extra_bit %d %d %d" % extra_bit, file=f) | |
| for net in sorted(self.symbols.keys()): | |
| for sym_key in self.symbols[net]: | |
| print(".sym %s %s" % (net, sym_key), file=f) | |
| class tileconfig: | |
| def __init__(self, tile): | |
| self.bits = set() | |
| for k, line in enumerate(tile): | |
| for i in range(len(line)): | |
| if line[i] == "1": | |
| self.bits.add("B%d[%d]" % (k, i)) | |
| else: | |
| self.bits.add("!B%d[%d]" % (k, i)) | |
| def match(self, pattern): | |
| for bit in pattern: | |
| if not bit in self.bits: | |
| return False | |
| return True | |
| if False: | |
| ## Lattice span net name normalization | |
| valid_sp4_h_l = set([1, 2, 4, 5, 7, 9, 10, 11, 15, 16, 17, 21, 24, 34, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]) | |
| valid_sp4_h_r = set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 19, 21, 24, 25, 27, 30, 31, 33, 34, 35, 36, 38, 39, 40, 41, 42, 43, 44, 45, 46]) | |
| valid_sp4_v_t = set([1, 3, 5, 9, 12, 14, 16, 17, 18, 21, 22, 23, 26, 28, 29, 30, 32, 33, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]) | |
| valid_sp4_v_b = set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 18, 19, 21, 22, 23, 24, 26, 30, 33, 36, 37, 38, 42, 46, 47]) | |
| valid_sp12_h_l = set([3, 4, 5, 12, 14, 16, 17, 18, 21, 22, 23]) | |
| valid_sp12_h_r = set([0, 1, 2, 3, 5, 8, 9, 10, 11, 12, 13, 14, 16, 20, 23]) | |
| valid_sp12_v_t = set([0, 1, 2, 3, 6, 9, 10, 12, 14, 21, 22, 23]) | |
| valid_sp12_v_b = set([0, 1, 6, 7, 8, 11, 12, 14, 16, 18, 19, 20, 21, 23]) | |
| else: | |
| ## IceStorm span net name normalization | |
| valid_sp4_h_l = set(range(36, 48)) | |
| valid_sp4_h_r = set(range(48)) | |
| valid_sp4_v_t = set(range(36, 48)) | |
| valid_sp4_v_b = set(range(48)) | |
| valid_sp12_h_l = set(range(22, 24)) | |
| valid_sp12_h_r = set(range(24)) | |
| valid_sp12_v_t = set(range(22, 24)) | |
| valid_sp12_v_b = set(range(24)) | |
| def sp4h_normalize(netname, edge=""): | |
| m = re_match_cached("sp4_h_([lr])_(\d+)$", netname) | |
| assert m | |
| if not m: return None | |
| cur_edge = m.group(1) | |
| cur_index = int(m.group(2)) | |
| if cur_edge == edge: | |
| return netname | |
| if cur_edge == "r" and (edge == "l" or (edge == "" and cur_index not in valid_sp4_h_r)): | |
| if cur_index < 12: | |
| return None | |
| return "sp4_h_l_%d" % ((cur_index-12)^1) | |
| if cur_edge == "l" and (edge == "r" or (edge == "" and cur_index not in valid_sp4_h_l)): | |
| if cur_index >= 36: | |
| return None | |
| return "sp4_h_r_%d" % ((cur_index+12)^1) | |
| return netname | |
| # "Normalization" of span4 (not just sp4) is needed during Ultra/UltraPlus | |
| # corner tracing | |
| def ultra_span4_horz_normalize(netname, edge=""): | |
| m = re_match_cached("span4_horz_([rl])_(\d+)$", netname) | |
| assert m | |
| if not m: return None | |
| cur_edge = m.group(1) | |
| cur_index = int(m.group(2)) | |
| if cur_edge == edge: | |
| return netname | |
| if edge == "": | |
| if cur_edge == "l" and cur_index < 12: | |
| return "span4_horz_r_%d" % (cur_index + 4) | |
| else: | |
| return netname | |
| elif edge == "l" and cur_edge == "r": | |
| if cur_index < 4: | |
| return None | |
| else: | |
| cur_index -= 4 | |
| return "span4_horz_l_%d" % cur_index | |
| elif edge == "r" and cur_edge == "l": | |
| if cur_index < 12: | |
| return "span4_horz_r_%d" % (cur_index + 4) | |
| else: | |
| return None | |
| assert False | |
| def sp4v_normalize(netname, edge=""): | |
| m = re_match_cached("sp4_v_([bt])_(\d+)$", netname) | |
| assert m | |
| if not m: return None | |
| cur_edge = m.group(1) | |
| cur_index = int(m.group(2)) | |
| if cur_edge == edge: | |
| return netname | |
| if cur_edge == "b" and (edge == "t" or (edge == "" and cur_index not in valid_sp4_v_b)): | |
| if cur_index < 12: | |
| return None | |
| return "sp4_v_t_%d" % ((cur_index-12)^1) | |
| if cur_edge == "t" and (edge == "b" or (edge == "" and cur_index not in valid_sp4_v_t)): | |
| if cur_index >= 36: | |
| return None | |
| return "sp4_v_b_%d" % ((cur_index+12)^1) | |
| return netname | |
| def sp12h_normalize(netname, edge=""): | |
| m = re_match_cached("sp12_h_([lr])_(\d+)$", netname) | |
| assert m | |
| if not m: return None | |
| cur_edge = m.group(1) | |
| cur_index = int(m.group(2)) | |
| if cur_edge == edge: | |
| return netname | |
| if cur_edge == "r" and (edge == "l" or (edge == "" and cur_index not in valid_sp12_h_r)): | |
| if cur_index < 2: | |
| return None | |
| return "sp12_h_l_%d" % ((cur_index-2)^1) | |
| if cur_edge == "l" and (edge == "r" or (edge == "" and cur_index not in valid_sp12_h_l)): | |
| if cur_index >= 22: | |
| return None | |
| return "sp12_h_r_%d" % ((cur_index+2)^1) | |
| return netname | |
| def sp12v_normalize(netname, edge=""): | |
| m = re_match_cached("sp12_v_([bt])_(\d+)$", netname) | |
| assert m | |
| if not m: return None | |
| cur_edge = m.group(1) | |
| cur_index = int(m.group(2)) | |
| if cur_edge == edge: | |
| return netname | |
| if cur_edge == "b" and (edge == "t" or (edge == "" and cur_index not in valid_sp12_v_b)): | |
| if cur_index < 2: | |
| return None | |
| return "sp12_v_t_%d" % ((cur_index-2)^1) | |
| if cur_edge == "t" and (edge == "b" or (edge == "" and cur_index not in valid_sp12_v_t)): | |
| if cur_index >= 22: | |
| return None | |
| return "sp12_v_b_%d" % ((cur_index+2)^1) | |
| return netname | |
| def netname_normalize(netname, edge="", ramb=False, ramt=False, ramb_8k=False, ramt_8k=False): | |
| if netname.startswith("sp4_v_"): return sp4v_normalize(netname, edge) | |
| if netname.startswith("sp4_h_"): return sp4h_normalize(netname, edge) | |
| if netname.startswith("sp12_v_"): return sp12v_normalize(netname, edge) | |
| if netname.startswith("sp12_h_"): return sp12h_normalize(netname, edge) | |
| if netname.startswith("input_2_"): netname = netname.replace("input_2_", "wire_logic_cluster/lc_") + "/in_2" | |
| netname = netname.replace("lc_trk_", "local_") | |
| netname = netname.replace("lc_", "lutff_") | |
| netname = netname.replace("wire_logic_cluster/", "") | |
| netname = netname.replace("wire_io_cluster/", "") | |
| netname = netname.replace("wire_mult/", "") | |
| netname = netname.replace("wire_con_box/", "") | |
| netname = netname.replace("wire_bram/", "") | |
| if (ramb or ramt or ramb_8k or ramt_8k) and netname.startswith("input"): | |
| match = re_match_cached(r"input(\d)_(\d)", netname) | |
| idx1, idx2 = (int(match.group(1)), int(match.group(2))) | |
| if ramb: netname="ram/WADDR_%d" % (idx1*4 + idx2) | |
| if ramt: netname="ram/RADDR_%d" % (idx1*4 + idx2) | |
| if ramb_8k: netname="ram/RADDR_%d" % ([7, 6, 5, 4, 3, 2, 1, 0, -1, -1, -1, -1, -1, 10, 9, 8][idx1*4 + idx2]) | |
| if ramt_8k: netname="ram/WADDR_%d" % ([7, 6, 5, 4, 3, 2, 1, 0, -1, -1, -1, -1, -1, 10, 9, 8][idx1*4 + idx2]) | |
| match = re_match_cached(r"(...)_op_(.*)", netname) | |
| if match and (match.group(1) != "slf"): | |
| netname = "neigh_op_%s_%s" % (match.group(1), match.group(2)) | |
| if re_match_cached(r"lutff_7/(cen|clk|s_r)", netname): | |
| netname = netname.replace("lutff_7/", "lutff_global/") | |
| if re_match_cached(r"io_1/(cen|inclk|outclk)", netname): | |
| netname = netname.replace("io_1/", "io_global/") | |
| if netname == "carry_in_mux/cout": | |
| return "carry_in_mux" | |
| return netname | |
| def pos_has_net(pos, netname): | |
| if pos in ("l", "r"): | |
| if re_search_cached(r"_vert_\d+$", netname): return False | |
| if re_search_cached(r"_horz_[rl]_\d+$", netname): return False | |
| if pos in ("t", "b"): | |
| if re_search_cached(r"_horz_\d+$", netname): return False | |
| if re_search_cached(r"_vert_[bt]_\d+$", netname): return False | |
| return True | |
| def pos_follow_net(pos, direction, netname, is_ultra): | |
| if pos == "x" or ((pos in ("l", "r")) and is_ultra): | |
| m = re_match_cached("sp4_h_[lr]_(\d+)$", netname) | |
| if m and direction in ("l", "L"): | |
| n = sp4h_normalize(netname, "l") | |
| if n is not None: | |
| if direction == "l" or is_ultra: | |
| n = re_sub_cached("_l_", "_r_", n) | |
| n = sp4h_normalize(n) | |
| else: | |
| n = re_sub_cached("_l_", "_", n) | |
| n = re_sub_cached("sp4_h_", "span4_horz_", n) | |
| return n | |
| if m and direction in ("r", "R"): | |
| n = sp4h_normalize(netname, "r") | |
| if n is not None: | |
| if direction == "r" or is_ultra: | |
| n = re_sub_cached("_r_", "_l_", n) | |
| n = sp4h_normalize(n) | |
| else: | |
| n = re_sub_cached("_r_", "_", n) | |
| n = re_sub_cached("sp4_h_", "span4_horz_", n) | |
| return n | |
| m = re_match_cached("sp4_v_[tb]_(\d+)$", netname) | |
| if m and direction in ("t", "T"): | |
| n = sp4v_normalize(netname, "t") | |
| if n is not None: | |
| if is_ultra and direction == "T" and pos in ("l", "r"): | |
| return re_sub_cached("sp4_v_", "span4_vert_", n) | |
| elif direction == "t": | |
| n = re_sub_cached("_t_", "_b_", n) | |
| n = sp4v_normalize(n) | |
| else: | |
| n = re_sub_cached("_t_", "_", n) | |
| n = re_sub_cached("sp4_v_", "span4_vert_", n) | |
| return n | |
| if m and direction in ("b", "B"): | |
| n = sp4v_normalize(netname, "b") | |
| if n is not None: | |
| if is_ultra and direction == "B" and pos in ("l", "r"): | |
| return re_sub_cached("sp4_v_", "span4_vert_", n) | |
| elif direction == "b": | |
| n = re_sub_cached("_b_", "_t_", n) | |
| n = sp4v_normalize(n) | |
| else: | |
| n = re_sub_cached("_b_", "_", n) | |
| n = re_sub_cached("sp4_v_", "span4_vert_", n) | |
| return n | |
| m = re_match_cached("sp12_h_[lr]_(\d+)$", netname) | |
| if m and direction in ("l", "L"): | |
| n = sp12h_normalize(netname, "l") | |
| if n is not None: | |
| if direction == "l" or is_ultra: | |
| n = re_sub_cached("_l_", "_r_", n) | |
| n = sp12h_normalize(n) | |
| else: | |
| n = re_sub_cached("_l_", "_", n) | |
| n = re_sub_cached("sp12_h_", "span12_horz_", n) | |
| return n | |
| if m and direction in ("r", "R"): | |
| n = sp12h_normalize(netname, "r") | |
| if n is not None: | |
| if direction == "r" or is_ultra: | |
| n = re_sub_cached("_r_", "_l_", n) | |
| n = sp12h_normalize(n) | |
| else: | |
| n = re_sub_cached("_r_", "_", n) | |
| n = re_sub_cached("sp12_h_", "span12_horz_", n) | |
| return n | |
| m = re_match_cached("sp12_v_[tb]_(\d+)$", netname) | |
| if m and direction in ("t", "T"): | |
| n = sp12v_normalize(netname, "t") | |
| if n is not None: | |
| if direction == "t": | |
| n = re_sub_cached("_t_", "_b_", n) | |
| n = sp12v_normalize(n) | |
| elif direction == "T" and pos in ("l", "r"): | |
| pass | |
| else: | |
| n = re_sub_cached("_t_", "_", n) | |
| n = re_sub_cached("sp12_v_", "span12_vert_", n) | |
| return n | |
| if m and direction in ("b", "B"): | |
| n = sp12v_normalize(netname, "b") | |
| if n is not None: | |
| if direction == "b": | |
| n = re_sub_cached("_b_", "_t_", n) | |
| n = sp12v_normalize(n) | |
| elif direction == "B" and pos in ("l", "r"): | |
| pass | |
| else: | |
| n = re_sub_cached("_b_", "_", n) | |
| n = re_sub_cached("sp12_v_", "span12_vert_", n) | |
| return n | |
| if (pos in ("l", "r" )) and (not is_ultra): | |
| m = re_match_cached("span4_vert_([bt])_(\d+)$", netname) | |
| if m: | |
| case, idx = direction + m.group(1), int(m.group(2)) | |
| if case == "tt": | |
| return "span4_vert_b_%d" % idx | |
| if case == "tb" and idx >= 4: | |
| return "span4_vert_b_%d" % (idx-4) | |
| if case == "bb" and idx < 12: | |
| return "span4_vert_b_%d" % (idx+4) | |
| if case == "bb" and idx >= 12: | |
| return "span4_vert_t_%d" % idx | |
| if pos in ("t", "b" ): | |
| m = re_match_cached("span4_horz_([rl])_(\d+)$", netname) | |
| if m: | |
| case, idx = direction + m.group(1), int(m.group(2)) | |
| if direction == "L": | |
| return ultra_span4_horz_normalize(netname, "l") | |
| elif direction == "R": | |
| return ultra_span4_horz_normalize(netname, "r") | |
| if case == "ll": | |
| return "span4_horz_r_%d" % idx | |
| if case == "lr" and idx >= 4: | |
| return "span4_horz_r_%d" % (idx-4) | |
| if case == "rr" and idx < 12: | |
| return "span4_horz_r_%d" % (idx+4) | |
| if case == "rr" and idx >= 12: | |
| return "span4_horz_l_%d" % idx | |
| if pos == "l" and direction == "r" and (not is_ultra): | |
| m = re_match_cached("span4_horz_(\d+)$", netname) | |
| if m: return sp4h_normalize("sp4_h_l_%s" % m.group(1)) | |
| m = re_match_cached("span12_horz_(\d+)$", netname) | |
| if m: return sp12h_normalize("sp12_h_l_%s" % m.group(1)) | |
| if pos == "r" and direction == "l" and (not is_ultra): | |
| m = re_match_cached("span4_horz_(\d+)$", netname) | |
| if m: return sp4h_normalize("sp4_h_r_%s" % m.group(1)) | |
| m = re_match_cached("span12_horz_(\d+)$", netname) | |
| if m: return sp12h_normalize("sp12_h_r_%s" % m.group(1)) | |
| if pos == "t" and direction == "b": | |
| m = re_match_cached("span4_vert_(\d+)$", netname) | |
| if m: return sp4v_normalize("sp4_v_t_%s" % m.group(1)) | |
| m = re_match_cached("span12_vert_(\d+)$", netname) | |
| if m: return sp12v_normalize("sp12_v_t_%s" % m.group(1)) | |
| if pos == "b" and direction == "t": | |
| m = re_match_cached("span4_vert_(\d+)$", netname) | |
| if m: return sp4v_normalize("sp4_v_b_%s" % m.group(1)) | |
| m = re_match_cached("span12_vert_(\d+)$", netname) | |
| if m: return sp12v_normalize("sp12_v_b_%s" % m.group(1)) | |
| return None | |
| def get_lutff_bits(tile, index): | |
| bits = list("--------------------") | |
| for k, line in enumerate(tile): | |
| for i in range(36, 46): | |
| lutff_idx = k // 2 | |
| lutff_bitnum = (i-36) + 10*(k%2) | |
| if lutff_idx == index: | |
| bits[lutff_bitnum] = line[i]; | |
| return bits | |
| def get_lutff_lut_bits(tile, index): | |
| lutff_bits = get_lutff_bits(tile, index) | |
| return [lutff_bits[i] for i in [4, 14, 15, 5, 6, 16, 17, 7, 3, 13, 12, 2, 1, 11, 10, 0]] | |
| def get_lutff_seq_bits(tile, index): | |
| lutff_bits = get_lutff_bits(tile, index) | |
| return [lutff_bits[i] for i in [8, 9, 18, 19]] | |
| def get_carry_cascade_bit(tile): | |
| return tile[1][49] | |
| def get_carry_bit(tile): | |
| return tile[1][50] | |
| def get_negclk_bit(tile): | |
| return tile[0][0] | |
| def key_netname(netname): | |
| return re_sub_cached(r"\d+", lambda m: "%09d" % int(m.group(0)), netname) | |
| def run_checks_neigh(): | |
| print("Running consistency checks on neighbour finder..") | |
| ic = iceconfig() | |
| # ic.setup_empty_1k() | |
| #ic.setup_empty_lm4k() | |
| ic.setup_empty_u4k() | |
| #ic.setup_empty_5k() | |
| # ic.setup_empty_8k() | |
| # ic.setup_empty_384() | |
| all_segments = set() | |
| def add_segments(idx, db): | |
| for entry in db: | |
| if entry[1] in ("routing", "buffer"): | |
| if not ic.tile_has_net(idx[0], idx[1], entry[2]): continue | |
| if not ic.tile_has_net(idx[0], idx[1], entry[3]): continue | |
| all_segments.add((idx[0], idx[1], entry[2])) | |
| all_segments.add((idx[0], idx[1], entry[3])) | |
| for x in range(ic.max_x+1): | |
| for y in range(ic.max_x+1): | |
| # Skip the corners. | |
| if x in (0, ic.max_x) and y in (0, ic.max_y): | |
| continue | |
| add_segments((x, y), ic.tile_db(x, y)) | |
| if (x, y) in ic.logic_tiles: | |
| all_segments.add((x, y, "lutff_7/cout")) | |
| for s1 in all_segments: | |
| for s2 in ic.follow_net(s1): | |
| # if s1[1] > 4: continue | |
| if s1 not in ic.follow_net(s2): | |
| print("ERROR: %s -> %s, but not vice versa!" % (s1, s2)) | |
| print("Neighbours of %s:" % (s1,)) | |
| for s in ic.follow_net(s1): | |
| print(" ", s) | |
| print("Neighbours of %s:" % (s2,)) | |
| for s in ic.follow_net(s2): | |
| print(" ", s) | |
| print() | |
| def run_checks(): | |
| run_checks_neigh() | |
| def parse_db(text, device="1k"): | |
| db = list() | |
| for line in text.split("\n"): | |
| line_384 = line.replace("384_glb_netwk_", "glb_netwk_") | |
| line_1k = line.replace("1k_glb_netwk_", "glb_netwk_") | |
| line_8k = line.replace("8k_glb_netwk_", "glb_netwk_") | |
| if line_1k != line: | |
| if device != "1k": | |
| continue | |
| line = line_1k | |
| elif line_8k != line: | |
| # global network is the same for 8k, 5k, lm4k, and u4k | |
| if device != "8k" and device != "5k" and device != "lm4k" and device != "u4k": | |
| continue | |
| line = line_8k | |
| elif line_384 != line: | |
| if device != "384": | |
| continue | |
| line = line_384 | |
| line = line.split("\t") | |
| if len(line) == 0 or line[0] == "": | |
| continue | |
| line[0] = line[0].split(",") | |
| db.append(line) | |
| return db | |
| extra_bits_db = { | |
| "1k": { | |
| (0, 330, 142): ("padin_glb_netwk", "0"), | |
| (0, 331, 142): ("padin_glb_netwk", "1"), | |
| (1, 330, 143): ("padin_glb_netwk", "2"), | |
| (1, 331, 143): ("padin_glb_netwk", "3"), # (1 3) (331 144) (331 144) routing T_0_0.padin_3 <X> T_0_0.glb_netwk_3 | |
| (1, 330, 142): ("padin_glb_netwk", "4"), | |
| (1, 331, 142): ("padin_glb_netwk", "5"), | |
| (0, 330, 143): ("padin_glb_netwk", "6"), # (0 0) (330 143) (330 143) routing T_0_0.padin_6 <X> T_0_0.glb_netwk_6 | |
| (0, 331, 143): ("padin_glb_netwk", "7"), | |
| }, | |
| "lm4k": { | |
| (0, 654, 174): ("padin_glb_netwk", "0"), | |
| (0, 655, 174): ("padin_glb_netwk", "1"), | |
| (1, 654, 175): ("padin_glb_netwk", "2"), | |
| (1, 655, 175): ("padin_glb_netwk", "3"), | |
| (1, 654, 174): ("padin_glb_netwk", "4"), # HSOSC | |
| (1, 655, 174): ("padin_glb_netwk", "5"), # LSOSC | |
| (0, 654, 175): ("padin_glb_netwk", "6"), | |
| (0, 655, 175): ("padin_glb_netwk", "7"), | |
| }, | |
| "5k": { | |
| (0, 690, 334): ("padin_glb_netwk", "0"), # check | |
| (0, 691, 334): ("padin_glb_netwk", "1"), # good | |
| (1, 690, 175): ("padin_glb_netwk", "2"), # good | |
| (1, 691, 175): ("padin_glb_netwk", "3"), # check | |
| (1, 690, 174): ("padin_glb_netwk", "4"), # good (INTOSC only) | |
| (1, 691, 174): ("padin_glb_netwk", "5"), # good (INTOSC only) | |
| (0, 690, 335): ("padin_glb_netwk", "6"), # check | |
| (0, 691, 335): ("padin_glb_netwk", "7"), # good | |
| }, | |
| "u4k": { | |
| (0, 691, 175): ("padin_glb_netwk", "0"), # good | |
| (1, 690, 175): ("padin_glb_netwk", "1"), # good | |
| (0, 690, 175): ("padin_glb_netwk", "2"), # made up | |
| (0, 690, 174): ("padin_glb_netwk", "3"), # good | |
| (1, 690, 174): ("padin_glb_netwk", "4"), # HFOSC, good | |
| (1, 691, 174): ("padin_glb_netwk", "5"), # LFOSC, good | |
| (0, 691, 174): ("padin_glb_netwk", "6"), # good | |
| (1, 691, 175): ("padin_glb_netwk", "7"), # made up | |
| }, | |
| "8k": { | |
| (0, 870, 270): ("padin_glb_netwk", "0"), | |
| (0, 871, 270): ("padin_glb_netwk", "1"), | |
| (1, 870, 271): ("padin_glb_netwk", "2"), | |
| (1, 871, 271): ("padin_glb_netwk", "3"), | |
| (1, 870, 270): ("padin_glb_netwk", "4"), | |
| (1, 871, 270): ("padin_glb_netwk", "5"), | |
| (0, 870, 271): ("padin_glb_netwk", "6"), | |
| (0, 871, 271): ("padin_glb_netwk", "7"), | |
| }, | |
| "384": { | |
| (0, 180, 78): ("padin_glb_netwk", "0"), | |
| (0, 181, 78): ("padin_glb_netwk", "1"), | |
| (1, 180, 79): ("padin_glb_netwk", "2"), | |
| (1, 181, 79): ("padin_glb_netwk", "3"), | |
| (1, 180, 78): ("padin_glb_netwk", "4"), | |
| (1, 181, 78): ("padin_glb_netwk", "5"), | |
| (0, 180, 79): ("padin_glb_netwk", "6"), | |
| (0, 181, 79): ("padin_glb_netwk", "7"), | |
| } | |
| } | |
| gbufin_db = { | |
| "1k": [ | |
| (13, 8, 7), | |
| ( 0, 8, 6), | |
| ( 7, 17, 1), | |
| ( 7, 0, 0), | |
| ( 0, 9, 3), | |
| (13, 9, 2), | |
| ( 6, 0, 5), | |
| ( 6, 17, 4), | |
| ], | |
| "5k": [ | |
| ( 6, 0, 6), #checked | |
| (12, 0, 5), #checked | |
| (13, 0, 0), #checked | |
| (19, 0, 7), #checked | |
| ( 6, 31, 3), #checked | |
| (12, 31, 4), #checked | |
| (13, 31, 1), #checked | |
| (19, 31, 2), #checked | |
| ], | |
| "u4k": [ | |
| (13, 0, 0), # 0 ok | |
| (13, 21, 1), # 1 ok | |
| (19, 21, 2), # 2 ok | |
| ( 6, 21, 3), # 3 ok | |
| (12, 21, 4), # 4 ok | |
| (12, 0, 5), # 5 ok | |
| ( 6, 0, 6), # 6 ok | |
| (19, 0, 7), # 7 ok | |
| ], | |
| "lm4k": [ | |
| ( 6, 0, 6), | |
| (12, 0, 5), | |
| (13, 0, 0), | |
| (19, 0, 7), | |
| ( 6, 21, 3), | |
| (12, 21, 4), | |
| (13, 21, 1), | |
| (19, 21, 2), | |
| ], | |
| "8k": [ | |
| (33, 16, 7), | |
| ( 0, 16, 6), | |
| (17, 33, 1), | |
| (17, 0, 0), | |
| ( 0, 17, 3), | |
| (33, 17, 2), | |
| (16, 0, 5), | |
| (16, 33, 4), | |
| ], | |
| "384": [ | |
| ( 7, 4, 7), | |
| ( 0, 4, 6), | |
| ( 4, 9, 1), | |
| ( 4, 0, 0), | |
| ( 0, 5, 3), | |
| ( 7, 5, 2), | |
| ( 3, 0, 5), | |
| ( 3, 9, 4), | |
| ] | |
| } | |
| # To figure these out: | |
| # 1. Copy io_latched.sh and convert it for your pinout (like io_latched_5k.sh). | |
| # 2. Run it. It will create an io_latched_<device>.work directory with a bunch of files. | |
| # 3. Grep the *.ve files in that directory for "'fabout')". The coordinates | |
| # before it are where the io latches are. | |
| # | |
| # Note: This may not work if your icepack configuration of cell sizes is incorrect because | |
| # icebox_vlog.py won't correctly interpret the meaning of particular bits. | |
| iolatch_db = { | |
| "1k": [ | |
| ( 0, 7), | |
| (13, 10), | |
| ( 5, 0), | |
| ( 8, 17), | |
| ], | |
| "lm4k": [ | |
| (14, 0), | |
| (14, 21) | |
| ], | |
| "5k": [ | |
| (14, 0), | |
| (14, 31), | |
| ], | |
| "u4k": [ | |
| (14, 0), | |
| (14, 21), | |
| ], | |
| "8k": [ | |
| ( 0, 15), | |
| (33, 18), | |
| (18, 0), | |
| (15, 33), | |
| ], | |
| "384": [ | |
| ( 0, 3), #384? | |
| ( 7, 5), #384? | |
| ( 2, 0), #384? | |
| ( 5, 9), #384? | |
| ], | |
| } | |
| # The x, y cell locations of the WARMBOOT controls. Run tests/sb_warmboot.v | |
| # through icecube.sh to determine these values. | |
| warmbootinfo_db = { | |
| "1k": { | |
| "BOOT": ( 12, 0, "fabout" ), | |
| "S0": ( 13, 1, "fabout" ), | |
| "S1": ( 13, 2, "fabout" ), | |
| }, | |
| "5k": { | |
| # These are the right locations but may be the wrong order. | |
| "BOOT": ( 22, 0, "fabout" ), | |
| "S0": ( 23, 0, "fabout" ), | |
| "S1": ( 24, 0, "fabout" ), | |
| }, | |
| "u4k": { | |
| # These are the right locations but may be the wrong order. | |
| "BOOT": ( 22, 0, "fabout" ), | |
| "S0": ( 23, 0, "fabout" ), | |
| "S1": ( 24, 0, "fabout" ), | |
| }, | |
| "lm4k": { | |
| # These are the right locations but may be the wrong order. | |
| "BOOT": ( 23, 0, "fabout" ), | |
| "S0": ( 24, 0, "fabout" ), | |
| "S1": ( 25, 1, "fabout" ), | |
| }, | |
| "8k": { | |
| "BOOT": ( 31, 0, "fabout" ), | |
| "S0": ( 33, 1, "fabout" ), | |
| "S1": ( 33, 2, "fabout" ), | |
| }, | |
| "384": { | |
| "BOOT": ( 6, 0, "fabout" ), #384? | |
| "S0": ( 7, 1, "fabout" ), | |
| "S1": ( 7, 2, "fabout" ), | |
| } | |
| } | |
| noplls_db = { | |
| "1k-swg16tr": [ "1k" ], | |
| "1k-cm36": [ "1k" ], | |
| "1k-cm49": [ "1k" ], | |
| "8k-cm81": [ "8k_1" ], | |
| "8k-cm81:4k": [ "8k_1" ], | |
| "1k-qn48": [ "1k" ], | |
| "1k-cb81": [ "1k" ], | |
| "1k-cb121": [ "1k" ], | |
| "1k-vq100": [ "1k" ], | |
| "384-qn32": [ "384" ], | |
| } | |
| pllinfo_db = { | |
| "1k": { | |
| "LOC" : (6, 0), | |
| # 3'b000 = "DISABLED" | |
| # 3'b010 = "SB_PLL40_PAD" | |
| # 3'b100 = "SB_PLL40_2_PAD" | |
| # 3'b110 = "SB_PLL40_2F_PAD" | |
| # 3'b011 = "SB_PLL40_CORE" | |
| # 3'b111 = "SB_PLL40_2F_CORE" | |
| "PLLTYPE_0": ( 0, 3, "PLLCONFIG_5"), | |
| "PLLTYPE_1": ( 0, 5, "PLLCONFIG_1"), | |
| "PLLTYPE_2": ( 0, 5, "PLLCONFIG_3"), | |
| # 3'b000 = "DELAY" | |
| # 3'b001 = "SIMPLE" | |
| # 3'b010 = "PHASE_AND_DELAY" | |
| # 3'b110 = "EXTERNAL" | |
| "FEEDBACK_PATH_0": ( 0, 5, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_1": ( 0, 2, "PLLCONFIG_9"), | |
| "FEEDBACK_PATH_2": ( 0, 3, "PLLCONFIG_1"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_FEEDBACK=4'b1111) | |
| "DELAY_ADJMODE_FB": ( 0, 4, "PLLCONFIG_4"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_RELATIVE=4'b1111) | |
| "DELAY_ADJMODE_REL": ( 0, 4, "PLLCONFIG_9"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_A_0": ( 0, 3, "PLLCONFIG_6"), | |
| "PLLOUT_SELECT_A_1": ( 0, 3, "PLLCONFIG_7"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_B_0": ( 0, 3, "PLLCONFIG_2"), | |
| "PLLOUT_SELECT_B_1": ( 0, 3, "PLLCONFIG_3"), | |
| # Numeric Parameters | |
| "SHIFTREG_DIV_MODE": ( 0, 3, "PLLCONFIG_4"), | |
| "FDA_FEEDBACK_0": ( 0, 3, "PLLCONFIG_9"), | |
| "FDA_FEEDBACK_1": ( 0, 4, "PLLCONFIG_1"), | |
| "FDA_FEEDBACK_2": ( 0, 4, "PLLCONFIG_2"), | |
| "FDA_FEEDBACK_3": ( 0, 4, "PLLCONFIG_3"), | |
| "FDA_RELATIVE_0": ( 0, 4, "PLLCONFIG_5"), | |
| "FDA_RELATIVE_1": ( 0, 4, "PLLCONFIG_6"), | |
| "FDA_RELATIVE_2": ( 0, 4, "PLLCONFIG_7"), | |
| "FDA_RELATIVE_3": ( 0, 4, "PLLCONFIG_8"), | |
| "DIVR_0": ( 0, 1, "PLLCONFIG_1"), | |
| "DIVR_1": ( 0, 1, "PLLCONFIG_2"), | |
| "DIVR_2": ( 0, 1, "PLLCONFIG_3"), | |
| "DIVR_3": ( 0, 1, "PLLCONFIG_4"), | |
| "DIVF_0": ( 0, 1, "PLLCONFIG_5"), | |
| "DIVF_1": ( 0, 1, "PLLCONFIG_6"), | |
| "DIVF_2": ( 0, 1, "PLLCONFIG_7"), | |
| "DIVF_3": ( 0, 1, "PLLCONFIG_8"), | |
| "DIVF_4": ( 0, 1, "PLLCONFIG_9"), | |
| "DIVF_5": ( 0, 2, "PLLCONFIG_1"), | |
| "DIVF_6": ( 0, 2, "PLLCONFIG_2"), | |
| "DIVQ_0": ( 0, 2, "PLLCONFIG_3"), | |
| "DIVQ_1": ( 0, 2, "PLLCONFIG_4"), | |
| "DIVQ_2": ( 0, 2, "PLLCONFIG_5"), | |
| "FILTER_RANGE_0": ( 0, 2, "PLLCONFIG_6"), | |
| "FILTER_RANGE_1": ( 0, 2, "PLLCONFIG_7"), | |
| "FILTER_RANGE_2": ( 0, 2, "PLLCONFIG_8"), | |
| "TEST_MODE": ( 0, 3, "PLLCONFIG_8"), | |
| # PLL Ports | |
| "PLLOUT_A": ( 6, 0, 1), | |
| "PLLOUT_B": ( 7, 0, 0), | |
| "REFERENCECLK": ( 0, 1, "fabout"), | |
| "EXTFEEDBACK": ( 0, 2, "fabout"), | |
| "DYNAMICDELAY_0": ( 0, 4, "fabout"), | |
| "DYNAMICDELAY_1": ( 0, 5, "fabout"), | |
| "DYNAMICDELAY_2": ( 0, 6, "fabout"), | |
| "DYNAMICDELAY_3": ( 0, 10, "fabout"), | |
| "DYNAMICDELAY_4": ( 0, 11, "fabout"), | |
| "DYNAMICDELAY_5": ( 0, 12, "fabout"), | |
| "DYNAMICDELAY_6": ( 0, 13, "fabout"), | |
| "DYNAMICDELAY_7": ( 0, 14, "fabout"), | |
| "LOCK": ( 1, 1, "neigh_op_bnl_1"), | |
| "BYPASS": ( 1, 0, "fabout"), | |
| "RESETB": ( 2, 0, "fabout"), | |
| "LATCHINPUTVALUE": ( 5, 0, "fabout"), | |
| "SDO": (12, 1, "neigh_op_bnr_3"), | |
| "SDI": ( 4, 0, "fabout"), | |
| "SCLK": ( 3, 0, "fabout"), | |
| }, | |
| "lm4k": { | |
| "LOC" : (12, 0), | |
| # 3'b000 = "DISABLED" | |
| # 3'b010 = "SB_PLL40_PAD" | |
| # 3'b100 = "SB_PLL40_2_PAD" | |
| # 3'b110 = "SB_PLL40_2F_PAD" | |
| # 3'b011 = "SB_PLL40_CORE" | |
| # 3'b111 = "SB_PLL40_2F_CORE" | |
| "PLLTYPE_0": (12, 0, "PLLCONFIG_5"), | |
| "PLLTYPE_1": (14, 0, "PLLCONFIG_1"), | |
| "PLLTYPE_2": (14, 0, "PLLCONFIG_3"), | |
| # 3'b000 = "DELAY" | |
| # 3'b001 = "SIMPLE" | |
| # 3'b010 = "PHASE_AND_DELAY" | |
| # 3'b110 = "EXTERNAL" | |
| "FEEDBACK_PATH_0": (14, 0, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_1": (11, 0, "PLLCONFIG_9"), | |
| "FEEDBACK_PATH_2": (12, 0, "PLLCONFIG_1"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_FEEDBACK=4'b1111) | |
| "DELAY_ADJMODE_FB": (13, 0, "PLLCONFIG_4"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_RELATIVE=4'b1111) | |
| "DELAY_ADJMODE_REL": (13, 0, "PLLCONFIG_9"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_A_0": (12, 0, "PLLCONFIG_6"), | |
| "PLLOUT_SELECT_A_1": (12, 0, "PLLCONFIG_7"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_B_0": (12, 0, "PLLCONFIG_2"), | |
| "PLLOUT_SELECT_B_1": (12, 0, "PLLCONFIG_3"), | |
| # Numeric Parameters | |
| "SHIFTREG_DIV_MODE": (12, 0, "PLLCONFIG_4"), | |
| "FDA_FEEDBACK_0": (12, 0, "PLLCONFIG_9"), | |
| "FDA_FEEDBACK_1": (13, 0, "PLLCONFIG_1"), | |
| "FDA_FEEDBACK_2": (13, 0, "PLLCONFIG_2"), | |
| "FDA_FEEDBACK_3": (13, 0, "PLLCONFIG_3"), | |
| "FDA_RELATIVE_0": (13, 0, "PLLCONFIG_5"), | |
| "FDA_RELATIVE_1": (13, 0, "PLLCONFIG_6"), | |
| "FDA_RELATIVE_2": (13, 0, "PLLCONFIG_7"), | |
| "FDA_RELATIVE_3": (13, 0, "PLLCONFIG_8"), | |
| "DIVR_0": (10, 0, "PLLCONFIG_1"), | |
| "DIVR_1": (10, 0, "PLLCONFIG_2"), | |
| "DIVR_2": (10, 0, "PLLCONFIG_3"), | |
| "DIVR_3": (10, 0, "PLLCONFIG_4"), | |
| "DIVF_0": (10, 0, "PLLCONFIG_5"), | |
| "DIVF_1": (10, 0, "PLLCONFIG_6"), | |
| "DIVF_2": (10, 0, "PLLCONFIG_7"), | |
| "DIVF_3": (10, 0, "PLLCONFIG_8"), | |
| "DIVF_4": (10, 0, "PLLCONFIG_9"), | |
| "DIVF_5": (11, 0, "PLLCONFIG_1"), | |
| "DIVF_6": (11, 0, "PLLCONFIG_2"), | |
| "DIVQ_0": (11, 0, "PLLCONFIG_3"), | |
| "DIVQ_1": (11, 0, "PLLCONFIG_4"), | |
| "DIVQ_2": (11, 0, "PLLCONFIG_5"), | |
| "FILTER_RANGE_0": (11, 0, "PLLCONFIG_6"), | |
| "FILTER_RANGE_1": (11, 0, "PLLCONFIG_7"), | |
| "FILTER_RANGE_2": (11, 0, "PLLCONFIG_8"), | |
| "TEST_MODE": (12, 0, "PLLCONFIG_8"), | |
| # PLL Ports | |
| # TODO(awygle) confirm these | |
| "PLLOUT_A": ( 12, 0, 1), | |
| "PLLOUT_B": ( 13, 0, 0), | |
| "REFERENCECLK": ( 10, 0, "fabout"), | |
| "EXTFEEDBACK": ( 11, 0, "fabout"), | |
| "DYNAMICDELAY_0": ( 1, 0, "fabout"), | |
| "DYNAMICDELAY_1": ( 2, 0, "fabout"), | |
| "DYNAMICDELAY_2": ( 3, 0, "fabout"), | |
| "DYNAMICDELAY_3": ( 4, 0, "fabout"), | |
| "DYNAMICDELAY_4": ( 5, 0, "fabout"), | |
| "DYNAMICDELAY_5": ( 7, 0, "fabout"), | |
| "DYNAMICDELAY_6": ( 8, 0, "fabout"), | |
| "DYNAMICDELAY_7": ( 9, 0, "fabout"), | |
| "LOCK": ( 1, 1, "neigh_op_bnl_1"), #check? | |
| "BYPASS": ( 15, 0, "fabout"), | |
| "RESETB": ( 16, 0, "fabout"), | |
| "LATCHINPUTVALUE": ( 14, 0, "fabout"), | |
| "SDO": ( 24, 1, "neigh_op_bnr_3"), #check? | |
| "SDI": ( 18, 0, "fabout"), | |
| "SCLK": ( 17, 0, "fabout"), | |
| }, | |
| "5k": { | |
| "LOC" : (12, 31), | |
| # 3'b000 = "DISABLED" | |
| # 3'b010 = "SB_PLL40_PAD" | |
| # 3'b100 = "SB_PLL40_2_PAD" | |
| # 3'b110 = "SB_PLL40_2F_PAD" | |
| # 3'b011 = "SB_PLL40_CORE" | |
| # 3'b111 = "SB_PLL40_2F_CORE" | |
| "PLLTYPE_0": (12, 31, "PLLCONFIG_5"), | |
| "PLLTYPE_1": (14, 31, "PLLCONFIG_1"), | |
| "PLLTYPE_2": (14, 31, "PLLCONFIG_3"), | |
| # 3'b000 = "DELAY" | |
| # 3'b001 = "SIMPLE" | |
| # 3'b010 = "PHASE_AND_DELAY" | |
| # 3'b110 = "EXTERNAL" | |
| "FEEDBACK_PATH_0": (14, 31, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_1": (11, 31, "PLLCONFIG_9"), | |
| "FEEDBACK_PATH_2": (12, 31, "PLLCONFIG_1"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_FEEDBACK=4'b1111) | |
| "DELAY_ADJMODE_FB": (13, 31, "PLLCONFIG_4"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_RELATIVE=4'b1111) | |
| "DELAY_ADJMODE_REL": (13, 31, "PLLCONFIG_9"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_A_0": (12, 31, "PLLCONFIG_6"), | |
| "PLLOUT_SELECT_A_1": (12, 31, "PLLCONFIG_7"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_B_0": (12, 31, "PLLCONFIG_2"), | |
| "PLLOUT_SELECT_B_1": (12, 31, "PLLCONFIG_3"), | |
| # Numeric Parameters | |
| "SHIFTREG_DIV_MODE": (12, 31, "PLLCONFIG_4"), | |
| "FDA_FEEDBACK_0": (12, 31, "PLLCONFIG_9"), | |
| "FDA_FEEDBACK_1": (13, 31, "PLLCONFIG_1"), | |
| "FDA_FEEDBACK_2": (13, 31, "PLLCONFIG_2"), | |
| "FDA_FEEDBACK_3": (13, 31, "PLLCONFIG_3"), | |
| "FDA_RELATIVE_0": (13, 31, "PLLCONFIG_5"), | |
| "FDA_RELATIVE_1": (13, 31, "PLLCONFIG_6"), | |
| "FDA_RELATIVE_2": (13, 31, "PLLCONFIG_7"), | |
| "FDA_RELATIVE_3": (13, 31, "PLLCONFIG_8"), | |
| "DIVR_0": (10, 31, "PLLCONFIG_1"), | |
| "DIVR_1": (10, 31, "PLLCONFIG_2"), | |
| "DIVR_2": (10, 31, "PLLCONFIG_3"), | |
| "DIVR_3": (10, 31, "PLLCONFIG_4"), | |
| "DIVF_0": (10, 31, "PLLCONFIG_5"), | |
| "DIVF_1": (10, 31, "PLLCONFIG_6"), | |
| "DIVF_2": (10, 31, "PLLCONFIG_7"), | |
| "DIVF_3": (10, 31, "PLLCONFIG_8"), | |
| "DIVF_4": (10, 31, "PLLCONFIG_9"), | |
| "DIVF_5": (11, 31, "PLLCONFIG_1"), | |
| "DIVF_6": (11, 31, "PLLCONFIG_2"), | |
| "DIVQ_0": (11, 31, "PLLCONFIG_3"), | |
| "DIVQ_1": (11, 31, "PLLCONFIG_4"), | |
| "DIVQ_2": (11, 31, "PLLCONFIG_5"), | |
| "FILTER_RANGE_0": (11, 31, "PLLCONFIG_6"), | |
| "FILTER_RANGE_1": (11, 31, "PLLCONFIG_7"), | |
| "FILTER_RANGE_2": (11, 31, "PLLCONFIG_8"), | |
| "TEST_MODE": (12, 31, "PLLCONFIG_8"), | |
| # PLL Ports | |
| "PLLOUT_A": ( 12, 31, 1), | |
| "PLLOUT_B": ( 13, 31, 0), | |
| "REFERENCECLK": ( 10, 31, "fabout"), | |
| "EXTFEEDBACK": ( 11, 31, "fabout"), | |
| "DYNAMICDELAY_0": ( 1, 31, "fabout"), | |
| "DYNAMICDELAY_1": ( 2, 31, "fabout"), | |
| "DYNAMICDELAY_2": ( 3, 31, "fabout"), | |
| "DYNAMICDELAY_3": ( 4, 31, "fabout"), | |
| "DYNAMICDELAY_4": ( 5, 31, "fabout"), | |
| "DYNAMICDELAY_5": ( 7, 31, "fabout"), | |
| "DYNAMICDELAY_6": ( 8, 31, "fabout"), | |
| "DYNAMICDELAY_7": ( 9, 31, "fabout"), | |
| "LOCK": ( 1, 30, "neigh_op_tnl_1"), #check? | |
| "BYPASS": ( 15, 31, "fabout"), | |
| "RESETB": ( 16, 31, "fabout"), | |
| "LATCHINPUTVALUE": ( 14, 31, "fabout"), | |
| "SDO": ( 24, 30, "neigh_op_tnr_1"), #check? | |
| "SDI": ( 18, 31, "fabout"), | |
| "SCLK": ( 17, 31, "fabout"), | |
| }, | |
| "u4k": { | |
| "LOC" : (12, 21), | |
| "PLLTYPE_1": (14, 21, "PLLCONFIG_1"), | |
| "PLLTYPE_2": (14, 21, "PLLCONFIG_3"), | |
| "PLLTYPE_0": (12, 21, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_0": (14, 21, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_1": (11, 21, "PLLCONFIG_9"), | |
| "FEEDBACK_PATH_2": (12, 21, "PLLCONFIG_1"), | |
| "PLLOUT_SELECT_A_0": (12, 21, "PLLCONFIG_6"), | |
| "PLLOUT_SELECT_A_1": (12, 21, "PLLCONFIG_7"), | |
| "PLLOUT_SELECT_B_0": (12, 21, "PLLCONFIG_2"), | |
| "PLLOUT_SELECT_B_1": (12, 21, "PLLCONFIG_3"), | |
| "SHIFTREG_DIV_MODE": (12, 21, "PLLCONFIG_4"), | |
| "FDA_FEEDBACK_0": (12, 21, "PLLCONFIG_9"), | |
| "FDA_FEEDBACK_1": (13, 21, "PLLCONFIG_1"), | |
| "FDA_FEEDBACK_2": (13, 21, "PLLCONFIG_2"), | |
| "FDA_FEEDBACK_3": (13, 21, "PLLCONFIG_3"), | |
| "FDA_RELATIVE_0": (13, 21, "PLLCONFIG_5"), | |
| "FDA_RELATIVE_1": (13, 21, "PLLCONFIG_6"), | |
| "FDA_RELATIVE_2": (13, 21, "PLLCONFIG_7"), | |
| "FDA_RELATIVE_3": (13, 21, "PLLCONFIG_8"), | |
| "DIVR_0": (10, 21, "PLLCONFIG_1"), | |
| "DIVR_1": (10, 21, "PLLCONFIG_2"), | |
| "DIVR_2": (10, 21, "PLLCONFIG_3"), | |
| "DIVR_3": (10, 21, "PLLCONFIG_4"), | |
| "DIVF_0": (10, 21, "PLLCONFIG_5"), | |
| "DIVF_1": (10, 21, "PLLCONFIG_6"), | |
| "DIVF_2": (10, 21, "PLLCONFIG_7"), | |
| "DIVF_3": (10, 21, "PLLCONFIG_8"), | |
| "DIVF_4": (10, 21, "PLLCONFIG_9"), | |
| "DIVF_5": (11, 21, "PLLCONFIG_1"), | |
| "DIVF_6": (11, 21, "PLLCONFIG_2"), | |
| "DIVQ_0": (11, 21, "PLLCONFIG_3"), | |
| "DIVQ_1": (11, 21, "PLLCONFIG_4"), | |
| "DIVQ_2": (11, 21, "PLLCONFIG_5"), | |
| "FILTER_RANGE_0": (11, 21, "PLLCONFIG_6"), | |
| "FILTER_RANGE_1": (11, 21, "PLLCONFIG_7"), | |
| "FILTER_RANGE_2": (11, 21, "PLLCONFIG_8"), | |
| "TEST_MODE": (12, 21, "PLLCONFIG_8"), | |
| "DELAY_ADJMODE_FB": (13, 21, "PLLCONFIG_4"), | |
| "DELAY_ADJMODE_REL": (13, 21, "PLLCONFIG_9"), | |
| # PLL Ports | |
| "PLLOUT_A": ( 12, 21, 1), | |
| "PLLOUT_B": ( 13, 21, 0), | |
| "REFERENCECLK": ( 10, 21, "fabout"), | |
| "EXTFEEDBACK": ( 11, 21, "fabout"), | |
| "DYNAMICDELAY_0": ( 1, 21, "fabout"), | |
| "DYNAMICDELAY_1": ( 2, 21, "fabout"), | |
| "DYNAMICDELAY_2": ( 3, 21, "fabout"), | |
| "DYNAMICDELAY_3": ( 4, 21, "fabout"), | |
| "DYNAMICDELAY_4": ( 5, 21, "fabout"), | |
| "DYNAMICDELAY_5": ( 7, 21, "fabout"), | |
| "DYNAMICDELAY_6": ( 8, 21, "fabout"), | |
| "DYNAMICDELAY_7": ( 9, 21, "fabout"), | |
| "LOCK": ( 1, 20, "neigh_op_tnl_1"), #check? | |
| "BYPASS": ( 15, 21, "fabout"), | |
| "RESETB": ( 16, 21, "fabout"), | |
| "LATCHINPUTVALUE": ( 14, 21, "fabout"), | |
| "SDO": ( 24, 20, "neigh_op_tnr_1"), #check? | |
| "SDI": ( 18, 21, "fabout"), | |
| "SCLK": ( 17, 21, "fabout"), | |
| }, | |
| "8k_0": { | |
| "LOC" : (16, 0), | |
| # 3'b000 = "DISABLED" | |
| # 3'b010 = "SB_PLL40_PAD" | |
| # 3'b100 = "SB_PLL40_2_PAD" | |
| # 3'b110 = "SB_PLL40_2F_PAD" | |
| # 3'b011 = "SB_PLL40_CORE" | |
| # 3'b111 = "SB_PLL40_2F_CORE" | |
| "PLLTYPE_0": ( 16, 0, "PLLCONFIG_5"), | |
| "PLLTYPE_1": ( 18, 0, "PLLCONFIG_1"), | |
| "PLLTYPE_2": ( 18, 0, "PLLCONFIG_3"), | |
| # 3'b000 = "DELAY" | |
| # 3'b001 = "SIMPLE" | |
| # 3'b010 = "PHASE_AND_DELAY" | |
| # 3'b110 = "EXTERNAL" | |
| "FEEDBACK_PATH_0": ( 18, 0, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_1": ( 15, 0, "PLLCONFIG_9"), | |
| "FEEDBACK_PATH_2": ( 16, 0, "PLLCONFIG_1"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_FEEDBACK=4'b1111) | |
| "DELAY_ADJMODE_FB": ( 17, 0, "PLLCONFIG_4"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_RELATIVE=4'b1111) | |
| "DELAY_ADJMODE_REL": ( 17, 0, "PLLCONFIG_9"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_A_0": ( 16, 0, "PLLCONFIG_6"), | |
| "PLLOUT_SELECT_A_1": ( 16, 0, "PLLCONFIG_7"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_B_0": ( 16, 0, "PLLCONFIG_2"), | |
| "PLLOUT_SELECT_B_1": ( 16, 0, "PLLCONFIG_3"), | |
| # Numeric Parameters | |
| "SHIFTREG_DIV_MODE": ( 16, 0, "PLLCONFIG_4"), | |
| "FDA_FEEDBACK_0": ( 16, 0, "PLLCONFIG_9"), | |
| "FDA_FEEDBACK_1": ( 17, 0, "PLLCONFIG_1"), | |
| "FDA_FEEDBACK_2": ( 17, 0, "PLLCONFIG_2"), | |
| "FDA_FEEDBACK_3": ( 17, 0, "PLLCONFIG_3"), | |
| "FDA_RELATIVE_0": ( 17, 0, "PLLCONFIG_5"), | |
| "FDA_RELATIVE_1": ( 17, 0, "PLLCONFIG_6"), | |
| "FDA_RELATIVE_2": ( 17, 0, "PLLCONFIG_7"), | |
| "FDA_RELATIVE_3": ( 17, 0, "PLLCONFIG_8"), | |
| "DIVR_0": ( 14, 0, "PLLCONFIG_1"), | |
| "DIVR_1": ( 14, 0, "PLLCONFIG_2"), | |
| "DIVR_2": ( 14, 0, "PLLCONFIG_3"), | |
| "DIVR_3": ( 14, 0, "PLLCONFIG_4"), | |
| "DIVF_0": ( 14, 0, "PLLCONFIG_5"), | |
| "DIVF_1": ( 14, 0, "PLLCONFIG_6"), | |
| "DIVF_2": ( 14, 0, "PLLCONFIG_7"), | |
| "DIVF_3": ( 14, 0, "PLLCONFIG_8"), | |
| "DIVF_4": ( 14, 0, "PLLCONFIG_9"), | |
| "DIVF_5": ( 15, 0, "PLLCONFIG_1"), | |
| "DIVF_6": ( 15, 0, "PLLCONFIG_2"), | |
| "DIVQ_0": ( 15, 0, "PLLCONFIG_3"), | |
| "DIVQ_1": ( 15, 0, "PLLCONFIG_4"), | |
| "DIVQ_2": ( 15, 0, "PLLCONFIG_5"), | |
| "FILTER_RANGE_0": ( 15, 0, "PLLCONFIG_6"), | |
| "FILTER_RANGE_1": ( 15, 0, "PLLCONFIG_7"), | |
| "FILTER_RANGE_2": ( 15, 0, "PLLCONFIG_8"), | |
| "TEST_MODE": ( 16, 0, "PLLCONFIG_8"), | |
| # PLL Ports | |
| "PLLOUT_A": ( 16, 0, 1), | |
| "PLLOUT_B": ( 17, 0, 0), | |
| "REFERENCECLK": ( 13, 0, "fabout"), | |
| "EXTFEEDBACK": ( 14, 0, "fabout"), | |
| "DYNAMICDELAY_0": ( 5, 0, "fabout"), | |
| "DYNAMICDELAY_1": ( 6, 0, "fabout"), | |
| "DYNAMICDELAY_2": ( 7, 0, "fabout"), | |
| "DYNAMICDELAY_3": ( 8, 0, "fabout"), | |
| "DYNAMICDELAY_4": ( 9, 0, "fabout"), | |
| "DYNAMICDELAY_5": ( 10, 0, "fabout"), | |
| "DYNAMICDELAY_6": ( 11, 0, "fabout"), | |
| "DYNAMICDELAY_7": ( 12, 0, "fabout"), | |
| "LOCK": ( 1, 1, "neigh_op_bnl_1"), | |
| "BYPASS": ( 19, 0, "fabout"), | |
| "RESETB": ( 20, 0, "fabout"), | |
| "LATCHINPUTVALUE": ( 15, 0, "fabout"), | |
| "SDO": ( 32, 1, "neigh_op_bnr_3"), | |
| "SDI": ( 22, 0, "fabout"), | |
| "SCLK": ( 21, 0, "fabout"), | |
| }, | |
| "8k_1": { | |
| "LOC" : (16, 33), | |
| # 3'b000 = "DISABLED" | |
| # 3'b010 = "SB_PLL40_PAD" | |
| # 3'b100 = "SB_PLL40_2_PAD" | |
| # 3'b110 = "SB_PLL40_2F_PAD" | |
| # 3'b011 = "SB_PLL40_CORE" | |
| # 3'b111 = "SB_PLL40_2F_CORE" | |
| "PLLTYPE_0": ( 16, 33, "PLLCONFIG_5"), | |
| "PLLTYPE_1": ( 18, 33, "PLLCONFIG_1"), | |
| "PLLTYPE_2": ( 18, 33, "PLLCONFIG_3"), | |
| # 3'b000 = "DELAY" | |
| # 3'b001 = "SIMPLE" | |
| # 3'b010 = "PHASE_AND_DELAY" | |
| # 3'b110 = "EXTERNAL" | |
| "FEEDBACK_PATH_0": ( 18, 33, "PLLCONFIG_5"), | |
| "FEEDBACK_PATH_1": ( 15, 33, "PLLCONFIG_9"), | |
| "FEEDBACK_PATH_2": ( 16, 33, "PLLCONFIG_1"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_FEEDBACK=4'b1111) | |
| "DELAY_ADJMODE_FB": ( 17, 33, "PLLCONFIG_4"), | |
| # 1'b0 = "FIXED" | |
| # 1'b1 = "DYNAMIC" (also set FDA_RELATIVE=4'b1111) | |
| "DELAY_ADJMODE_REL": ( 17, 33, "PLLCONFIG_9"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_A_0": ( 16, 33, "PLLCONFIG_6"), | |
| "PLLOUT_SELECT_A_1": ( 16, 33, "PLLCONFIG_7"), | |
| # 2'b00 = "GENCLK" | |
| # 2'b01 = "GENCLK_HALF" | |
| # 2'b10 = "SHIFTREG_90deg" | |
| # 2'b11 = "SHIFTREG_0deg" | |
| "PLLOUT_SELECT_B_0": ( 16, 33, "PLLCONFIG_2"), | |
| "PLLOUT_SELECT_B_1": ( 16, 33, "PLLCONFIG_3"), | |
| # Numeric Parameters | |
| "SHIFTREG_DIV_MODE": ( 16, 33, "PLLCONFIG_4"), | |
| "FDA_FEEDBACK_0": ( 16, 33, "PLLCONFIG_9"), | |
| "FDA_FEEDBACK_1": ( 17, 33, "PLLCONFIG_1"), | |
| "FDA_FEEDBACK_2": ( 17, 33, "PLLCONFIG_2"), | |
| "FDA_FEEDBACK_3": ( 17, 33, "PLLCONFIG_3"), | |
| "FDA_RELATIVE_0": ( 17, 33, "PLLCONFIG_5"), | |
| "FDA_RELATIVE_1": ( 17, 33, "PLLCONFIG_6"), | |
| "FDA_RELATIVE_2": ( 17, 33, "PLLCONFIG_7"), | |
| "FDA_RELATIVE_3": ( 17, 33, "PLLCONFIG_8"), | |
| "DIVR_0": ( 14, 33, "PLLCONFIG_1"), | |
| "DIVR_1": ( 14, 33, "PLLCONFIG_2"), | |
| "DIVR_2": ( 14, 33, "PLLCONFIG_3"), | |
| "DIVR_3": ( 14, 33, "PLLCONFIG_4"), | |
| "DIVF_0": ( 14, 33, "PLLCONFIG_5"), | |
| "DIVF_1": ( 14, 33, "PLLCONFIG_6"), | |
| "DIVF_2": ( 14, 33, "PLLCONFIG_7"), | |
| "DIVF_3": ( 14, 33, "PLLCONFIG_8"), | |
| "DIVF_4": ( 14, 33, "PLLCONFIG_9"), | |
| "DIVF_5": ( 15, 33, "PLLCONFIG_1"), | |
| "DIVF_6": ( 15, 33, "PLLCONFIG_2"), | |
| "DIVQ_0": ( 15, 33, "PLLCONFIG_3"), | |
| "DIVQ_1": ( 15, 33, "PLLCONFIG_4"), | |
| "DIVQ_2": ( 15, 33, "PLLCONFIG_5"), | |
| "FILTER_RANGE_0": ( 15, 33, "PLLCONFIG_6"), | |
| "FILTER_RANGE_1": ( 15, 33, "PLLCONFIG_7"), | |
| "FILTER_RANGE_2": ( 15, 33, "PLLCONFIG_8"), | |
| "TEST_MODE": ( 16, 33, "PLLCONFIG_8"), | |
| # PLL Ports | |
| "PLLOUT_A": ( 16, 33, 1), | |
| "PLLOUT_B": ( 17, 33, 0), | |
| "REFERENCECLK": ( 13, 33, "fabout"), | |
| "EXTFEEDBACK": ( 14, 33, "fabout"), | |
| "DYNAMICDELAY_0": ( 5, 33, "fabout"), | |
| "DYNAMICDELAY_1": ( 6, 33, "fabout"), | |
| "DYNAMICDELAY_2": ( 7, 33, "fabout"), | |
| "DYNAMICDELAY_3": ( 8, 33, "fabout"), | |
| "DYNAMICDELAY_4": ( 9, 33, "fabout"), | |
| "DYNAMICDELAY_5": ( 10, 33, "fabout"), | |
| "DYNAMICDELAY_6": ( 11, 33, "fabout"), | |
| "DYNAMICDELAY_7": ( 12, 33, "fabout"), | |
| "LOCK": ( 1, 32, "neigh_op_tnl_1"), | |
| "BYPASS": ( 19, 33, "fabout"), | |
| "RESETB": ( 20, 33, "fabout"), | |
| "LATCHINPUTVALUE": ( 15, 33, "fabout"), | |
| "SDO": ( 32, 32, "neigh_op_tnr_1"), | |
| "SDI": ( 22, 33, "fabout"), | |
| "SCLK": ( 21, 33, "fabout"), | |
| }, | |
| } | |
| padin_pio_db = { | |
| "1k": [ | |
| (13, 8, 1), # glb_netwk_0 | |
| ( 0, 8, 1), # glb_netwk_1 | |
| ( 7, 17, 0), # glb_netwk_2 | |
| ( 7, 0, 0), # glb_netwk_3 | |
| ( 0, 9, 0), # glb_netwk_4 | |
| (13, 9, 0), # glb_netwk_5 | |
| ( 6, 0, 1), # glb_netwk_6 | |
| ( 6, 17, 1), # glb_netwk_7 | |
| ], | |
| "lm4k": [ | |
| (19, 0, 0), #0 fixed | |
| ( 6, 0, 1), #1 fixed | |
| (13, 21, 0), #2 fixed | |
| (13, 0, 0), #3 fixed | |
| (19, 21, 0), #These two are questionable, but keep the order correct | |
| ( 6, 21, 0), #They may need to be fixed if other package options are added. | |
| (12, 0, 1), #6 fixed | |
| (12, 21, 1), #7 fixed | |
| ], | |
| "5k": [ | |
| (19, 0, 1), #0 fixed | |
| ( 6, 0, 1), #1 fixed | |
| (13, 31, 0), #2 fixed | |
| (13, 0, 0), #3 fixed | |
| (19, 31, 0), #These two are questionable, but keep the order correct | |
| ( 6, 31, 0), #They may need to be fixed if other package options are added. | |
| (12, 0, 1), #6 fixed | |
| (12, 31, 1), #7 fixed | |
| ], | |
| "u4k": [ | |
| (19, 0, 1), # 0 ok | |
| ( 6, 0, 1), # 1 ok | |
| (13, 21, 0), # 2 ok | |
| (13, 0, 0), # 3 unclear | |
| (19, 21, 0), # 4 HFOSC unclear | |
| ( 6, 21, 0), # 5 LFOSC unclear | |
| (12, 0, 1), # 6 unclear | |
| (12, 21, 1), # 7 ok | |
| ], | |
| "8k": [ | |
| (33, 16, 1), | |
| ( 0, 16, 1), | |
| (17, 33, 0), | |
| (17, 0, 0), | |
| ( 0, 17, 0), | |
| (33, 17, 0), | |
| (16, 0, 1), | |
| (16, 33, 1), | |
| ], | |
| "384": [ | |
| ( 7, 4, 1), | |
| ( 0, 4, 1), | |
| ( 4, 9, 0), | |
| ( 4, 0, 0), #QFN32: no pin?! | |
| ( 0, 5, 0), | |
| ( 7, 5, 0), | |
| ( 3, 0, 1), #QFN32: no pin?! | |
| ( 3, 9, 1), | |
| ] | |
| } | |
| ieren_db = { | |
| "1k": [ | |
| # IO-block (X, Y, Z) <-> IeRen-block (X, Y, Z) | |
| ( 0, 2, 0, 0, 2, 1), | |
| ( 0, 2, 1, 0, 2, 0), | |
| ( 0, 3, 0, 0, 3, 1), | |
| ( 0, 3, 1, 0, 3, 0), | |
| ( 0, 4, 0, 0, 4, 1), | |
| ( 0, 4, 1, 0, 4, 0), | |
| ( 0, 5, 0, 0, 5, 1), | |
| ( 0, 5, 1, 0, 5, 0), | |
| ( 0, 6, 0, 0, 6, 1), | |
| ( 0, 6, 1, 0, 6, 0), | |
| ( 0, 8, 0, 0, 8, 1), | |
| ( 0, 8, 1, 0, 8, 0), | |
| ( 0, 9, 0, 0, 9, 1), | |
| ( 0, 9, 1, 0, 9, 0), | |
| ( 0, 10, 0, 0, 10, 1), | |
| ( 0, 10, 1, 0, 10, 0), | |
| ( 0, 11, 0, 0, 11, 1), | |
| ( 0, 11, 1, 0, 11, 0), | |
| ( 0, 12, 0, 0, 12, 1), | |
| ( 0, 12, 1, 0, 12, 0), | |
| ( 0, 13, 0, 0, 13, 1), | |
| ( 0, 13, 1, 0, 13, 0), | |
| ( 0, 14, 0, 0, 14, 1), | |
| ( 0, 14, 1, 0, 14, 0), | |
| ( 1, 0, 0, 1, 0, 0), | |
| ( 1, 0, 1, 1, 0, 1), | |
| ( 1, 17, 0, 1, 17, 0), | |
| ( 1, 17, 1, 1, 17, 1), | |
| ( 2, 0, 0, 2, 0, 0), | |
| ( 2, 0, 1, 2, 0, 1), | |
| ( 2, 17, 0, 2, 17, 0), | |
| ( 2, 17, 1, 2, 17, 1), | |
| ( 3, 0, 0, 3, 0, 0), | |
| ( 3, 0, 1, 3, 0, 1), | |
| ( 3, 17, 0, 3, 17, 0), | |
| ( 3, 17, 1, 3, 17, 1), | |
| ( 4, 0, 0, 4, 0, 0), | |
| ( 4, 0, 1, 4, 0, 1), | |
| ( 4, 17, 0, 4, 17, 0), | |
| ( 4, 17, 1, 4, 17, 1), | |
| ( 5, 0, 0, 5, 0, 0), | |
| ( 5, 0, 1, 5, 0, 1), | |
| ( 5, 17, 0, 5, 17, 0), | |
| ( 5, 17, 1, 5, 17, 1), | |
| ( 6, 0, 0, 7, 0, 0), | |
| ( 6, 0, 1, 6, 0, 0), | |
| ( 6, 17, 0, 6, 17, 0), | |
| ( 6, 17, 1, 6, 17, 1), | |
| ( 7, 0, 0, 6, 0, 1), | |
| ( 7, 0, 1, 7, 0, 1), | |
| ( 7, 17, 0, 7, 17, 0), | |
| ( 7, 17, 1, 7, 17, 1), | |
| ( 8, 0, 0, 8, 0, 0), | |
| ( 8, 0, 1, 8, 0, 1), | |
| ( 8, 17, 0, 8, 17, 0), | |
| ( 8, 17, 1, 8, 17, 1), | |
| ( 9, 0, 0, 9, 0, 0), | |
| ( 9, 0, 1, 9, 0, 1), | |
| ( 9, 17, 0, 10, 17, 0), | |
| ( 9, 17, 1, 10, 17, 1), | |
| (10, 0, 0, 10, 0, 0), | |
| (10, 0, 1, 10, 0, 1), | |
| (10, 17, 0, 9, 17, 0), | |
| (10, 17, 1, 9, 17, 1), | |
| (11, 0, 0, 11, 0, 0), | |
| (11, 0, 1, 11, 0, 1), | |
| (11, 17, 0, 11, 17, 0), | |
| (11, 17, 1, 11, 17, 1), | |
| (12, 0, 0, 12, 0, 0), | |
| (12, 0, 1, 12, 0, 1), | |
| (12, 17, 0, 12, 17, 0), | |
| (12, 17, 1, 12, 17, 1), | |
| (13, 1, 0, 13, 1, 0), | |
| (13, 1, 1, 13, 1, 1), | |
| (13, 2, 0, 13, 2, 0), | |
| (13, 2, 1, 13, 2, 1), | |
| (13, 3, 1, 13, 3, 1), | |
| (13, 4, 0, 13, 4, 0), | |
| (13, 4, 1, 13, 4, 1), | |
| (13, 6, 0, 13, 6, 0), | |
| (13, 6, 1, 13, 6, 1), | |
| (13, 7, 0, 13, 7, 0), | |
| (13, 7, 1, 13, 7, 1), | |
| (13, 8, 0, 13, 8, 0), | |
| (13, 8, 1, 13, 8, 1), | |
| (13, 9, 0, 13, 9, 0), | |
| (13, 9, 1, 13, 9, 1), | |
| (13, 11, 0, 13, 10, 0), | |
| (13, 11, 1, 13, 10, 1), | |
| (13, 12, 0, 13, 11, 0), | |
| (13, 12, 1, 13, 11, 1), | |
| (13, 13, 0, 13, 13, 0), | |
| (13, 13, 1, 13, 13, 1), | |
| (13, 14, 0, 13, 14, 0), | |
| (13, 14, 1, 13, 14, 1), | |
| (13, 15, 0, 13, 15, 0), | |
| (13, 15, 1, 13, 15, 1), | |
| ], | |
| "8k": [ | |
| ( 0, 3, 0, 0, 3, 0), | |
| ( 0, 3, 1, 0, 3, 1), | |
| ( 0, 4, 0, 0, 4, 0), | |
| ( 0, 4, 1, 0, 4, 1), | |
| ( 0, 5, 0, 0, 5, 0), | |
| ( 0, 5, 1, 0, 5, 1), | |
| ( 0, 6, 0, 0, 6, 0), | |
| ( 0, 6, 1, 0, 6, 1), | |
| ( 0, 7, 0, 0, 7, 0), | |
| ( 0, 7, 1, 0, 7, 1), | |
| ( 0, 8, 0, 0, 8, 0), | |
| ( 0, 8, 1, 0, 8, 1), | |
| ( 0, 9, 0, 0, 9, 0), | |
| ( 0, 9, 1, 0, 9, 1), | |
| ( 0, 10, 0, 0, 10, 0), | |
| ( 0, 10, 1, 0, 10, 1), | |
| ( 0, 11, 0, 0, 11, 0), | |
| ( 0, 11, 1, 0, 11, 1), | |
| ( 0, 12, 0, 0, 12, 0), | |
| ( 0, 12, 1, 0, 12, 1), | |
| ( 0, 13, 0, 0, 13, 0), | |
| ( 0, 13, 1, 0, 13, 1), | |
| ( 0, 14, 0, 0, 14, 0), | |
| ( 0, 14, 1, 0, 14, 1), | |
| ( 0, 16, 0, 0, 16, 0), | |
| ( 0, 16, 1, 0, 16, 1), | |
| ( 0, 17, 0, 0, 17, 0), | |
| ( 0, 17, 1, 0, 17, 1), | |
| ( 0, 18, 0, 0, 18, 0), | |
| ( 0, 18, 1, 0, 18, 1), | |
| ( 0, 19, 0, 0, 19, 0), | |
| ( 0, 19, 1, 0, 19, 1), | |
| ( 0, 20, 0, 0, 20, 0), | |
| ( 0, 20, 1, 0, 20, 1), | |
| ( 0, 21, 0, 0, 21, 0), | |
| ( 0, 21, 1, 0, 21, 1), | |
| ( 0, 22, 0, 0, 22, 0), | |
| ( 0, 22, 1, 0, 22, 1), | |
| ( 0, 23, 0, 0, 23, 0), | |
| ( 0, 23, 1, 0, 23, 1), | |
| ( 0, 24, 0, 0, 24, 0), | |
| ( 0, 24, 1, 0, 24, 1), | |
| ( 0, 25, 0, 0, 25, 0), | |
| ( 0, 25, 1, 0, 25, 1), | |
| ( 0, 27, 0, 0, 27, 0), | |
| ( 0, 27, 1, 0, 27, 1), | |
| ( 0, 28, 0, 0, 28, 0), | |
| ( 0, 28, 1, 0, 28, 1), | |
| ( 0, 30, 0, 0, 30, 0), | |
| ( 0, 30, 1, 0, 30, 1), | |
| ( 0, 31, 0, 0, 31, 0), | |
| ( 0, 31, 1, 0, 31, 1), | |
| ( 1, 33, 0, 1, 33, 0), | |
| ( 1, 33, 1, 1, 33, 1), | |
| ( 2, 0, 0, 2, 0, 0), | |
| ( 2, 0, 1, 2, 0, 1), | |
| ( 2, 33, 0, 2, 33, 0), | |
| ( 2, 33, 1, 2, 33, 1), | |
| ( 3, 0, 0, 3, 0, 0), | |
| ( 3, 0, 1, 3, 0, 1), | |
| ( 3, 33, 0, 3, 33, 0), | |
| ( 3, 33, 1, 3, 33, 1), | |
| ( 4, 0, 0, 4, 0, 0), | |
| ( 4, 0, 1, 4, 0, 1), | |
| ( 4, 33, 0, 4, 33, 0), | |
| ( 4, 33, 1, 4, 33, 1), | |
| ( 5, 0, 0, 5, 0, 0), | |
| ( 5, 0, 1, 5, 0, 1), | |
| ( 5, 33, 0, 5, 33, 0), | |
| ( 5, 33, 1, 5, 33, 1), | |
| ( 6, 0, 0, 6, 0, 0), | |
| ( 6, 0, 1, 6, 0, 1), | |
| ( 6, 33, 0, 6, 33, 0), | |
| ( 6, 33, 1, 6, 33, 1), | |
| ( 7, 0, 0, 7, 0, 0), | |
| ( 7, 0, 1, 7, 0, 1), | |
| ( 7, 33, 0, 7, 33, 0), | |
| ( 7, 33, 1, 7, 33, 1), | |
| ( 8, 0, 0, 8, 0, 0), | |
| ( 8, 0, 1, 8, 0, 1), | |
| ( 8, 33, 0, 8, 33, 0), | |
| ( 8, 33, 1, 8, 33, 1), | |
| ( 9, 0, 0, 9, 0, 0), | |
| ( 9, 0, 1, 9, 0, 1), | |
| ( 9, 33, 0, 9, 33, 0), | |
| ( 9, 33, 1, 9, 33, 1), | |
| (10, 0, 0, 10, 0, 0), | |
| (10, 0, 1, 10, 0, 1), | |
| (10, 33, 0, 10, 33, 0), | |
| (10, 33, 1, 10, 33, 1), | |
| (11, 0, 0, 11, 0, 0), | |
| (11, 0, 1, 11, 0, 1), | |
| (11, 33, 0, 11, 33, 0), | |
| (11, 33, 1, 11, 33, 1), | |
| (12, 0, 0, 12, 0, 0), | |
| (12, 0, 1, 12, 0, 1), | |
| (12, 33, 0, 12, 33, 0), | |
| (13, 0, 0, 13, 0, 0), | |
| (13, 0, 1, 13, 0, 1), | |
| (13, 33, 0, 13, 33, 0), | |
| (13, 33, 1, 13, 33, 1), | |
| (14, 0, 0, 14, 0, 0), | |
| (14, 0, 1, 14, 0, 1), | |
| (14, 33, 0, 14, 33, 0), | |
| (14, 33, 1, 14, 33, 1), | |
| (15, 0, 0, 15, 0, 0), | |
| (15, 0, 1, 15, 0, 1), | |
| (16, 0, 0, 16, 0, 0), | |
| (16, 0, 1, 16, 0, 1), | |
| (16, 33, 0, 16, 33, 0), | |
| (16, 33, 1, 16, 33, 1), | |
| (17, 0, 0, 17, 0, 0), | |
| (17, 0, 1, 17, 0, 1), | |
| (17, 33, 0, 17, 33, 0), | |
| (17, 33, 1, 17, 33, 1), | |
| (18, 33, 0, 18, 33, 0), | |
| (18, 33, 1, 18, 33, 1), | |
| (19, 0, 0, 19, 0, 0), | |
| (19, 0, 1, 19, 0, 1), | |
| (19, 33, 0, 19, 33, 0), | |
| (19, 33, 1, 19, 33, 1), | |
| (20, 0, 0, 20, 0, 0), | |
| (20, 0, 1, 20, 0, 1), | |
| (20, 33, 0, 20, 33, 0), | |
| (20, 33, 1, 20, 33, 1), | |
| (21, 0, 0, 21, 0, 0), | |
| (21, 0, 1, 21, 0, 1), | |
| (21, 33, 0, 21, 33, 0), | |
| (21, 33, 1, 21, 33, 1), | |
| (22, 0, 0, 22, 0, 0), | |
| (22, 0, 1, 22, 0, 1), | |
| (22, 33, 0, 22, 33, 0), | |
| (22, 33, 1, 22, 33, 1), | |
| (23, 0, 0, 23, 0, 0), | |
| (23, 0, 1, 23, 0, 1), | |
| (23, 33, 0, 23, 33, 0), | |
| (23, 33, 1, 23, 33, 1), | |
| (24, 0, 0, 24, 0, 0), | |
| (24, 0, 1, 24, 0, 1), | |
| (24, 33, 0, 24, 33, 0), | |
| (24, 33, 1, 24, 33, 1), | |
| (25, 0, 0, 25, 0, 0), | |
| (25, 33, 0, 25, 33, 0), | |
| (25, 33, 1, 25, 33, 1), | |
| (26, 0, 0, 26, 0, 0), | |
| (26, 0, 1, 26, 0, 1), | |
| (26, 33, 0, 26, 33, 0), | |
| (26, 33, 1, 26, 33, 1), | |
| (27, 0, 0, 27, 0, 0), | |
| (27, 0, 1, 27, 0, 1), | |
| (27, 33, 0, 27, 33, 0), | |
| (27, 33, 1, 27, 33, 1), | |
| (28, 0, 0, 28, 0, 0), | |
| (28, 33, 1, 28, 33, 1), | |
| (29, 0, 0, 29, 0, 0), | |
| (29, 0, 1, 29, 0, 1), | |
| (29, 33, 0, 29, 33, 0), | |
| (29, 33, 1, 29, 33, 1), | |
| (30, 0, 0, 30, 0, 0), | |
| (30, 0, 1, 30, 0, 1), | |
| (30, 33, 0, 30, 33, 0), | |
| (30, 33, 1, 30, 33, 1), | |
| (31, 0, 0, 31, 0, 0), | |
| (31, 0, 1, 31, 0, 1), | |
| (31, 33, 0, 31, 33, 0), | |
| (31, 33, 1, 31, 33, 1), | |
| (33, 1, 0, 33, 1, 0), | |
| (33, 1, 1, 33, 1, 1), | |
| (33, 2, 0, 33, 2, 0), | |
| (33, 2, 1, 33, 2, 1), | |
| (33, 3, 0, 33, 3, 0), | |
| (33, 3, 1, 33, 3, 1), | |
| (33, 4, 0, 33, 4, 0), | |
| (33, 4, 1, 33, 4, 1), | |
| (33, 5, 0, 33, 5, 0), | |
| (33, 5, 1, 33, 5, 1), | |
| (33, 6, 0, 33, 6, 0), | |
| (33, 6, 1, 33, 6, 1), | |
| (33, 7, 0, 33, 7, 0), | |
| (33, 7, 1, 33, 7, 1), | |
| (33, 8, 0, 33, 8, 0), | |
| (33, 9, 0, 33, 9, 0), | |
| (33, 9, 1, 33, 9, 1), | |
| (33, 10, 0, 33, 10, 0), | |
| (33, 10, 1, 33, 10, 1), | |
| (33, 11, 0, 33, 11, 0), | |
| (33, 11, 1, 33, 11, 1), | |
| (33, 12, 0, 33, 12, 0), | |
| (33, 13, 0, 33, 13, 0), | |
| (33, 13, 1, 33, 13, 1), | |
| (33, 14, 0, 33, 14, 0), | |
| (33, 14, 1, 33, 14, 1), | |
| (33, 15, 0, 33, 15, 0), | |
| (33, 15, 1, 33, 15, 1), | |
| (33, 16, 0, 33, 16, 0), | |
| (33, 16, 1, 33, 16, 1), | |
| (33, 17, 0, 33, 17, 0), | |
| (33, 17, 1, 33, 17, 1), | |
| (33, 19, 0, 33, 19, 0), | |
| (33, 19, 1, 33, 19, 1), | |
| (33, 20, 0, 33, 20, 0), | |
| (33, 20, 1, 33, 20, 1), | |
| (33, 21, 0, 33, 21, 0), | |
| (33, 21, 1, 33, 21, 1), | |
| (33, 22, 0, 33, 22, 0), | |
| (33, 22, 1, 33, 22, 1), | |
| (33, 23, 0, 33, 23, 0), | |
| (33, 23, 1, 33, 23, 1), | |
| (33, 24, 0, 33, 24, 0), | |
| (33, 24, 1, 33, 24, 1), | |
| (33, 25, 0, 33, 25, 0), | |
| (33, 25, 1, 33, 25, 1), | |
| (33, 26, 0, 33, 26, 0), | |
| (33, 26, 1, 33, 26, 1), | |
| (33, 27, 0, 33, 27, 0), | |
| (33, 27, 1, 33, 27, 1), | |
| (33, 28, 0, 33, 28, 0), | |
| (33, 28, 1, 33, 28, 1), | |
| (33, 29, 1, 33, 29, 1), | |
| (33, 30, 0, 33, 30, 0), | |
| (33, 30, 1, 33, 30, 1), | |
| (33, 31, 0, 33, 31, 0), | |
| ], | |
| "384": [ | |
| ( 0, 1, 0, 0, 1, 1), | |
| ( 0, 1, 1, 0, 1, 0), | |
| ( 0, 2, 0, 0, 2, 1), | |
| ( 0, 2, 1, 0, 2, 0), | |
| ( 0, 4, 0, 0, 4, 1), | |
| ( 0, 4, 1, 0, 4, 0), | |
| ( 0, 5, 0, 0, 5, 1), | |
| ( 0, 5, 1, 0, 5, 0), | |
| ( 0, 6, 0, 0, 6, 1), | |
| ( 0, 6, 1, 0, 6, 0), | |
| ( 0, 7, 0, 0, 7, 1), | |
| ( 0, 7, 1, 0, 7, 0), | |
| ( 2, 9, 0, 2, 9, 1), | |
| ( 2, 9, 1, 2, 9, 0), | |
| ( 3, 0, 0, 3, 0, 1), | |
| ( 3, 0, 1, 3, 0, 0), | |
| ( 3, 9, 0, 3, 9, 1), | |
| ( 3, 9, 1, 3, 9, 0), | |
| ( 4, 0, 0, 4, 0, 1), | |
| ( 4, 0, 1, 4, 0, 0), | |
| ( 4, 9, 0, 4, 9, 1), | |
| ( 4, 9, 1, 4, 9, 0), | |
| ( 5, 0, 0, 5, 0, 1), | |
| ( 5, 0, 1, 5, 0, 0), | |
| ( 5, 9, 0, 5, 9, 1), | |
| ( 5, 9, 1, 5, 9, 0), | |
| ( 6, 0, 0, 6, 0, 1), | |
| ( 6, 0, 1, 6, 0, 0), | |
| ( 6, 9, 0, 6, 9, 1), | |
| ( 6, 9, 1, 6, 9, 0), | |
| ( 7, 3, 1, 7, 3, 0), | |
| ( 7, 4, 0, 7, 4, 1), | |
| ( 7, 4, 1, 7, 4, 0), | |
| ( 7, 5, 0, 7, 5, 1), | |
| ( 7, 5, 1, 7, 5, 0), | |
| ( 7, 6, 0, 7, 6, 1), | |
| ( 7, 6, 1, 7, 6, 0), | |
| ], | |
| "lm4k": [ | |
| ( 4, 21, 0, 4, 21, 1), | |
| ( 4, 21, 1, 4, 21, 0), | |
| ( 5, 21, 1, 5, 21, 0), | |
| ( 6, 0, 0, 6, 0, 1), | |
| ( 6, 0, 1, 6, 0, 0), | |
| ( 6, 21, 0, 6, 21, 1), | |
| ( 7, 0, 0, 7, 0, 1), | |
| ( 7, 0, 1, 7, 0, 0), | |
| ( 7, 21, 1, 7, 21, 0), | |
| ( 8, 0, 0, 8, 0, 1), | |
| ( 8, 0, 1, 8, 0, 0), | |
| ( 9, 21, 1, 9, 21, 0), | |
| ( 9, 21, 0, 9, 21, 1), | |
| (10, 0, 0, 10, 0, 1), | |
| (12, 0, 0, 12, 0, 1), | |
| (12, 0, 1, 12, 0, 0), | |
| (12, 21, 1, 12, 21, 0), | |
| (13, 0, 0, 13, 0, 1), | |
| (13, 0, 1, 13, 0, 0), | |
| (13, 21, 0, 13, 21, 1), | |
| (14, 0, 1, 14, 0, 0), | |
| (15, 21, 0, 15, 21, 1), | |
| (16, 21, 1, 16, 21, 0), | |
| (17, 21, 1, 17, 21, 0), | |
| (18, 21, 0, 18, 21, 1), | |
| (19, 0, 0, 19, 0, 1), | |
| (19, 0, 1, 19, 0, 0), | |
| (19, 21, 0, 19, 21, 1), | |
| (19, 21, 1, 19, 21, 0), | |
| (21, 0, 0, 21, 0, 1), | |
| (21, 0, 1, 21, 0, 0), | |
| (21, 21, 1, 21, 21, 0), | |
| (22, 0, 0, 22, 0, 1), | |
| (22, 0, 1, 22, 0, 0), | |
| (22, 21, 1, 22, 21, 0), | |
| (23, 0, 0, 23, 0, 1), | |
| (23, 0, 1, 23, 0, 0), | |
| (23, 21, 0, 23, 21, 1), | |
| (23, 21, 1, 23, 21, 0), | |
| (24, 0, 0, 24, 0, 1), | |
| (24, 0, 1, 24, 0, 0), | |
| ], | |
| "5k": [ | |
| ( 8, 0, 0, 8, 0, 1), | |
| ( 9, 0, 1, 9, 0, 0), | |
| ( 9, 0, 0, 9, 0, 1), | |
| (13, 0, 1, 13, 0, 0), | |
| (15, 0, 0, 15, 0, 1), | |
| (16, 0, 0, 16, 0, 1), | |
| (17, 0, 0, 17, 0, 1), | |
| (18, 0, 0, 18, 0, 1), | |
| (19, 0, 0, 19, 0, 1), | |
| (23, 0, 0, 23, 0, 1), | |
| (24, 0, 0, 24, 0, 1), | |
| (24, 0, 1, 24, 0, 0), | |
| (23, 0, 1, 23, 0, 0), | |
| (22, 0, 1, 22, 0, 0), | |
| (21, 0, 1, 21, 0, 0), | |
| (19, 0, 1, 19, 0, 0), | |
| (18, 0, 1, 18, 0, 0), | |
| (19, 31, 0, 19, 31, 1), | |
| (19, 31, 1, 19, 31, 0), | |
| (18, 31, 0, 18, 31, 1), | |
| (18, 31, 1, 18, 31, 0), | |
| (17, 31, 0, 17, 31, 1), | |
| (16, 31, 1, 16, 31, 0), | |
| (16, 31, 0, 16, 31, 1), | |
| (13, 31, 1, 13, 31, 0), | |
| (12, 31, 1, 12, 31, 0), | |
| ( 9, 31, 1, 9, 31, 0), | |
| (13, 31, 0, 13, 31, 1), | |
| ( 4, 31, 0, 4, 31, 1), | |
| ( 5, 31, 0, 5, 31, 1), | |
| ( 6, 31, 0, 6, 31, 1), | |
| ( 8, 31, 1, 8, 31, 0), | |
| ( 8, 31, 0, 8, 31, 1), | |
| ( 9, 31, 0, 9, 31, 1), | |
| ( 6, 0, 1, 6, 0, 0), | |
| ( 7, 0, 1, 7, 0, 0), | |
| ( 5, 0, 0, 5, 0, 1), | |
| ( 6, 0, 0, 6, 0, 1), | |
| ( 7, 0, 0, 7, 0, 1), | |
| (12, 31, 0, 12, 31, 1), | |
| (12, 0, 0, 12, 0, 1), | |
| (13, 0, 0, 13, 0, 1), | |
| (12, 0, 1, 12, 0, 0) | |
| ], | |
| "u4k": [ | |
| ( 4, 21, 0, 4, 21, 1), | |
| ( 5, 0, 0, 5, 0, 1), | |
| ( 5, 21, 0, 5, 21, 1), | |
| ( 6, 0, 0, 6, 0, 1), | |
| ( 6, 0, 1, 6, 0, 0), | |
| ( 6, 21, 0, 6, 21, 1), | |
| ( 7, 0, 0, 7, 0, 1), | |
| ( 7, 0, 1, 7, 0, 0), | |
| ( 8, 0, 0, 8, 0, 1), | |
| ( 8, 21, 0, 8, 21, 1), | |
| ( 8, 21, 1, 8, 21, 0), | |
| ( 9, 0, 0, 9, 0, 1), | |
| ( 9, 0, 1, 9, 0, 0), | |
| ( 9, 21, 0, 9, 21, 1), | |
| ( 9, 21, 1, 9, 21, 0), | |
| (12, 21, 1, 12, 21, 0), | |
| (13, 0, 1, 13, 0, 0), | |
| (13, 21, 0, 13, 21, 1), | |
| (13, 21, 1, 13, 21, 0), | |
| (15, 0, 0, 15, 0, 1), | |
| (16, 0, 0, 16, 0, 1), | |
| (16, 21, 0, 16, 21, 1), | |
| (16, 21, 1, 16, 21, 0), | |
| (17, 0, 0, 17, 0, 1), | |
| (17, 21, 0, 17, 21, 1), | |
| (18, 0, 0, 18, 0, 1), | |
| (18, 0, 1, 18, 0, 0), | |
| (18, 21, 0, 18, 21, 1), | |
| (18, 21, 1, 18, 21, 0), | |
| (19, 0, 0, 19, 0, 1), | |
| (19, 0, 1, 19, 0, 0), | |
| (19, 21, 0, 19, 21, 1), | |
| (19, 21, 1, 19, 21, 0), | |
| (21, 0, 1, 21, 0, 0), | |
| (22, 0, 1, 22, 0, 0), | |
| (23, 0, 0, 23, 0, 1), | |
| (23, 0, 1, 23, 0, 0), | |
| (24, 0, 0, 24, 0, 1), | |
| (24, 0, 1, 24, 0, 0) | |
| ] | |
| } | |
| # This dictionary maps package variants to a table of pin names and their | |
| # corresponding grid location (x, y, block). This is most easily found through | |
| # the package view in iCEcube2 by hovering the mouse over each pin. | |
| pinloc_db = { | |
| "1k-swg16tr": [ | |
| ( "A2", 6, 17, 1), | |
| ( "A4", 2, 17, 0), | |
| ( "B1", 11, 17, 1), | |
| ( "B2", 0, 8, 1), | |
| ( "B3", 0, 9, 0), | |
| ( "C1", 12, 0, 0), | |
| ( "C2", 11, 0, 1), | |
| ( "C3", 11, 0, 0), | |
| ( "D1", 12, 0, 1), | |
| ( "D3", 6, 0, 1), | |
| ], | |
| "1k-cm36": [ | |
| ( "A1", 0, 13, 0), | |
| ( "A2", 4, 17, 1), | |
| ( "A3", 7, 17, 0), | |
| ( "B1", 0, 13, 1), | |
| ( "B3", 6, 17, 1), | |
| ( "B4", 13, 9, 0), | |
| ( "B5", 13, 11, 0), | |
| ( "B6", 13, 11, 1), | |
| ( "C1", 0, 9, 0), | |
| ( "C2", 0, 9, 1), | |
| ( "C3", 4, 17, 0), | |
| ( "C5", 13, 8, 1), | |
| ( "C6", 13, 12, 0), | |
| ( "D1", 0, 8, 1), | |
| ( "D5", 12, 0, 1), | |
| ( "D6", 13, 6, 0), | |
| ( "E1", 0, 8, 0), | |
| ( "E2", 6, 0, 0), | |
| ( "E3", 10, 0, 0), | |
| ( "E4", 11, 0, 0), | |
| ( "E5", 12, 0, 0), | |
| ( "E6", 13, 4, 1), | |
| ( "F2", 6, 0, 1), | |
| ( "F3", 10, 0, 1), | |
| ( "F5", 11, 0, 1), | |
| ], | |
| "1k-cm49": [ | |
| ( "A1", 0, 11, 1), | |
| ( "A2", 3, 17, 1), | |
| ( "A3", 8, 17, 1), | |
| ( "A4", 8, 17, 0), | |
| ( "A5", 9, 17, 1), | |
| ( "A6", 10, 17, 0), | |
| ( "A7", 9, 17, 0), | |
| ( "B1", 0, 11, 0), | |
| ( "B2", 0, 13, 0), | |
| ( "B3", 4, 17, 0), | |
| ( "B4", 6, 17, 1), | |
| ( "C1", 0, 5, 0), | |
| ( "C2", 0, 13, 1), | |
| ( "C4", 7, 17, 0), | |
| ( "C5", 13, 12, 0), | |
| ( "C6", 13, 11, 1), | |
| ( "C7", 13, 11, 0), | |
| ( "D1", 0, 5, 1), | |
| ( "D2", 0, 9, 0), | |
| ( "D3", 0, 9, 1), | |
| ( "D4", 4, 17, 1), | |
| ( "D6", 13, 8, 1), | |
| ( "D7", 13, 9, 0), | |
| ( "E2", 0, 8, 1), | |
| ( "E6", 12, 0, 1), | |
| ( "E7", 13, 4, 1), | |
| ( "F2", 0, 8, 0), | |
| ( "F3", 6, 0, 0), | |
| ( "F4", 10, 0, 0), | |
| ( "F5", 11, 0, 0), | |
| ( "F6", 12, 0, 0), | |
| ( "F7", 13, 6, 0), | |
| ( "G3", 6, 0, 1), | |
| ( "G4", 10, 0, 1), | |
| ( "G6", 11, 0, 1), | |
| ], | |
| "1k-cm81": [ | |
| ( "A1", 1, 17, 1), | |
| ( "A2", 4, 17, 0), | |
| ( "A3", 5, 17, 0), | |
| ( "A4", 6, 17, 0), | |
| ( "A6", 8, 17, 1), | |
| ( "A7", 9, 17, 0), | |
| ( "A8", 10, 17, 0), | |
| ( "A9", 13, 14, 1), | |
| ( "B1", 0, 13, 0), | |
| ( "B2", 0, 14, 0), | |
| ( "B3", 2, 17, 1), | |
| ( "B4", 4, 17, 1), | |
| ( "B5", 8, 17, 0), | |
| ( "B6", 9, 17, 1), | |
| ( "B7", 10, 17, 1), | |
| ( "B8", 11, 17, 0), | |
| ( "B9", 13, 11, 1), | |
| ( "C1", 0, 13, 1), | |
| ( "C2", 0, 14, 1), | |
| ( "C3", 0, 12, 1), | |
| ( "C4", 6, 17, 1), | |
| ( "C5", 7, 17, 0), | |
| ( "C9", 13, 12, 0), | |
| ( "D1", 0, 11, 1), | |
| ( "D2", 0, 12, 0), | |
| ( "D3", 0, 9, 0), | |
| ( "D5", 3, 17, 1), | |
| ( "D6", 13, 6, 0), | |
| ( "D7", 13, 7, 0), | |
| ( "D8", 13, 9, 0), | |
| ( "D9", 13, 11, 0), | |
| ( "E1", 0, 10, 1), | |
| ( "E2", 0, 10, 0), | |
| ( "E3", 0, 8, 1), | |
| ( "E4", 0, 11, 0), | |
| ( "E5", 5, 17, 1), | |
| ( "E7", 13, 6, 1), | |
| ( "E8", 13, 8, 1), | |
| ( "F1", 0, 8, 0), | |
| ( "F3", 0, 9, 1), | |
| ( "F7", 12, 0, 1), | |
| ( "F8", 13, 4, 0), | |
| ( "G1", 0, 5, 1), | |
| ( "G3", 0, 5, 0), | |
| ( "G4", 6, 0, 0), | |
| ( "G5", 10, 0, 0), | |
| ( "G6", 11, 0, 0), | |
| ( "G7", 12, 0, 0), | |
| ( "G8", 13, 4, 1), | |
| ( "G9", 13, 2, 1), | |
| ( "H1", 2, 0, 0), | |
| ( "H4", 6, 0, 1), | |
| ( "H5", 10, 0, 1), | |
| ( "H7", 11, 0, 1), | |
| ( "H9", 13, 2, 0), | |
| ( "J1", 3, 0, 0), | |
| ( "J2", 2, 0, 1), | |
| ( "J3", 3, 0, 1), | |
| ( "J4", 5, 0, 0), | |
| ( "J6", 7, 0, 0), | |
| ( "J7", 9, 0, 1), | |
| ( "J8", 13, 1, 0), | |
| ( "J9", 13, 1, 1), | |
| ], | |
| "1k-cm121": [ | |
| ( "A1", 0, 14, 0), | |
| ( "A2", 2, 17, 1), | |
| ( "A3", 3, 17, 0), | |
| ( "A5", 5, 17, 1), | |
| ( "A7", 8, 17, 0), | |
| ( "A8", 10, 17, 1), | |
| ( "A9", 11, 17, 0), | |
| ("A10", 12, 17, 0), | |
| ("A11", 13, 15, 0), | |
| ( "B1", 0, 13, 0), | |
| ( "B2", 1, 17, 1), | |
| ( "B3", 2, 17, 0), | |
| ( "B4", 3, 17, 1), | |
| ( "B5", 4, 17, 1), | |
| ( "B7", 9, 17, 0), | |
| ( "B8", 11, 17, 1), | |
| ( "B9", 12, 17, 1), | |
| ("B10", 13, 15, 1), | |
| ("B11", 13, 14, 1), | |
| ( "C1", 0, 12, 0), | |
| ( "C2", 0, 13, 1), | |
| ( "C3", 0, 14, 1), | |
| ( "C4", 1, 17, 0), | |
| ( "C5", 4, 17, 0), | |
| ( "C6", 7, 17, 1), | |
| ( "C7", 8, 17, 1), | |
| ( "C8", 9, 17, 1), | |
| ( "C9", 10, 17, 0), | |
| ("C10", 13, 14, 0), | |
| ("C11", 13, 13, 1), | |
| ( "D1", 0, 11, 0), | |
| ( "D2", 0, 12, 1), | |
| ( "D3", 0, 11, 1), | |
| ( "D4", 0, 10, 1), | |
| ( "D5", 6, 17, 1), | |
| ( "D6", 7, 17, 0), | |
| ("D10", 13, 12, 1), | |
| ("D11", 13, 11, 1), | |
| ( "E2", 0, 10, 0), | |
| ( "E3", 0, 9, 1), | |
| ( "E4", 0, 9, 0), | |
| ( "E6", 5, 17, 0), | |
| ( "E7", 13, 12, 0), | |
| ( "E8", 13, 13, 0), | |
| ( "E9", 13, 9, 0), | |
| ("E10", 13, 9, 1), | |
| ( "F2", 0, 6, 0), | |
| ( "F3", 0, 5, 0), | |
| ( "F4", 0, 8, 1), | |
| ( "F5", 0, 8, 0), | |
| ( "F6", 6, 17, 0), | |
| ( "F8", 13, 11, 0), | |
| ( "F9", 13, 8, 1), | |
| ("F11", 13, 7, 1), | |
| ( "G2", 0, 5, 1), | |
| ( "G4", 0, 3, 0), | |
| ( "G8", 12, 0, 1), | |
| ( "G9", 13, 8, 0), | |
| ("G11", 13, 7, 0), | |
| ( "H1", 0, 6, 1), | |
| ( "H2", 0, 4, 1), | |
| ( "H4", 0, 2, 0), | |
| ( "H5", 6, 0, 0), | |
| ( "H6", 10, 0, 0), | |
| ( "H7", 11, 0, 0), | |
| ( "H8", 12, 0, 0), | |
| ( "H9", 13, 6, 1), | |
| ("H10", 13, 2, 1), | |
| ("H11", 13, 4, 1), | |
| ( "J1", 0, 4, 0), | |
| ( "J2", 1, 0, 1), | |
| ( "J5", 6, 0, 1), | |
| ( "J6", 10, 0, 1), | |
| ( "J8", 11, 0, 1), | |
| ("J10", 13, 2, 0), | |
| ("J11", 13, 6, 0), | |
| ( "K1", 0, 3, 1), | |
| ( "K2", 2, 0, 0), | |
| ( "K3", 2, 0, 1), | |
| ( "K4", 4, 0, 0), | |
| ( "K5", 5, 0, 0), | |
| ( "K7", 7, 0, 1), | |
| ( "K8", 9, 0, 0), | |
| ( "K9", 13, 1, 0), | |
| ("K10", 13, 1, 1), | |
| ("K11", 13, 3, 1), | |
| ( "L1", 0, 2, 1), | |
| ( "L2", 3, 0, 0), | |
| ( "L3", 3, 0, 1), | |
| ( "L4", 4, 0, 1), | |
| ( "L5", 7, 0, 0), | |
| ( "L7", 8, 0, 0), | |
| ( "L9", 8, 0, 1), | |
| ("L10", 9, 0, 1), | |
| ("L11", 13, 4, 0), | |
| ], | |
| "1k-cb81": [ | |
| ( "A2", 2, 17, 1), | |
| ( "A3", 3, 17, 1), | |
| ( "A4", 6, 17, 1), | |
| ( "A7", 11, 17, 0), | |
| ( "A8", 12, 17, 1), | |
| ( "B1", 0, 13, 1), | |
| ( "B2", 0, 14, 0), | |
| ( "B3", 0, 13, 0), | |
| ( "B4", 5, 17, 1), | |
| ( "B5", 8, 17, 1), | |
| ( "B6", 9, 17, 1), | |
| ( "B7", 11, 17, 1), | |
| ( "B8", 12, 17, 0), | |
| ( "C1", 0, 12, 0), | |
| ( "C2", 0, 10, 0), | |
| ( "C3", 0, 14, 1), | |
| ( "C4", 1, 17, 1), | |
| ( "C5", 8, 17, 0), | |
| ( "C6", 10, 17, 0), | |
| ( "C7", 13, 15, 0), | |
| ( "C8", 13, 15, 1), | |
| ( "C9", 13, 14, 1), | |
| ( "D1", 0, 9, 0), | |
| ( "D2", 0, 10, 1), | |
| ( "D3", 0, 12, 1), | |
| ( "D4", 5, 17, 0), | |
| ( "D5", 4, 17, 0), | |
| ( "D6", 7, 17, 0), | |
| ( "D7", 13, 13, 0), | |
| ( "D8", 13, 13, 1), | |
| ( "E1", 0, 8, 1), | |
| ( "E2", 0, 8, 0), | |
| ( "E3", 0, 9, 1), | |
| ( "E6", 10, 17, 1), | |
| ( "E7", 13, 12, 0), | |
| ( "E8", 13, 11, 0), | |
| ( "E9", 13, 11, 1), | |
| ( "F2", 0, 6, 1), | |
| ( "F3", 0, 6, 0), | |
| ( "F6", 13, 8, 0), | |
| ( "F7", 13, 9, 0), | |
| ( "F8", 13, 8, 1), | |
| ( "F9", 13, 7, 1), | |
| ( "G1", 0, 4, 1), | |
| ( "G2", 0, 2, 1), | |
| ( "G3", 3, 0, 1), | |
| ( "G4", 4, 0, 0), | |
| ( "G5", 10, 0, 0), | |
| ( "G6", 13, 4, 0), | |
| ( "G7", 13, 4, 1), | |
| ( "G8", 13, 6, 1), | |
| ( "G9", 13, 7, 0), | |
| ( "H2", 0, 4, 0), | |
| ( "H3", 2, 0, 1), | |
| ( "H4", 6, 0, 0), | |
| ( "H5", 10, 0, 1), | |
| ( "H7", 11, 0, 0), | |
| ( "H8", 12, 0, 1), | |
| ( "J2", 2, 0, 0), | |
| ( "J3", 6, 0, 1), | |
| ( "J7", 11, 0, 1), | |
| ( "J8", 12, 0, 0), | |
| ], | |
| "1k-cb121": [ | |
| ( "A2", 1, 17, 1), | |
| ( "A3", 2, 17, 0), | |
| ( "A4", 4, 17, 0), | |
| ( "A5", 3, 17, 1), | |
| ( "A6", 4, 17, 1), | |
| ( "A8", 10, 17, 0), | |
| ("A10", 12, 17, 1), | |
| ("A11", 13, 15, 0), | |
| ( "B1", 0, 14, 0), | |
| ( "B3", 1, 17, 0), | |
| ( "B4", 2, 17, 1), | |
| ( "B5", 3, 17, 0), | |
| ( "B8", 10, 17, 1), | |
| ( "B9", 12, 17, 0), | |
| ("B11", 13, 15, 1), | |
| ( "C1", 0, 14, 1), | |
| ( "C2", 0, 11, 1), | |
| ( "C3", 0, 13, 1), | |
| ( "C4", 0, 13, 0), | |
| ( "C5", 5, 17, 0), | |
| ( "C6", 7, 17, 0), | |
| ( "C7", 8, 17, 1), | |
| ( "C8", 11, 17, 0), | |
| ( "C9", 11, 17, 1), | |
| ("C11", 13, 14, 1), | |
| ( "D1", 0, 10, 1), | |
| ( "D2", 0, 11, 0), | |
| ( "D3", 0, 9, 0), | |
| ( "D4", 0, 12, 0), | |
| ( "D5", 5, 17, 1), | |
| ( "D6", 6, 17, 1), | |
| ( "D7", 8, 17, 0), | |
| ( "D8", 13, 12, 0), | |
| ( "D9", 13, 13, 0), | |
| ("D10", 13, 13, 1), | |
| ("D11", 13, 14, 0), | |
| ( "E2", 0, 10, 0), | |
| ( "E3", 0, 9, 1), | |
| ( "E4", 0, 12, 1), | |
| ( "E5", 6, 17, 0), | |
| ( "E6", 7, 17, 1), | |
| ( "E7", 9, 17, 0), | |
| ( "E8", 13, 11, 0), | |
| ( "E9", 13, 11, 1), | |
| ("E11", 13, 12, 1), | |
| ( "F2", 0, 6, 1), | |
| ( "F3", 0, 5, 1), | |
| ( "F4", 0, 8, 1), | |
| ( "F7", 9, 17, 1), | |
| ( "F8", 13, 8, 1), | |
| ( "F9", 13, 9, 0), | |
| ("F10", 13, 9, 1), | |
| ( "G1", 0, 6, 0), | |
| ( "G3", 0, 5, 0), | |
| ( "G4", 0, 8, 0), | |
| ( "G7", 13, 6, 1), | |
| ( "G8", 13, 7, 0), | |
| ( "G9", 13, 7, 1), | |
| ("G10", 13, 8, 0), | |
| ( "H1", 0, 3, 1), | |
| ( "H2", 0, 4, 1), | |
| ( "H3", 0, 4, 0), | |
| ( "H4", 4, 0, 0), | |
| ( "H5", 4, 0, 1), | |
| ( "H6", 10, 0, 0), | |
| ( "H7", 13, 4, 1), | |
| ( "H8", 13, 6, 0), | |
| ( "H9", 13, 4, 0), | |
| ("H10", 13, 3, 1), | |
| ("H11", 9, 0, 1), | |
| ( "J1", 0, 3, 0), | |
| ( "J2", 0, 2, 0), | |
| ( "J3", 0, 2, 1), | |
| ( "J4", 2, 0, 1), | |
| ( "J5", 3, 0, 0), | |
| ( "J6", 10, 0, 1), | |
| ( "J8", 11, 0, 0), | |
| ( "J9", 12, 0, 1), | |
| ("J11", 8, 0, 1), | |
| ( "K3", 1, 0, 0), | |
| ( "K4", 1, 0, 1), | |
| ( "K8", 11, 0, 1), | |
| ( "K9", 12, 0, 0), | |
| ("K11", 9, 0, 0), | |
| ( "L2", 2, 0, 0), | |
| ( "L3", 3, 0, 1), | |
| ( "L4", 5, 0, 0), | |
| ( "L5", 5, 0, 1), | |
| ( "L8", 7, 0, 0), | |
| ( "L9", 6, 0, 1), | |
| ("L10", 7, 0, 1), | |
| ("L11", 8, 0, 0), | |
| ], | |
| "1k-cb132": [ | |
| ( "A1", 1, 17, 1), | |
| ( "A2", 2, 17, 1), | |
| ( "A4", 4, 17, 0), | |
| ( "A5", 4, 17, 1), | |
| ( "A6", 6, 17, 1), | |
| ( "A7", 7, 17, 0), | |
| ("A10", 10, 17, 0), | |
| ("A12", 12, 17, 0), | |
| ( "B1", 0, 14, 1), | |
| ("B14", 13, 15, 0), | |
| ( "C1", 0, 14, 0), | |
| ( "C3", 0, 13, 1), | |
| ( "C4", 1, 17, 0), | |
| ( "C5", 3, 17, 0), | |
| ( "C6", 5, 17, 0), | |
| ( "C7", 6, 17, 0), | |
| ( "C8", 8, 17, 0), | |
| ( "C9", 9, 17, 0), | |
| ("C10", 11, 17, 0), | |
| ("C11", 11, 17, 1), | |
| ("C12", 12, 17, 1), | |
| ("C14", 13, 14, 0), | |
| ( "D1", 0, 11, 1), | |
| ( "D3", 0, 13, 0), | |
| ( "D4", 0, 12, 1), | |
| ( "D5", 2, 17, 0), | |
| ( "D6", 3, 17, 1), | |
| ( "D7", 5, 17, 1), | |
| ( "D8", 7, 17, 1), | |
| ( "D9", 8, 17, 1), | |
| ("D10", 9, 17, 1), | |
| ("D11", 10, 17, 1), | |
| ("D12", 13, 15, 1), | |
| ("D14", 13, 13, 1), | |
| ( "E1", 0, 11, 0), | |
| ( "E4", 0, 12, 0), | |
| ("E11", 13, 14, 1), | |
| ("E12", 13, 13, 0), | |
| ("E14", 13, 12, 0), | |
| ( "F3", 0, 10, 0), | |
| ( "F4", 0, 10, 1), | |
| ("F11", 13, 12, 1), | |
| ("F12", 13, 11, 1), | |
| ("F14", 13, 8, 1), | |
| ( "G1", 0, 8, 1), | |
| ( "G3", 0, 8, 0), | |
| ( "G4", 0, 6, 1), | |
| ("G11", 13, 11, 0), | |
| ("G12", 13, 9, 1), | |
| ("G14", 13, 9, 0), | |
| ( "H1", 0, 9, 0), | |
| ( "H3", 0, 9, 1), | |
| ( "H4", 0, 6, 0), | |
| ("H11", 13, 8, 0), | |
| ("H12", 13, 7, 1), | |
| ( "J1", 0, 5, 1), | |
| ( "J3", 0, 5, 0), | |
| ("J11", 13, 7, 0), | |
| ("J12", 13, 6, 1), | |
| ( "K3", 0, 3, 0), | |
| ( "K4", 0, 3, 1), | |
| ("K11", 13, 4, 1), | |
| ("K12", 13, 4, 0), | |
| ("K14", 13, 6, 0), | |
| ( "L1", 0, 2, 0), | |
| ( "L4", 1, 0, 1), | |
| ( "L5", 3, 0, 1), | |
| ( "L6", 4, 0, 1), | |
| ( "L7", 8, 0, 0), | |
| ( "L8", 9, 0, 0), | |
| ( "L9", 10, 0, 0), | |
| ("L12", 13, 2, 0), | |
| ("L14", 13, 3, 1), | |
| ( "M1", 0, 2, 1), | |
| ( "M3", 1, 0, 0), | |
| ( "M4", 3, 0, 0), | |
| ( "M6", 5, 0, 1), | |
| ( "M7", 6, 0, 0), | |
| ( "M8", 8, 0, 1), | |
| ( "M9", 9, 0, 1), | |
| ("M11", 11, 0, 0), | |
| ("M12", 13, 1, 0), | |
| ("N14", 13, 2, 1), | |
| ( "P2", 2, 0, 0), | |
| ( "P3", 2, 0, 1), | |
| ( "P4", 4, 0, 0), | |
| ( "P5", 5, 0, 0), | |
| ( "P7", 6, 0, 1), | |
| ( "P8", 7, 0, 0), | |
| ( "P9", 7, 0, 1), | |
| ("P10", 10, 0, 1), | |
| ("P11", 11, 0, 1), | |
| ("P12", 12, 0, 0), | |
| ("P13", 12, 0, 1), | |
| ("P14", 13, 1, 1), | |
| ], | |
| "1k-qn84": [ | |
| ( "A1", 0, 14, 0), | |
| ( "A2", 0, 13, 0), | |
| ( "A3", 0, 12, 0), | |
| ( "A4", 0, 11, 0), | |
| ( "A5", 0, 10, 0), | |
| ( "A8", 0, 9, 0), | |
| ( "A9", 0, 8, 1), | |
| ("A10", 0, 5, 1), | |
| ("A11", 0, 4, 0), | |
| ("A12", 0, 2, 0), | |
| ("A13", 4, 0, 0), | |
| ("A14", 6, 0, 1), | |
| ("A16", 6, 0, 0), | |
| ("A19", 9, 0, 1), | |
| ("A20", 10, 0, 1), | |
| ("A22", 11, 0, 1), | |
| ("A23", 12, 0, 0), | |
| ("A25", 13, 4, 0), | |
| ("A26", 13, 6, 0), | |
| ("A27", 13, 7, 1), | |
| ("A29", 13, 8, 1), | |
| ("A31", 13, 11, 1), | |
| ("A32", 13, 12, 1), | |
| ("A33", 13, 13, 1), | |
| ("A34", 13, 14, 0), | |
| ("A35", 13, 15, 0), | |
| ("A38", 11, 17, 0), | |
| ("A39", 10, 17, 0), | |
| ("A40", 9, 17, 0), | |
| ("A41", 8, 17, 0), | |
| ("A43", 7, 17, 0), | |
| ("A44", 6, 17, 0), | |
| ("A45", 5, 17, 0), | |
| ("A46", 4, 17, 0), | |
| ("A47", 3, 17, 0), | |
| ("A48", 1, 17, 1), | |
| ( "B1", 0, 13, 1), | |
| ( "B2", 0, 12, 1), | |
| ( "B3", 0, 11, 1), | |
| ( "B4", 0, 10, 1), | |
| ( "B5", 0, 9, 1), | |
| ( "B7", 0, 8, 0), | |
| ( "B8", 0, 5, 0), | |
| ( "B9", 0, 3, 0), | |
| ("B10", 5, 0, 0), | |
| ("B11", 5, 0, 1), | |
| ("B12", 7, 0, 0), | |
| ("B13", 8, 0, 0), | |
| ("B14", 9, 0, 0), | |
| ("B15", 10, 0, 0), | |
| ("B17", 11, 0, 0), | |
| ("B18", 12, 0, 1), | |
| ("B19", 13, 3, 1), | |
| ("B20", 13, 6, 1), | |
| ("B21", 13, 7, 0), | |
| ("B22", 13, 9, 0), | |
| ("B23", 13, 11, 0), | |
| ("B24", 13, 12, 0), | |
| ("B26", 13, 14, 1), | |
| ("B27", 13, 15, 1), | |
| ("B29", 10, 17, 1), | |
| ("B30", 9, 17, 1), | |
| ("B31", 8, 17, 1), | |
| ("B32", 6, 17, 1), | |
| ("B34", 4, 17, 1), | |
| ("B35", 3, 17, 1), | |
| ("B36", 2, 17, 1), | |
| ], | |
| "1k-tq144": [ | |
| ( "1", 0, 14, 1), | |
| ( "2", 0, 14, 0), | |
| ( "3", 0, 13, 1), | |
| ( "4", 0, 13, 0), | |
| ( "7", 0, 12, 1), | |
| ( "8", 0, 12, 0), | |
| ( "9", 0, 11, 1), | |
| ( "10", 0, 11, 0), | |
| ( "11", 0, 10, 1), | |
| ( "12", 0, 10, 0), | |
| ( "19", 0, 9, 1), | |
| ( "20", 0, 9, 0), | |
| ( "21", 0, 8, 1), | |
| ( "22", 0, 8, 0), | |
| ( "23", 0, 6, 1), | |
| ( "24", 0, 6, 0), | |
| ( "25", 0, 5, 1), | |
| ( "26", 0, 5, 0), | |
| ( "28", 0, 4, 1), | |
| ( "29", 0, 4, 0), | |
| ( "31", 0, 3, 1), | |
| ( "32", 0, 3, 0), | |
| ( "33", 0, 2, 1), | |
| ( "34", 0, 2, 0), | |
| ( "37", 1, 0, 0), | |
| ( "38", 1, 0, 1), | |
| ( "39", 2, 0, 0), | |
| ( "41", 2, 0, 1), | |
| ( "42", 3, 0, 0), | |
| ( "43", 3, 0, 1), | |
| ( "44", 4, 0, 0), | |
| ( "45", 4, 0, 1), | |
| ( "47", 5, 0, 0), | |
| ( "48", 5, 0, 1), | |
| ( "49", 6, 0, 1), | |
| ( "50", 7, 0, 0), | |
| ( "52", 6, 0, 0), | |
| ( "56", 7, 0, 1), | |
| ( "58", 8, 0, 0), | |
| ( "60", 8, 0, 1), | |
| ( "61", 9, 0, 0), | |
| ( "62", 9, 0, 1), | |
| ( "63", 10, 0, 0), | |
| ( "64", 10, 0, 1), | |
| ( "67", 11, 0, 0), | |
| ( "68", 11, 0, 1), | |
| ( "70", 12, 0, 0), | |
| ( "71", 12, 0, 1), | |
| ( "73", 13, 1, 0), | |
| ( "74", 13, 1, 1), | |
| ( "75", 13, 2, 0), | |
| ( "76", 13, 2, 1), | |
| ( "78", 13, 3, 1), | |
| ( "79", 13, 4, 0), | |
| ( "80", 13, 4, 1), | |
| ( "81", 13, 6, 0), | |
| ( "87", 13, 6, 1), | |
| ( "88", 13, 7, 0), | |
| ( "90", 13, 7, 1), | |
| ( "91", 13, 8, 0), | |
| ( "93", 13, 8, 1), | |
| ( "94", 13, 9, 0), | |
| ( "95", 13, 9, 1), | |
| ( "96", 13, 11, 0), | |
| ( "97", 13, 11, 1), | |
| ( "98", 13, 12, 0), | |
| ( "99", 13, 12, 1), | |
| ("101", 13, 13, 0), | |
| ("102", 13, 13, 1), | |
| ("104", 13, 14, 0), | |
| ("105", 13, 14, 1), | |
| ("106", 13, 15, 0), | |
| ("107", 13, 15, 1), | |
| ("112", 12, 17, 1), | |
| ("113", 12, 17, 0), | |
| ("114", 11, 17, 1), | |
| ("115", 11, 17, 0), | |
| ("116", 10, 17, 1), | |
| ("117", 10, 17, 0), | |
| ("118", 9, 17, 1), | |
| ("119", 9, 17, 0), | |
| ("120", 8, 17, 1), | |
| ("121", 8, 17, 0), | |
| ("122", 7, 17, 1), | |
| ("128", 7, 17, 0), | |
| ("129", 6, 17, 1), | |
| ("134", 5, 17, 1), | |
| ("135", 5, 17, 0), | |
| ("136", 4, 17, 1), | |
| ("137", 4, 17, 0), | |
| ("138", 3, 17, 1), | |
| ("139", 3, 17, 0), | |
| ("141", 2, 17, 1), | |
| ("142", 2, 17, 0), | |
| ("143", 1, 17, 1), | |
| ("144", 1, 17, 0), | |
| ], | |
| "1k-vq100": [ | |
| ( "1", 0, 14, 1), | |
| ( "2", 0, 14, 0), | |
| ( "3", 0, 13, 1), | |
| ( "4", 0, 13, 0), | |
| ( "7", 0, 12, 1), | |
| ( "8", 0, 12, 0), | |
| ( "9", 0, 10, 1), | |
| ( "10", 0, 10, 0), | |
| ( "12", 0, 9, 1), | |
| ( "13", 0, 9, 0), | |
| ( "15", 0, 8, 1), | |
| ( "16", 0, 8, 0), | |
| ( "18", 0, 6, 1), | |
| ( "19", 0, 6, 0), | |
| ( "20", 0, 4, 1), | |
| ( "21", 0, 4, 0), | |
| ( "24", 0, 2, 1), | |
| ( "25", 0, 2, 0), | |
| ( "26", 2, 0, 0), | |
| ( "27", 2, 0, 1), | |
| ( "28", 3, 0, 0), | |
| ( "29", 3, 0, 1), | |
| ( "30", 4, 0, 0), | |
| ( "33", 6, 0, 1), | |
| ( "34", 7, 0, 0), | |
| ( "36", 6, 0, 0), | |
| ( "37", 7, 0, 1), | |
| ( "40", 9, 0, 1), | |
| ( "41", 10, 0, 0), | |
| ( "42", 10, 0, 1), | |
| ( "45", 11, 0, 0), | |
| ( "46", 11, 0, 1), | |
| ( "48", 12, 0, 0), | |
| ( "49", 12, 0, 1), | |
| ( "51", 13, 3, 1), | |
| ( "52", 13, 4, 0), | |
| ( "53", 13, 4, 1), | |
| ( "54", 13, 6, 0), | |
| ( "56", 13, 6, 1), | |
| ( "57", 13, 7, 0), | |
| ( "59", 13, 7, 1), | |
| ( "60", 13, 8, 0), | |
| ( "62", 13, 8, 1), | |
| ( "63", 13, 9, 0), | |
| ( "64", 13, 11, 0), | |
| ( "65", 13, 11, 1), | |
| ( "66", 13, 12, 0), | |
| ( "68", 13, 13, 0), | |
| ( "69", 13, 13, 1), | |
| ( "71", 13, 14, 0), | |
| ( "72", 13, 14, 1), | |
| ( "73", 13, 15, 0), | |
| ( "74", 13, 15, 1), | |
| ( "78", 12, 17, 1), | |
| ( "79", 12, 17, 0), | |
| ( "80", 11, 17, 1), | |
| ( "81", 10, 17, 1), | |
| ( "82", 10, 17, 0), | |
| ( "83", 9, 17, 1), | |
| ( "85", 9, 17, 0), | |
| ( "86", 8, 17, 1), | |
| ( "87", 8, 17, 0), | |
| ( "89", 7, 17, 0), | |
| ( "90", 6, 17, 1), | |
| ( "91", 6, 17, 0), | |
| ( "93", 5, 17, 1), | |
| ( "94", 5, 17, 0), | |
| ( "95", 4, 17, 1), | |
| ( "96", 4, 17, 0), | |
| ( "97", 3, 17, 1), | |
| ( "99", 2, 17, 1), | |
| ("100", 1, 17, 1), | |
| ], | |
| "8k-cb132:4k": [ | |
| ( "A1", 2, 33, 0), | |
| ( "A2", 3, 33, 0), | |
| ( "A3", 3, 33, 1), | |
| ( "A4", 5, 33, 0), | |
| ( "A5", 10, 33, 1), | |
| ( "A6", 16, 33, 1), | |
| ( "A7", 17, 33, 0), | |
| ("A10", 25, 33, 0), | |
| ("A11", 26, 33, 0), | |
| ("A12", 30, 33, 1), | |
| ( "B1", 0, 30, 1), | |
| ("B14", 33, 28, 0), | |
| ( "C1", 0, 30, 0), | |
| ( "C3", 0, 27, 1), | |
| ( "C4", 4, 33, 0), | |
| ( "C5", 8, 33, 1), | |
| ( "C6", 11, 33, 1), | |
| ( "C7", 14, 33, 1), | |
| ( "C9", 20, 33, 1), | |
| ("C10", 22, 33, 1), | |
| ("C11", 28, 33, 1), | |
| ("C12", 29, 33, 1), | |
| ("C14", 33, 24, 1), | |
| ( "D1", 0, 25, 1), | |
| ( "D3", 0, 27, 0), | |
| ( "D4", 0, 22, 1), | |
| ( "D5", 9, 33, 0), | |
| ( "D6", 11, 33, 0), | |
| ( "D7", 13, 33, 1), | |
| ( "D9", 21, 33, 1), | |
| ("D10", 27, 33, 0), | |
| ("D11", 26, 33, 1), | |
| ("D12", 33, 27, 1), | |
| ("D14", 33, 23, 1), | |
| ( "E1", 0, 25, 0), | |
| ( "E4", 0, 22, 0), | |
| ("E11", 33, 20, 1), | |
| ("E12", 33, 21, 0), | |
| ("E14", 33, 21, 1), | |
| ( "F3", 0, 21, 0), | |
| ( "F4", 0, 21, 1), | |
| ("F11", 33, 19, 1), | |
| ("F12", 33, 15, 0), | |
| ("F14", 33, 16, 1), | |
| ( "G1", 0, 17, 0), | |
| ( "G3", 0, 17, 1), | |
| ( "G4", 0, 20, 0), | |
| ("G11", 33, 14, 1), | |
| ("G12", 33, 11, 0), | |
| ("G14", 33, 17, 0), | |
| ( "H1", 0, 16, 1), | |
| ( "H3", 0, 16, 0), | |
| ( "H4", 0, 20, 1), | |
| ("H11", 33, 10, 1), | |
| ("H12", 33, 6, 1), | |
| ( "J1", 0, 18, 0), | |
| ( "J3", 0, 18, 1), | |
| ("J11", 33, 6, 0), | |
| ("J12", 33, 5, 1), | |
| ( "K3", 0, 11, 1), | |
| ( "K4", 0, 11, 0), | |
| ("K11", 33, 4, 1), | |
| ("K12", 33, 4, 0), | |
| ("K14", 33, 5, 0), | |
| ( "L1", 0, 6, 1), | |
| ( "L4", 12, 0, 0), | |
| ( "L5", 11, 0, 1), | |
| ( "L6", 15, 0, 0), | |
| ( "L8", 20, 0, 1), | |
| ( "L9", 29, 0, 0), | |
| ("L12", 33, 2, 0), | |
| ("L14", 33, 3, 1), | |
| ( "M1", 0, 6, 0), | |
| ( "M3", 8, 0, 0), | |
| ( "M4", 7, 0, 1), | |
| ( "M6", 14, 0, 1), | |
| ( "M7", 15, 0, 1), | |
| ( "M9", 22, 0, 1), | |
| ("M11", 30, 0, 0), | |
| ("M12", 33, 1, 0), | |
| ( "N1", 0, 4, 1), | |
| ("N14", 33, 2, 1), | |
| ( "P1", 0, 4, 0), | |
| ( "P2", 4, 0, 0), | |
| ( "P3", 5, 0, 1), | |
| ( "P4", 12, 0, 1), | |
| ( "P5", 13, 0, 0), | |
| ( "P7", 16, 0, 1), | |
| ( "P8", 17, 0, 0), | |
| ( "P9", 21, 0, 1), | |
| ("P10", 29, 0, 1), | |
| ("P11", 30, 0, 1), | |
| ("P12", 31, 0, 0), | |
| ("P13", 31, 0, 1), | |
| ("P14", 33, 1, 1), | |
| ], | |
| "8k-tq144:4k": [ | |
| ( "1", 0, 30, 1), | |
| ( "2", 0, 30, 0), | |
| ( "3", 0, 28, 1), | |
| ( "4", 0, 28, 0), | |
| ( "7", 0, 27, 1), | |
| ( "8", 0, 27, 0), | |
| ( "9", 0, 25, 1), | |
| ( "10", 0, 25, 0), | |
| ( "11", 0, 22, 1), | |
| ( "12", 0, 22, 0), | |
| ( "15", 0, 20, 1), | |
| ( "16", 0, 20, 0), | |
| ( "17", 0, 18, 1), | |
| ( "18", 0, 18, 0), | |
| ( "19", 0, 17, 1), | |
| ( "20", 0, 17, 0), | |
| ( "21", 0, 16, 1), | |
| ( "22", 0, 16, 0), | |
| ( "23", 0, 12, 1), | |
| ( "24", 0, 12, 0), | |
| ( "25", 0, 11, 1), | |
| ( "26", 0, 11, 0), | |
| ( "28", 0, 6, 1), | |
| ( "29", 0, 6, 0), | |
| ( "31", 0, 5, 1), | |
| ( "32", 0, 5, 0), | |
| ( "33", 0, 4, 1), | |
| ( "34", 0, 4, 0), | |
| ( "37", 4, 0, 0), | |
| ( "38", 4, 0, 1), | |
| ( "39", 6, 0, 1), | |
| ( "41", 7, 0, 1), | |
| ( "42", 8, 0, 0), | |
| ( "43", 11, 0, 1), | |
| ( "44", 12, 0, 0), | |
| ( "45", 12, 0, 1), | |
| ( "47", 15, 0, 1), | |
| ( "48", 16, 0, 0), | |
| ( "49", 16, 0, 1), | |
| ( "52", 17, 0, 0), | |
| ( "55", 22, 0, 1), | |
| ( "56", 24, 0, 0), | |
| ( "60", 24, 0, 1), | |
| ( "61", 25, 0, 0), | |
| ( "62", 28, 0, 0), | |
| ( "63", 29, 0, 0), | |
| ( "64", 29, 0, 1), | |
| ( "67", 30, 0, 0), | |
| ( "68", 30, 0, 1), | |
| ( "70", 31, 0, 0), | |
| ( "71", 31, 0, 1), | |
| ( "73", 33, 1, 0), | |
| ( "74", 33, 1, 1), | |
| ( "75", 33, 2, 0), | |
| ( "76", 33, 2, 1), | |
| ( "78", 33, 3, 1), | |
| ( "79", 33, 4, 0), | |
| ( "80", 33, 4, 1), | |
| ( "81", 33, 5, 0), | |
| ( "82", 33, 5, 1), | |
| ( "83", 33, 6, 0), | |
| ( "84", 33, 6, 1), | |
| ( "85", 33, 10, 1), | |
| ( "87", 33, 14, 1), | |
| ( "88", 33, 15, 0), | |
| ( "90", 33, 15, 1), | |
| ( "91", 33, 16, 0), | |
| ( "93", 33, 16, 1), | |
| ( "94", 33, 17, 0), | |
| ( "95", 33, 19, 1), | |
| ( "96", 33, 20, 1), | |
| ( "97", 33, 21, 0), | |
| ( "98", 33, 21, 1), | |
| ( "99", 33, 23, 1), | |
| ("101", 33, 27, 1), | |
| ("102", 33, 28, 0), | |
| ("104", 33, 29, 1), | |
| ("105", 33, 30, 0), | |
| ("106", 33, 30, 1), | |
| ("107", 33, 31, 0), | |
| ("110", 31, 33, 1), | |
| ("112", 31, 33, 0), | |
| ("113", 30, 33, 1), | |
| ("114", 30, 33, 0), | |
| ("115", 29, 33, 1), | |
| ("116", 29, 33, 0), | |
| ("117", 28, 33, 1), | |
| ("118", 27, 33, 0), | |
| ("119", 26, 33, 1), | |
| ("120", 26, 33, 0), | |
| ("121", 25, 33, 0), | |
| ("122", 20, 33, 1), | |
| ("124", 20, 33, 0), | |
| ("125", 19, 33, 1), | |
| ("128", 17, 33, 0), | |
| ("129", 16, 33, 1), | |
| ("130", 11, 33, 1), | |
| ("134", 8, 33, 1), | |
| ("135", 8, 33, 0), | |
| ("136", 7, 33, 1), | |
| ("137", 7, 33, 0), | |
| ("138", 6, 33, 1), | |
| ("139", 6, 33, 0), | |
| ("141", 5, 33, 0), | |
| ("142", 4, 33, 1), | |
| ("143", 4, 33, 0), | |
| ("144", 3, 33, 1), | |
| ], | |
| "8k-cm81:4k": [ | |
| ( "A1", 2, 33, 1), | |
| ( "A2", 4, 33, 0), | |
| ( "A3", 6, 33, 0), | |
| ( "A4", 10, 33, 1), | |
| ( "A6", 23, 33, 0), | |
| ( "A7", 27, 33, 0), | |
| ( "A8", 28, 33, 1), | |
| ( "A9", 33, 4, 1), | |
| ( "B1", 0, 28, 1), | |
| ( "B2", 0, 30, 0), | |
| ( "B3", 5, 33, 1), | |
| ( "B4", 9, 33, 0), | |
| ( "B5", 21, 33, 1), | |
| ( "B6", 24, 33, 0), | |
| ( "B7", 25, 33, 1), | |
| ( "B8", 30, 33, 1), | |
| ( "B9", 33, 6, 1), | |
| ( "C1", 0, 28, 0), | |
| ( "C2", 0, 30, 1), | |
| ( "C3", 0, 23, 0), | |
| ( "C4", 16, 33, 1), | |
| ( "C5", 17, 33, 0), | |
| ( "C9", 33, 21, 1), | |
| ( "D1", 0, 20, 1), | |
| ( "D2", 0, 23, 1), | |
| ( "D3", 0, 17, 0), | |
| ( "D5", 8, 33, 1), | |
| ( "D6", 33, 4, 0), | |
| ( "D7", 33, 5, 0), | |
| ( "D8", 33, 17, 0), | |
| ( "D9", 33, 6, 0), | |
| ( "E1", 0, 20, 0), | |
| ( "E2", 0, 17, 1), | |
| ( "E3", 0, 16, 1), | |
| ( "E4", 0, 16, 0), | |
| ( "E5", 7, 33, 1), | |
| ( "E7", 33, 5, 1), | |
| ( "E8", 33, 16, 1), | |
| ( "F1", 0, 7, 1), | |
| ( "F3", 0, 7, 0), | |
| ( "F7", 31, 0, 1), | |
| ( "F8", 33, 3, 0), | |
| ( "G1", 0, 5, 0), | |
| ( "G2", 0, 3, 1), | |
| ( "G3", 0, 5, 1), | |
| ( "G4", 16, 0, 1), | |
| ( "G5", 29, 0, 0), | |
| ( "G6", 30, 0, 0), | |
| ( "G7", 31, 0, 0), | |
| ( "G8", 33, 3, 1), | |
| ( "G9", 33, 2, 1), | |
| ( "H1", 3, 0, 0), | |
| ( "H2", 0, 3, 0), | |
| ( "H4", 17, 0, 0), | |
| ( "H5", 29, 0, 1), | |
| ( "H7", 30, 0, 1), | |
| ( "H9", 33, 2, 0), | |
| ( "J1", 3, 0, 1), | |
| ( "J2", 4, 0, 0), | |
| ( "J3", 4, 0, 1), | |
| ( "J4", 11, 0, 0), | |
| ( "J8", 33, 1, 0), | |
| ( "J9", 33, 1, 1), | |
| ], | |
| "8k-cm121:4k": [ | |
| ( "A1", 2, 33, 0), | |
| ( "A2", 3, 33, 1), | |
| ( "A3", 3, 33, 0), | |
| ( "A4", 9, 33, 0), | |
| ( "A5", 11, 33, 0), | |
| ( "A6", 11, 33, 1), | |
| ( "A7", 19, 33, 1), | |
| ( "A8", 20, 33, 1), | |
| ( "A9", 26, 33, 1), | |
| ("A10", 30, 33, 1), | |
| ("A11", 31, 33, 1), | |
| ( "B1", 0, 30, 1), | |
| ( "B2", 0, 30, 0), | |
| ( "B3", 4, 33, 0), | |
| ( "B4", 5, 33, 0), | |
| ( "B5", 10, 33, 1), | |
| ( "B6", 16, 33, 1), | |
| ( "B7", 17, 33, 0), | |
| ( "B8", 27, 33, 0), | |
| ( "B9", 28, 33, 1), | |
| ("B11", 33, 28, 0), | |
| ( "C1", 0, 25, 0), | |
| ( "C2", 0, 25, 1), | |
| ( "C3", 0, 27, 0), | |
| ( "C4", 0, 27, 1), | |
| ( "C7", 20, 33, 0), | |
| ( "C8", 26, 33, 0), | |
| ( "C9", 29, 33, 1), | |
| ("C11", 33, 27, 1), | |
| ( "D1", 0, 22, 0), | |
| ( "D2", 0, 21, 1), | |
| ( "D3", 0, 21, 0), | |
| ( "D5", 8, 33, 1), | |
| ( "D7", 25, 33, 0), | |
| ( "D9", 33, 21, 0), | |
| ("D10", 33, 24, 1), | |
| ("D11", 33, 23, 1), | |
| ( "E1", 0, 22, 1), | |
| ( "E2", 0, 20, 1), | |
| ( "E3", 0, 20, 0), | |
| ( "E8", 33, 20, 1), | |
| ( "E9", 33, 19, 1), | |
| ("E10", 33, 17, 0), | |
| ("E11", 33, 21, 1), | |
| ( "F1", 0, 18, 1), | |
| ( "F2", 0, 18, 0), | |
| ( "F3", 0, 17, 0), | |
| ( "F4", 0, 17, 1), | |
| ( "F9", 33, 15, 0), | |
| ("F10", 33, 14, 1), | |
| ("F11", 33, 16, 1), | |
| ( "G1", 0, 16, 1), | |
| ( "G2", 0, 16, 0), | |
| ( "G3", 0, 12, 1), | |
| ( "G8", 33, 5, 1), | |
| ( "G9", 33, 10, 1), | |
| ("G10", 33, 6, 1), | |
| ("G11", 33, 11, 0), | |
| ( "H1", 0, 11, 1), | |
| ( "H2", 0, 11, 0), | |
| ( "H3", 0, 12, 0), | |
| ( "H7", 20, 0, 1), | |
| ( "H9", 29, 0, 1), | |
| ("H10", 33, 4, 1), | |
| ("H11", 33, 6, 0), | |
| ( "J1", 0, 6, 1), | |
| ( "J2", 0, 4, 0), | |
| ( "J3", 4, 0, 1), | |
| ( "J4", 8, 0, 0), | |
| ( "J5", 15, 0, 0), | |
| ( "J7", 20, 0, 0), | |
| ( "J8", 22, 0, 1), | |
| ( "J9", 30, 0, 1), | |
| ("J10", 33, 5, 0), | |
| ("J11", 33, 3, 1), | |
| ( "K1", 0, 6, 0), | |
| ( "K2", 0, 4, 1), | |
| ( "K3", 7, 0, 1), | |
| ( "K4", 12, 0, 1), | |
| ( "K5", 15, 0, 1), | |
| ( "K6", 17, 0, 0), | |
| ( "K7", 21, 0, 1), | |
| ( "K9", 30, 0, 0), | |
| ("K10", 31, 0, 1), | |
| ("K11", 33, 4, 0), | |
| ( "L1", 4, 0, 0), | |
| ( "L2", 6, 0, 1), | |
| ( "L3", 11, 0, 1), | |
| ( "L4", 12, 0, 0), | |
| ( "L5", 16, 0, 1), | |
| ( "L7", 24, 0, 0), | |
| ( "L8", 29, 0, 0), | |
| ("L10", 31, 0, 0), | |
| ], | |
| "8k-bg121:4k": [ | |
| ( "A1", 2, 33, 0), | |
| ( "A2", 3, 33, 1), | |
| ( "A3", 3, 33, 0), | |
| ( "A4", 9, 33, 0), | |
| ( "A5", 11, 33, 0), | |
| ( "A6", 11, 33, 1), | |
| ( "A7", 19, 33, 1), | |
| ( "A8", 20, 33, 1), | |
| ( "A9", 26, 33, 1), | |
| ("A10", 30, 33, 1), | |
| ("A11", 31, 33, 1), | |
| ( "B1", 0, 30, 1), | |
| ( "B2", 0, 30, 0), | |
| ( "B3", 4, 33, 0), | |
| ( "B4", 5, 33, 0), | |
| ( "B5", 10, 33, 1), | |
| ( "B6", 16, 33, 1), | |
| ( "B7", 17, 33, 0), | |
| ( "B8", 27, 33, 0), | |
| ( "B9", 28, 33, 1), | |
| ("B11", 33, 28, 0), | |
| ( "C1", 0, 25, 0), | |
| ( "C2", 0, 25, 1), | |
| ( "C3", 0, 27, 0), | |
| ( "C4", 0, 27, 1), | |
| ( "C7", 20, 33, 0), | |
| ( "C8", 26, 33, 0), | |
| ( "C9", 29, 33, 1), | |
| ("C11", 33, 27, 1), | |
| ( "D1", 0, 22, 0), | |
| ( "D2", 0, 21, 1), | |
| ( "D3", 0, 21, 0), | |
| ( "D5", 8, 33, 1), | |
| ( "D7", 25, 33, 0), | |
| ( "D9", 33, 21, 0), | |
| ("D10", 33, 24, 1), | |
| ("D11", 33, 23, 1), | |
| ( "E1", 0, 22, 1), | |
| ( "E2", 0, 20, 1), | |
| ( "E3", 0, 20, 0), | |
| ( "E8", 33, 20, 1), | |
| ( "E9", 33, 19, 1), | |
| ("E10", 33, 17, 0), | |
| ("E11", 33, 21, 1), | |
| ( "F1", 0, 18, 1), | |
| ( "F2", 0, 18, 0), | |
| ( "F3", 0, 17, 0), | |
| ( "F4", 0, 17, 1), | |
| ( "F9", 33, 15, 0), | |
| ("F10", 33, 14, 1), | |
| ("F11", 33, 16, 1), | |
| ( "G1", 0, 16, 1), | |
| ( "G2", 0, 16, 0), | |
| ( "G3", 0, 12, 1), | |
| ( "G8", 33, 5, 1), | |
| ( "G9", 33, 10, 1), | |
| ("G10", 33, 6, 1), | |
| ("G11", 33, 11, 0), | |
| ( "H1", 0, 11, 1), | |
| ( "H2", 0, 11, 0), | |
| ( "H3", 0, 12, 0), | |
| ( "H7", 20, 0, 1), | |
| ( "H9", 29, 0, 1), | |
| ("H10", 33, 4, 1), | |
| ("H11", 33, 6, 0), | |
| ( "J1", 0, 6, 1), | |
| ( "J2", 0, 4, 0), | |
| ( "J3", 4, 0, 1), | |
| ( "J4", 8, 0, 0), | |
| ( "J5", 15, 0, 0), | |
| ( "J7", 20, 0, 0), | |
| ( "J8", 22, 0, 1), | |
| ( "J9", 30, 0, 1), | |
| ("J10", 33, 5, 0), | |
| ("J11", 33, 3, 1), | |
| ( "K1", 0, 6, 0), | |
| ( "K2", 0, 4, 1), | |
| ( "K3", 7, 0, 1), | |
| ( "K4", 12, 0, 1), | |
| ( "K5", 15, 0, 1), | |
| ( "K6", 17, 0, 0), | |
| ( "K7", 21, 0, 1), | |
| ( "K9", 30, 0, 0), | |
| ("K10", 31, 0, 1), | |
| ("K11", 33, 4, 0), | |
| ( "L1", 4, 0, 0), | |
| ( "L2", 6, 0, 1), | |
| ( "L3", 11, 0, 1), | |
| ( "L4", 12, 0, 0), | |
| ( "L5", 16, 0, 1), | |
| ( "L7", 24, 0, 0), | |
| ( "L8", 29, 0, 0), | |
| ("L10", 31, 0, 0), | |
| ], | |
| "8k-cm225:4k": [ | |
| ( "A1", 1, 33, 1), | |
| ( "A2", 3, 33, 1), | |
| ( "A5", 6, 33, 1), | |
| ( "A6", 11, 33, 0), | |
| ( "A7", 12, 33, 0), | |
| ( "A8", 17, 33, 1), | |
| ( "A9", 18, 33, 1), | |
| ("A11", 23, 33, 1), | |
| ("A15", 31, 33, 0), | |
| ( "B2", 2, 33, 1), | |
| ( "B3", 4, 33, 1), | |
| ( "B4", 5, 33, 1), | |
| ( "B5", 7, 33, 1), | |
| ( "B6", 10, 33, 0), | |
| ( "B7", 14, 33, 0), | |
| ( "B8", 19, 33, 1), | |
| ( "B9", 18, 33, 0), | |
| ("B10", 22, 33, 0), | |
| ("B11", 23, 33, 0), | |
| ("B12", 25, 33, 1), | |
| ("B13", 27, 33, 1), | |
| ("B14", 31, 33, 1), | |
| ("B15", 33, 31, 0), | |
| ( "C1", 0, 28, 0), | |
| ( "C3", 2, 33, 0), | |
| ( "C4", 3, 33, 0), | |
| ( "C5", 5, 33, 0), | |
| ( "C6", 13, 33, 0), | |
| ( "C7", 11, 33, 1), | |
| ( "C8", 19, 33, 0), | |
| ( "C9", 17, 33, 0), | |
| ("C10", 20, 33, 0), | |
| ("C11", 24, 33, 1), | |
| ("C12", 30, 33, 1), | |
| ("C13", 30, 33, 0), | |
| ("C14", 33, 30, 0), | |
| ( "D1", 0, 25, 0), | |
| ( "D2", 0, 24, 1), | |
| ( "D3", 0, 27, 0), | |
| ( "D4", 0, 30, 0), | |
| ( "D5", 4, 33, 0), | |
| ( "D6", 9, 33, 0), | |
| ( "D7", 10, 33, 1), | |
| ( "D8", 16, 33, 1), | |
| ( "D9", 26, 33, 1), | |
| ("D10", 25, 33, 0), | |
| ("D11", 28, 33, 1), | |
| ("D13", 33, 27, 1), | |
| ("D14", 33, 25, 0), | |
| ("D15", 33, 27, 0), | |
| ( "E2", 0, 24, 0), | |
| ( "E3", 0, 28, 1), | |
| ( "E4", 0, 30, 1), | |
| ( "E5", 0, 27, 1), | |
| ( "E6", 0, 25, 1), | |
| ( "E9", 26, 33, 0), | |
| ("E10", 27, 33, 0), | |
| ("E11", 29, 33, 1), | |
| ("E13", 33, 28, 0), | |
| ("E14", 33, 24, 0), | |
| ( "F1", 0, 20, 0), | |
| ( "F2", 0, 21, 0), | |
| ( "F3", 0, 21, 1), | |
| ( "F4", 0, 22, 0), | |
| ( "F5", 0, 22, 1), | |
| ( "F7", 8, 33, 1), | |
| ( "F9", 20, 33, 1), | |
| ("F11", 33, 24, 1), | |
| ("F12", 33, 23, 1), | |
| ("F13", 33, 23, 0), | |
| ("F14", 33, 21, 0), | |
| ("F15", 33, 22, 0), | |
| ( "G2", 0, 20, 1), | |
| ( "G4", 0, 17, 0), | |
| ( "G5", 0, 18, 1), | |
| ("G10", 33, 20, 1), | |
| ("G11", 33, 19, 1), | |
| ("G12", 33, 21, 1), | |
| ("G13", 33, 17, 0), | |
| ("G14", 33, 20, 0), | |
| ("G15", 33, 19, 0), | |
| ( "H1", 0, 16, 0), | |
| ( "H2", 0, 18, 0), | |
| ( "H3", 0, 14, 1), | |
| ( "H4", 0, 13, 1), | |
| ( "H5", 0, 16, 1), | |
| ( "H6", 0, 17, 1), | |
| ("H11", 33, 14, 1), | |
| ("H12", 33, 16, 1), | |
| ("H13", 33, 15, 1), | |
| ("H14", 33, 15, 0), | |
| ( "J1", 0, 13, 0), | |
| ( "J2", 0, 12, 0), | |
| ( "J3", 0, 14, 0), | |
| ( "J4", 0, 11, 1), | |
| ( "J5", 0, 12, 1), | |
| ("J10", 33, 5, 1), | |
| ("J11", 33, 10, 1), | |
| ("J12", 33, 6, 1), | |
| ("J14", 33, 14, 0), | |
| ("J15", 33, 13, 0), | |
| ( "K1", 0, 11, 0), | |
| ( "K4", 0, 4, 0), | |
| ( "K5", 0, 6, 1), | |
| ( "K9", 20, 0, 1), | |
| ("K11", 29, 0, 0), | |
| ("K12", 33, 4, 1), | |
| ("K13", 33, 5, 0), | |
| ("K15", 33, 9, 0), | |
| ( "L3", 0, 7, 1), | |
| ( "L4", 0, 3, 0), | |
| ( "L5", 4, 0, 0), | |
| ( "L6", 7, 0, 0), | |
| ( "L7", 12, 0, 0), | |
| ( "L9", 17, 0, 0), | |
| ("L10", 21, 0, 1), | |
| ("L11", 30, 0, 1), | |
| ("L12", 33, 3, 1), | |
| ("L13", 33, 6, 0), | |
| ( "M1", 0, 7, 0), | |
| ( "M2", 0, 6, 0), | |
| ( "M3", 0, 5, 0), | |
| ( "M4", 0, 3, 1), | |
| ( "M5", 6, 0, 0), | |
| ( "M6", 8, 0, 0), | |
| ( "M7", 13, 0, 1), | |
| ( "M8", 15, 0, 0), | |
| ( "M9", 19, 0, 1), | |
| ("M11", 30, 0, 0), | |
| ("M12", 31, 0, 1), | |
| ("M13", 33, 4, 0), | |
| ("M15", 33, 3, 0), | |
| ( "N2", 0, 5, 1), | |
| ( "N3", 2, 0, 0), | |
| ( "N4", 3, 0, 0), | |
| ( "N5", 9, 0, 1), | |
| ( "N6", 12, 0, 1), | |
| ( "N7", 16, 0, 1), | |
| ( "N9", 20, 0, 0), | |
| ("N10", 22, 0, 1), | |
| ("N12", 31, 0, 0), | |
| ( "P1", 0, 4, 1), | |
| ( "P2", 2, 0, 1), | |
| ( "P4", 7, 0, 1), | |
| ( "P5", 10, 0, 1), | |
| ( "P6", 14, 0, 1), | |
| ( "P7", 17, 0, 1), | |
| ( "P8", 19, 0, 0), | |
| ( "P9", 22, 0, 0), | |
| ("P10", 23, 0, 0), | |
| ("P11", 25, 0, 0), | |
| ("P12", 29, 0, 1), | |
| ("P13", 27, 0, 0), | |
| ("P14", 33, 2, 1), | |
| ("P15", 33, 1, 1), | |
| ( "R1", 3, 0, 1), | |
| ( "R2", 4, 0, 1), | |
| ( "R3", 6, 0, 1), | |
| ( "R4", 8, 0, 1), | |
| ( "R5", 11, 0, 1), | |
| ( "R6", 15, 0, 1), | |
| ( "R9", 21, 0, 0), | |
| ("R10", 24, 0, 0), | |
| ("R11", 26, 0, 0), | |
| ("R12", 28, 0, 0), | |
| ("R14", 33, 2, 0), | |
| ("R15", 33, 1, 0), | |
| ], | |
| "8k-cm81": [ | |
| ( "A1", 2, 33, 1), | |
| ( "A2", 4, 33, 0), | |
| ( "A3", 6, 33, 0), | |
| ( "A4", 10, 33, 1), | |
| ( "A6", 23, 33, 0), | |
| ( "A7", 27, 33, 0), | |
| ( "A8", 28, 33, 1), | |
| ( "A9", 33, 4, 1), | |
| ( "B1", 0, 28, 1), | |
| ( "B2", 0, 30, 0), | |
| ( "B3", 5, 33, 1), | |
| ( "B4", 9, 33, 0), | |
| ( "B5", 21, 33, 1), | |
| ( "B6", 24, 33, 0), | |
| ( "B7", 25, 33, 1), | |
| ( "B8", 30, 33, 1), | |
| ( "B9", 33, 6, 1), | |
| ( "C1", 0, 28, 0), | |
| ( "C2", 0, 30, 1), | |
| ( "C3", 0, 23, 0), | |
| ( "C4", 16, 33, 1), | |
| ( "C5", 17, 33, 0), | |
| ( "C9", 33, 21, 1), | |
| ( "D1", 0, 20, 1), | |
| ( "D2", 0, 23, 1), | |
| ( "D3", 0, 17, 0), | |
| ( "D5", 8, 33, 1), | |
| ( "D6", 33, 4, 0), | |
| ( "D7", 33, 5, 0), | |
| ( "D8", 33, 17, 0), | |
| ( "D9", 33, 6, 0), | |
| ( "E1", 0, 20, 0), | |
| ( "E2", 0, 17, 1), | |
| ( "E3", 0, 16, 1), | |
| ( "E4", 0, 16, 0), | |
| ( "E5", 7, 33, 1), | |
| ( "E7", 33, 5, 1), | |
| ( "E8", 33, 16, 1), | |
| ( "F1", 0, 7, 1), | |
| ( "F3", 0, 7, 0), | |
| ( "F7", 31, 0, 1), | |
| ( "F8", 33, 3, 0), | |
| ( "G1", 0, 5, 0), | |
| ( "G2", 0, 3, 1), | |
| ( "G3", 0, 5, 1), | |
| ( "G4", 16, 0, 1), | |
| ( "G5", 29, 0, 0), | |
| ( "G6", 30, 0, 0), | |
| ( "G7", 31, 0, 0), | |
| ( "G8", 33, 3, 1), | |
| ( "G9", 33, 2, 1), | |
| ( "H1", 3, 0, 0), | |
| ( "H2", 0, 3, 0), | |
| ( "H4", 17, 0, 0), | |
| ( "H5", 29, 0, 1), | |
| ( "H7", 30, 0, 1), | |
| ( "H9", 33, 2, 0), | |
| ( "J1", 3, 0, 1), | |
| ( "J2", 4, 0, 0), | |
| ( "J3", 4, 0, 1), | |
| ( "J4", 11, 0, 0), | |
| ( "J8", 33, 1, 0), | |
| ( "J9", 33, 1, 1), | |
| ], | |
| "8k-cm121": [ | |
| ( "A1", 2, 33, 0), | |
| ( "A2", 3, 33, 1), | |
| ( "A3", 3, 33, 0), | |
| ( "A4", 9, 33, 0), | |
| ( "A5", 11, 33, 0), | |
| ( "A6", 11, 33, 1), | |
| ( "A7", 19, 33, 1), | |
| ( "A8", 20, 33, 1), | |
| ( "A9", 26, 33, 1), | |
| ("A10", 30, 33, 1), | |
| ("A11", 31, 33, 1), | |
| ( "B1", 0, 30, 1), | |
| ( "B2", 0, 30, 0), | |
| ( "B3", 4, 33, 0), | |
| ( "B4", 5, 33, 0), | |
| ( "B5", 10, 33, 1), | |
| ( "B6", 16, 33, 1), | |
| ( "B7", 17, 33, 0), | |
| ( "B8", 27, 33, 0), | |
| ( "B9", 28, 33, 1), | |
| ("B11", 33, 28, 0), | |
| ( "C1", 0, 25, 0), | |
| ( "C2", 0, 25, 1), | |
| ( "C3", 0, 27, 0), | |
| ( "C4", 0, 27, 1), | |
| ( "C7", 20, 33, 0), | |
| ( "C8", 26, 33, 0), | |
| ( "C9", 29, 33, 1), | |
| ("C11", 33, 27, 1), | |
| ( "D1", 0, 22, 0), | |
| ( "D2", 0, 21, 1), | |
| ( "D3", 0, 21, 0), | |
| ( "D5", 8, 33, 1), | |
| ( "D7", 25, 33, 0), | |
| ( "D9", 33, 21, 0), | |
| ("D10", 33, 24, 1), | |
| ("D11", 33, 23, 1), | |
| ( "E1", 0, 22, 1), | |
| ( "E2", 0, 20, 1), | |
| ( "E3", 0, 20, 0), | |
| ( "E8", 33, 20, 1), | |
| ( "E9", 33, 19, 1), | |
| ("E10", 33, 17, 0), | |
| ("E11", 33, 21, 1), | |
| ( "F1", 0, 18, 1), | |
| ( "F2", 0, 18, 0), | |
| ( "F3", 0, 17, 0), | |
| ( "F4", 0, 17, 1), | |
| ( "F9", 33, 15, 0), | |
| ("F10", 33, 14, 1), | |
| ("F11", 33, 16, 1), | |
| ( "G1", 0, 16, 1), | |
| ( "G2", 0, 16, 0), | |
| ( "G3", 0, 12, 1), | |
| ( "G8", 33, 5, 1), | |
| ( "G9", 33, 10, 1), | |
| ("G10", 33, 6, 1), | |
| ("G11", 33, 11, 0), | |
| ( "H1", 0, 11, 1), | |
| ( "H2", 0, 11, 0), | |
| ( "H3", 0, 12, 0), | |
| ( "H7", 20, 0, 1), | |
| ( "H9", 29, 0, 1), | |
| ("H10", 33, 4, 1), | |
| ("H11", 33, 6, 0), | |
| ( "J1", 0, 6, 1), | |
| ( "J2", 0, 4, 0), | |
| ( "J3", 4, 0, 1), | |
| ( "J4", 8, 0, 0), | |
| ( "J5", 15, 0, 0), | |
| ( "J7", 20, 0, 0), | |
| ( "J8", 22, 0, 1), | |
| ( "J9", 30, 0, 1), | |
| ("J10", 33, 5, 0), | |
| ("J11", 33, 3, 1), | |
| ( "K1", 0, 6, 0), | |
| ( "K2", 0, 4, 1), | |
| ( "K3", 7, 0, 1), | |
| ( "K4", 12, 0, 1), | |
| ( "K5", 15, 0, 1), | |
| ( "K6", 17, 0, 0), | |
| ( "K7", 21, 0, 1), | |
| ( "K9", 30, 0, 0), | |
| ("K10", 31, 0, 1), | |
| ("K11", 33, 4, 0), | |
| ( "L1", 4, 0, 0), | |
| ( "L2", 6, 0, 1), | |
| ( "L3", 11, 0, 1), | |
| ( "L4", 12, 0, 0), | |
| ( "L5", 16, 0, 1), | |
| ( "L7", 24, 0, 0), | |
| ( "L8", 29, 0, 0), | |
| ("L10", 31, 0, 0), | |
| ], | |
| "8k-bg121": [ | |
| ( "A1", 2, 33, 0), | |
| ( "A2", 3, 33, 1), | |
| ( "A3", 3, 33, 0), | |
| ( "A4", 9, 33, 0), | |
| ( "A5", 11, 33, 0), | |
| ( "A6", 11, 33, 1), | |
| ( "A7", 19, 33, 1), | |
| ( "A8", 20, 33, 1), | |
| ( "A9", 26, 33, 1), | |
| ("A10", 30, 33, 1), | |
| ("A11", 31, 33, 1), | |
| ( "B1", 0, 30, 1), | |
| ( "B2", 0, 30, 0), | |
| ( "B3", 4, 33, 0), | |
| ( "B4", 5, 33, 0), | |
| ( "B5", 10, 33, 1), | |
| ( "B6", 16, 33, 1), | |
| ( "B7", 17, 33, 0), | |
| ( "B8", 27, 33, 0), | |
| ( "B9", 28, 33, 1), | |
| ("B11", 33, 28, 0), | |
| ( "C1", 0, 25, 0), | |
| ( "C2", 0, 25, 1), | |
| ( "C3", 0, 27, 0), | |
| ( "C4", 0, 27, 1), | |
| ( "C7", 20, 33, 0), | |
| ( "C8", 26, 33, 0), | |
| ( "C9", 29, 33, 1), | |
| ("C11", 33, 27, 1), | |
| ( "D1", 0, 22, 0), | |
| ( "D2", 0, 21, 1), | |
| ( "D3", 0, 21, 0), | |
| ( "D5", 8, 33, 1), | |
| ( "D7", 25, 33, 0), | |
| ( "D9", 33, 21, 0), | |
| ("D10", 33, 24, 1), | |
| ("D11", 33, 23, 1), | |
| ( "E1", 0, 22, 1), | |
| ( "E2", 0, 20, 1), | |
| ( "E3", 0, 20, 0), | |
| ( "E8", 33, 20, 1), | |
| ( "E9", 33, 19, 1), | |
| ("E10", 33, 17, 0), | |
| ("E11", 33, 21, 1), | |
| ( "F1", 0, 18, 1), | |
| ( "F2", 0, 18, 0), | |
| ( "F3", 0, 17, 0), | |
| ( "F4", 0, 17, 1), | |
| ( "F9", 33, 15, 0), | |
| ("F10", 33, 14, 1), | |
| ("F11", 33, 16, 1), | |
| ( "G1", 0, 16, 1), | |
| ( "G2", 0, 16, 0), | |
| ( "G3", 0, 12, 1), | |
| ( "G8", 33, 5, 1), | |
| ( "G9", 33, 10, 1), | |
| ("G10", 33, 6, 1), | |
| ("G11", 33, 11, 0), | |
| ( "H1", 0, 11, 1), | |
| ( "H2", 0, 11, 0), | |
| ( "H3", 0, 12, 0), | |
| ( "H7", 20, 0, 1), | |
| ( "H9", 29, 0, 1), | |
| ("H10", 33, 4, 1), | |
| ("H11", 33, 6, 0), | |
| ( "J1", 0, 6, 1), | |
| ( "J2", 0, 4, 0), | |
| ( "J3", 4, 0, 1), | |
| ( "J4", 8, 0, 0), | |
| ( "J5", 15, 0, 0), | |
| ( "J7", 20, 0, 0), | |
| ( "J8", 22, 0, 1), | |
| ( "J9", 30, 0, 1), | |
| ("J10", 33, 5, 0), | |
| ("J11", 33, 3, 1), | |
| ( "K1", 0, 6, 0), | |
| ( "K2", 0, 4, 1), | |
| ( "K3", 7, 0, 1), | |
| ( "K4", 12, 0, 1), | |
| ( "K5", 15, 0, 1), | |
| ( "K6", 17, 0, 0), | |
| ( "K7", 21, 0, 1), | |
| ( "K9", 30, 0, 0), | |
| ("K10", 31, 0, 1), | |
| ("K11", 33, 4, 0), | |
| ( "L1", 4, 0, 0), | |
| ( "L2", 6, 0, 1), | |
| ( "L3", 11, 0, 1), | |
| ( "L4", 12, 0, 0), | |
| ( "L5", 16, 0, 1), | |
| ( "L7", 24, 0, 0), | |
| ( "L8", 29, 0, 0), | |
| ("L10", 31, 0, 0), | |
| ], | |
| "8k-cm225": [ | |
| ( "A1", 1, 33, 1), | |
| ( "A2", 3, 33, 1), | |
| ( "A5", 6, 33, 1), | |
| ( "A6", 11, 33, 0), | |
| ( "A7", 12, 33, 0), | |
| ( "A8", 17, 33, 1), | |
| ( "A9", 18, 33, 1), | |
| ("A10", 21, 33, 0), | |
| ("A11", 23, 33, 1), | |
| ("A15", 31, 33, 0), | |
| ( "B1", 0, 31, 0), | |
| ( "B2", 2, 33, 1), | |
| ( "B3", 4, 33, 1), | |
| ( "B4", 5, 33, 1), | |
| ( "B5", 7, 33, 1), | |
| ( "B6", 10, 33, 0), | |
| ( "B7", 14, 33, 0), | |
| ( "B8", 19, 33, 1), | |
| ( "B9", 18, 33, 0), | |
| ("B10", 22, 33, 0), | |
| ("B11", 23, 33, 0), | |
| ("B12", 25, 33, 1), | |
| ("B13", 27, 33, 1), | |
| ("B14", 31, 33, 1), | |
| ("B15", 33, 31, 0), | |
| ( "C1", 0, 28, 0), | |
| ( "C2", 0, 31, 1), | |
| ( "C3", 2, 33, 0), | |
| ( "C4", 3, 33, 0), | |
| ( "C5", 5, 33, 0), | |
| ( "C6", 13, 33, 0), | |
| ( "C7", 11, 33, 1), | |
| ( "C8", 19, 33, 0), | |
| ( "C9", 17, 33, 0), | |
| ("C10", 20, 33, 0), | |
| ("C11", 24, 33, 1), | |
| ("C12", 30, 33, 1), | |
| ("C13", 30, 33, 0), | |
| ("C14", 33, 30, 0), | |
| ( "D1", 0, 25, 0), | |
| ( "D2", 0, 24, 1), | |
| ( "D3", 0, 27, 0), | |
| ( "D4", 0, 30, 0), | |
| ( "D5", 4, 33, 0), | |
| ( "D6", 9, 33, 0), | |
| ( "D7", 10, 33, 1), | |
| ( "D8", 16, 33, 1), | |
| ( "D9", 26, 33, 1), | |
| ("D10", 25, 33, 0), | |
| ("D11", 28, 33, 1), | |
| ("D13", 33, 27, 1), | |
| ("D14", 33, 25, 0), | |
| ("D15", 33, 27, 0), | |
| ( "E2", 0, 24, 0), | |
| ( "E3", 0, 28, 1), | |
| ( "E4", 0, 30, 1), | |
| ( "E5", 0, 27, 1), | |
| ( "E6", 0, 25, 1), | |
| ( "E9", 26, 33, 0), | |
| ("E10", 27, 33, 0), | |
| ("E11", 29, 33, 1), | |
| ("E13", 33, 28, 0), | |
| ("E14", 33, 24, 0), | |
| ( "F1", 0, 20, 0), | |
| ( "F2", 0, 21, 0), | |
| ( "F3", 0, 21, 1), | |
| ( "F4", 0, 22, 0), | |
| ( "F5", 0, 22, 1), | |
| ( "F7", 8, 33, 1), | |
| ( "F9", 20, 33, 1), | |
| ("F11", 33, 24, 1), | |
| ("F12", 33, 23, 1), | |
| ("F13", 33, 23, 0), | |
| ("F14", 33, 21, 0), | |
| ("F15", 33, 22, 0), | |
| ( "G1", 0, 19, 0), | |
| ( "G2", 0, 20, 1), | |
| ( "G3", 0, 19, 1), | |
| ( "G4", 0, 17, 0), | |
| ( "G5", 0, 18, 1), | |
| ("G10", 33, 20, 1), | |
| ("G11", 33, 19, 1), | |
| ("G12", 33, 21, 1), | |
| ("G13", 33, 17, 0), | |
| ("G14", 33, 20, 0), | |
| ("G15", 33, 19, 0), | |
| ( "H1", 0, 16, 0), | |
| ( "H2", 0, 18, 0), | |
| ( "H3", 0, 14, 1), | |
| ( "H4", 0, 13, 1), | |
| ( "H5", 0, 16, 1), | |
| ( "H6", 0, 17, 1), | |
| ("H11", 33, 14, 1), | |
| ("H12", 33, 16, 1), | |
| ("H13", 33, 15, 1), | |
| ("H14", 33, 15, 0), | |
| ( "J1", 0, 13, 0), | |
| ( "J2", 0, 12, 0), | |
| ( "J3", 0, 14, 0), | |
| ( "J4", 0, 11, 1), | |
| ( "J5", 0, 12, 1), | |
| ("J10", 33, 5, 1), | |
| ("J11", 33, 10, 1), | |
| ("J12", 33, 6, 1), | |
| ("J13", 33, 11, 0), | |
| ("J14", 33, 14, 0), | |
| ("J15", 33, 13, 0), | |
| ( "K1", 0, 11, 0), | |
| ( "K3", 0, 9, 1), | |
| ( "K4", 0, 4, 0), | |
| ( "K5", 0, 6, 1), | |
| ( "K9", 20, 0, 1), | |
| ("K11", 29, 0, 0), | |
| ("K12", 33, 4, 1), | |
| ("K13", 33, 5, 0), | |
| ("K14", 33, 12, 0), | |
| ("K15", 33, 9, 0), | |
| ( "L1", 0, 9, 0), | |
| ( "L3", 0, 7, 1), | |
| ( "L4", 0, 3, 0), | |
| ( "L5", 4, 0, 0), | |
| ( "L6", 7, 0, 0), | |
| ( "L7", 12, 0, 0), | |
| ( "L9", 17, 0, 0), | |
| ("L10", 21, 0, 1), | |
| ("L11", 30, 0, 1), | |
| ("L12", 33, 3, 1), | |
| ("L13", 33, 6, 0), | |
| ("L14", 33, 7, 0), | |
| ( "M1", 0, 7, 0), | |
| ( "M2", 0, 6, 0), | |
| ( "M3", 0, 5, 0), | |
| ( "M4", 0, 3, 1), | |
| ( "M5", 6, 0, 0), | |
| ( "M6", 8, 0, 0), | |
| ( "M7", 13, 0, 1), | |
| ( "M8", 15, 0, 0), | |
| ( "M9", 19, 0, 1), | |
| ("M11", 30, 0, 0), | |
| ("M12", 31, 0, 1), | |
| ("M13", 33, 4, 0), | |
| ("M14", 33, 8, 0), | |
| ("M15", 33, 3, 0), | |
| ( "N2", 0, 5, 1), | |
| ( "N3", 2, 0, 0), | |
| ( "N4", 3, 0, 0), | |
| ( "N5", 9, 0, 1), | |
| ( "N6", 12, 0, 1), | |
| ( "N7", 16, 0, 1), | |
| ( "N9", 20, 0, 0), | |
| ("N10", 22, 0, 1), | |
| ("N12", 31, 0, 0), | |
| ( "P1", 0, 4, 1), | |
| ( "P2", 2, 0, 1), | |
| ( "P4", 7, 0, 1), | |
| ( "P5", 10, 0, 1), | |
| ( "P6", 14, 0, 1), | |
| ( "P7", 17, 0, 1), | |
| ( "P8", 19, 0, 0), | |
| ( "P9", 22, 0, 0), | |
| ("P10", 23, 0, 0), | |
| ("P11", 25, 0, 0), | |
| ("P12", 29, 0, 1), | |
| ("P13", 27, 0, 0), | |
| ("P14", 33, 2, 1), | |
| ("P15", 33, 1, 1), | |
| ( "R1", 3, 0, 1), | |
| ( "R2", 4, 0, 1), | |
| ( "R3", 6, 0, 1), | |
| ( "R4", 8, 0, 1), | |
| ( "R5", 11, 0, 1), | |
| ( "R6", 15, 0, 1), | |
| ( "R9", 21, 0, 0), | |
| ("R10", 24, 0, 0), | |
| ("R11", 26, 0, 0), | |
| ("R12", 28, 0, 0), | |
| ("R14", 33, 2, 0), | |
| ("R15", 33, 1, 0), | |
| ], | |
| "8k-cb132": [ | |
| ( "A1", 2, 33, 0), | |
| ( "A2", 3, 33, 0), | |
| ( "A3", 3, 33, 1), | |
| ( "A4", 5, 33, 0), | |
| ( "A5", 10, 33, 1), | |
| ( "A6", 16, 33, 1), | |
| ( "A7", 17, 33, 0), | |
| ("A10", 25, 33, 0), | |
| ("A11", 26, 33, 0), | |
| ("A12", 30, 33, 1), | |
| ( "B1", 0, 30, 1), | |
| ("B14", 33, 28, 0), | |
| ( "C1", 0, 30, 0), | |
| ( "C3", 0, 27, 1), | |
| ( "C4", 4, 33, 0), | |
| ( "C5", 8, 33, 1), | |
| ( "C6", 11, 33, 1), | |
| ( "C7", 14, 33, 1), | |
| ( "C9", 20, 33, 1), | |
| ("C10", 22, 33, 1), | |
| ("C11", 28, 33, 1), | |
| ("C12", 29, 33, 1), | |
| ("C14", 33, 24, 1), | |
| ( "D1", 0, 25, 1), | |
| ( "D3", 0, 27, 0), | |
| ( "D4", 0, 22, 1), | |
| ( "D5", 9, 33, 0), | |
| ( "D6", 11, 33, 0), | |
| ( "D7", 13, 33, 1), | |
| ( "D9", 21, 33, 1), | |
| ("D10", 27, 33, 0), | |
| ("D11", 26, 33, 1), | |
| ("D12", 33, 27, 1), | |
| ("D14", 33, 23, 1), | |
| ( "E1", 0, 25, 0), | |
| ( "E4", 0, 22, 0), | |
| ("E11", 33, 20, 1), | |
| ("E12", 33, 21, 0), | |
| ("E14", 33, 21, 1), | |
| ( "F3", 0, 21, 0), | |
| ( "F4", 0, 21, 1), | |
| ("F11", 33, 19, 1), | |
| ("F12", 33, 15, 0), | |
| ("F14", 33, 16, 1), | |
| ( "G1", 0, 17, 0), | |
| ( "G3", 0, 17, 1), | |
| ( "G4", 0, 20, 0), | |
| ("G11", 33, 14, 1), | |
| ("G12", 33, 11, 0), | |
| ("G14", 33, 17, 0), | |
| ( "H1", 0, 16, 1), | |
| ( "H3", 0, 16, 0), | |
| ( "H4", 0, 20, 1), | |
| ("H11", 33, 10, 1), | |
| ("H12", 33, 6, 1), | |
| ( "J1", 0, 18, 0), | |
| ( "J3", 0, 18, 1), | |
| ("J11", 33, 6, 0), | |
| ("J12", 33, 5, 1), | |
| ( "K3", 0, 11, 1), | |
| ( "K4", 0, 11, 0), | |
| ("K11", 33, 4, 1), | |
| ("K12", 33, 4, 0), | |
| ("K14", 33, 5, 0), | |
| ( "L1", 0, 6, 1), | |
| ( "L4", 12, 0, 0), | |
| ( "L5", 11, 0, 1), | |
| ( "L6", 15, 0, 0), | |
| ( "L8", 20, 0, 1), | |
| ( "L9", 29, 0, 0), | |
| ("L12", 33, 2, 0), | |
| ("L14", 33, 3, 1), | |
| ( "M1", 0, 6, 0), | |
| ( "M3", 8, 0, 0), | |
| ( "M4", 7, 0, 1), | |
| ( "M6", 14, 0, 1), | |
| ( "M7", 15, 0, 1), | |
| ( "M9", 22, 0, 1), | |
| ("M11", 30, 0, 0), | |
| ("M12", 33, 1, 0), | |
| ( "N1", 0, 4, 1), | |
| ("N14", 33, 2, 1), | |
| ( "P1", 0, 4, 0), | |
| ( "P2", 4, 0, 0), | |
| ( "P3", 5, 0, 1), | |
| ( "P4", 12, 0, 1), | |
| ( "P5", 13, 0, 0), | |
| ( "P7", 16, 0, 1), | |
| ( "P8", 17, 0, 0), | |
| ( "P9", 21, 0, 1), | |
| ("P10", 29, 0, 1), | |
| ("P11", 30, 0, 1), | |
| ("P12", 31, 0, 0), | |
| ("P13", 31, 0, 1), | |
| ("P14", 33, 1, 1), | |
| ], | |
| "8k-ct256": [ | |
| ( "A1", 4, 33, 1), | |
| ( "A2", 5, 33, 1), | |
| ( "A5", 8, 33, 0), | |
| ( "A6", 9, 33, 0), | |
| ( "A7", 12, 33, 0), | |
| ( "A9", 18, 33, 1), | |
| ("A10", 22, 33, 1), | |
| ("A11", 22, 33, 0), | |
| ("A15", 27, 33, 0), | |
| ("A16", 27, 33, 1), | |
| ( "B1", 0, 30, 0), | |
| ( "B2", 0, 31, 0), | |
| ( "B3", 3, 33, 0), | |
| ( "B4", 6, 33, 1), | |
| ( "B5", 7, 33, 1), | |
| ( "B6", 10, 33, 1), | |
| ( "B7", 11, 33, 0), | |
| ( "B8", 13, 33, 0), | |
| ( "B9", 16, 33, 0), | |
| ("B10", 24, 33, 0), | |
| ("B11", 23, 33, 1), | |
| ("B12", 24, 33, 1), | |
| ("B13", 26, 33, 1), | |
| ("B14", 30, 33, 0), | |
| ("B15", 31, 33, 0), | |
| ("B16", 33, 30, 0), | |
| ( "C1", 0, 28, 1), | |
| ( "C2", 0, 28, 0), | |
| ( "C3", 1, 33, 0), | |
| ( "C4", 3, 33, 1), | |
| ( "C5", 4, 33, 0), | |
| ( "C6", 10, 33, 0), | |
| ( "C7", 11, 33, 1), | |
| ( "C8", 17, 33, 0), | |
| ( "C9", 20, 33, 0), | |
| ("C10", 23, 33, 0), | |
| ("C11", 25, 33, 1), | |
| ("C12", 29, 33, 1), | |
| ("C13", 28, 33, 1), | |
| ("C14", 31, 33, 1), | |
| ("C16", 33, 28, 0), | |
| ( "D1", 0, 25, 0), | |
| ( "D2", 0, 27, 0), | |
| ( "D3", 1, 33, 1), | |
| ( "D4", 2, 33, 1), | |
| ( "D5", 5, 33, 0), | |
| ( "D6", 8, 33, 1), | |
| ( "D7", 9, 33, 1), | |
| ( "D8", 14, 33, 1), | |
| ( "D9", 19, 33, 0), | |
| ("D10", 20, 33, 1), | |
| ("D11", 25, 33, 0), | |
| ("D13", 30, 33, 1), | |
| ("D14", 33, 31, 0), | |
| ("D15", 33, 26, 0), | |
| ("D16", 33, 24, 0), | |
| ( "E2", 0, 23, 0), | |
| ( "E3", 0, 24, 0), | |
| ( "E4", 0, 31, 1), | |
| ( "E5", 2, 33, 0), | |
| ( "E6", 7, 33, 0), | |
| ( "E9", 19, 33, 1), | |
| ("E10", 26, 33, 0), | |
| ("E11", 29, 33, 0), | |
| ("E13", 33, 30, 1), | |
| ("E14", 33, 27, 1), | |
| ("E16", 33, 23, 0), | |
| ( "F1", 0, 20, 0), | |
| ( "F2", 0, 21, 0), | |
| ( "F3", 0, 22, 0), | |
| ( "F4", 0, 27, 1), | |
| ( "F5", 0, 30, 1), | |
| ( "F7", 16, 33, 1), | |
| ( "F9", 17, 33, 1), | |
| ("F11", 33, 26, 1), | |
| ("F12", 33, 25, 1), | |
| ("F13", 33, 28, 1), | |
| ("F14", 33, 25, 0), | |
| ("F15", 33, 22, 0), | |
| ("F16", 33, 21, 0), | |
| ( "G1", 0, 17, 0), | |
| ( "G2", 0, 19, 0), | |
| ( "G3", 0, 22, 1), | |
| ( "G4", 0, 24, 1), | |
| ( "G5", 0, 25, 1), | |
| ("G10", 33, 20, 1), | |
| ("G11", 33, 21, 1), | |
| ("G12", 33, 24, 1), | |
| ("G13", 33, 23, 1), | |
| ("G14", 33, 22, 1), | |
| ("G15", 33, 20, 0), | |
| ("G16", 33, 19, 0), | |
| ( "H1", 0, 16, 0), | |
| ( "H2", 0, 18, 0), | |
| ( "H3", 0, 21, 1), | |
| ( "H4", 0, 19, 1), | |
| ( "H5", 0, 23, 1), | |
| ( "H6", 0, 20, 1), | |
| ("H11", 33, 16, 1), | |
| ("H12", 33, 19, 1), | |
| ("H13", 33, 16, 0), | |
| ("H14", 33, 17, 1), | |
| ("H16", 33, 17, 0), | |
| ( "J1", 0, 14, 0), | |
| ( "J2", 0, 14, 1), | |
| ( "J3", 0, 16, 1), | |
| ( "J4", 0, 18, 1), | |
| ( "J5", 0, 17, 1), | |
| ("J10", 33, 7, 1), | |
| ("J11", 33, 9, 1), | |
| ("J12", 33, 14, 1), | |
| ("J13", 33, 15, 0), | |
| ("J14", 33, 13, 1), | |
| ("J15", 33, 11, 1), | |
| ("J16", 33, 15, 1), | |
| ( "K1", 0, 13, 1), | |
| ( "K3", 0, 13, 0), | |
| ( "K4", 0, 11, 1), | |
| ( "K5", 0, 9, 1), | |
| ( "K9", 17, 0, 0), | |
| ("K11", 29, 0, 0), | |
| ("K12", 33, 6, 1), | |
| ("K13", 33, 10, 1), | |
| ("K14", 33, 11, 0), | |
| ("K15", 33, 12, 0), | |
| ("K16", 33, 13, 0), | |
| ( "L1", 0, 12, 0), | |
| ( "L3", 0, 10, 0), | |
| ( "L4", 0, 12, 1), | |
| ( "L5", 0, 6, 1), | |
| ( "L6", 0, 10, 1), | |
| ( "L7", 0, 8, 1), | |
| ( "L9", 13, 0, 0), | |
| ("L10", 19, 0, 1), | |
| ("L11", 26, 0, 1), | |
| ("L12", 33, 4, 1), | |
| ("L13", 33, 5, 1), | |
| ("L14", 33, 6, 0), | |
| ("L16", 33, 10, 0), | |
| ( "M1", 0, 11, 0), | |
| ( "M2", 0, 9, 0), | |
| ( "M3", 0, 7, 0), | |
| ( "M4", 0, 5, 0), | |
| ( "M5", 0, 4, 0), | |
| ( "M6", 0, 7, 1), | |
| ( "M7", 8, 0, 0), | |
| ( "M8", 10, 0, 0), | |
| ( "M9", 16, 0, 0), | |
| ("M11", 23, 0, 1), | |
| ("M12", 27, 0, 1), | |
| ("M13", 33, 3, 1), | |
| ("M14", 33, 4, 0), | |
| ("M15", 33, 8, 0), | |
| ("M16", 33, 7, 0), | |
| ( "N2", 0, 8, 0), | |
| ( "N3", 0, 6, 0), | |
| ( "N4", 0, 3, 0), | |
| ( "N5", 4, 0, 0), | |
| ( "N6", 2, 0, 0), | |
| ( "N7", 9, 0, 0), | |
| ( "N9", 15, 0, 0), | |
| ("N10", 20, 0, 1), | |
| ("N12", 26, 0, 0), | |
| ("N16", 33, 5, 0), | |
| ( "P1", 0, 5, 1), | |
| ( "P2", 0, 4, 1), | |
| ( "P4", 3, 0, 0), | |
| ( "P5", 5, 0, 0), | |
| ( "P6", 9, 0, 1), | |
| ( "P7", 14, 0, 1), | |
| ( "P8", 12, 0, 0), | |
| ( "P9", 17, 0, 1), | |
| ("P10", 20, 0, 0), | |
| ("P11", 30, 0, 1), | |
| ("P12", 30, 0, 0), | |
| ("P13", 29, 0, 1), | |
| ("P14", 33, 2, 0), | |
| ("P15", 33, 2, 1), | |
| ("P16", 33, 3, 0), | |
| ( "R1", 0, 3, 1), | |
| ( "R2", 3, 0, 1), | |
| ( "R3", 5, 0, 1), | |
| ( "R4", 7, 0, 1), | |
| ( "R5", 6, 0, 0), | |
| ( "R6", 11, 0, 1), | |
| ( "R9", 16, 0, 1), | |
| ("R10", 19, 0, 0), | |
| ("R11", 31, 0, 0), | |
| ("R12", 31, 0, 1), | |
| ("R14", 33, 1, 0), | |
| ("R15", 33, 1, 1), | |
| ("R16", 28, 0, 0), | |
| ( "T1", 2, 0, 1), | |
| ( "T2", 4, 0, 1), | |
| ( "T3", 6, 0, 1), | |
| ( "T5", 10, 0, 1), | |
| ( "T6", 12, 0, 1), | |
| ( "T7", 13, 0, 1), | |
| ( "T8", 14, 0, 0), | |
| ( "T9", 15, 0, 1), | |
| ("T10", 21, 0, 0), | |
| ("T11", 21, 0, 1), | |
| ("T13", 24, 0, 0), | |
| ("T14", 23, 0, 0), | |
| ("T15", 22, 0, 1), | |
| ("T16", 27, 0, 0), | |
| ], | |
| "384-qn32": [ | |
| ( "1", 0, 7, 0), | |
| ( "2", 0, 7, 1), | |
| ( "5", 0, 5, 1), | |
| ( "6", 0, 5, 0), | |
| ( "7", 0, 4, 0), | |
| ( "8", 0, 4, 1), | |
| ( "12", 5, 0, 0), | |
| ( "13", 5, 0, 1), | |
| ( "14", 6, 0, 1), | |
| ( "15", 6, 0, 0), | |
| ( "18", 7, 4, 0), | |
| ( "19", 7, 4, 1), | |
| ( "20", 7, 5, 0), | |
| ( "22", 7, 6, 0), | |
| ( "23", 7, 6, 1), | |
| ( "26", 6, 9, 0), | |
| ( "27", 5, 9, 0), | |
| ( "29", 4, 9, 0), | |
| ( "30", 3, 9, 1), | |
| ( "31", 2, 9, 0), | |
| ( "32", 2, 9, 1), | |
| ], | |
| "384-cm36": [ | |
| ( "A1", 0, 7, 0), | |
| ( "A2", 2, 9, 1), | |
| ( "A3", 3, 9, 1), | |
| ( "B1", 0, 7, 1), | |
| ( "B3", 4, 9, 0), | |
| ( "B4", 7, 5, 0), | |
| ( "B5", 7, 5, 1), | |
| ( "B6", 7, 6, 0), | |
| ( "C1", 0, 5, 0), | |
| ( "C2", 0, 5, 1), | |
| ( "C3", 2, 9, 0), | |
| ( "C5", 7, 4, 1), | |
| ( "C6", 7, 6, 1), | |
| ( "D1", 0, 4, 1), | |
| ( "D5", 6, 0, 1), | |
| ( "D6", 7, 4, 0), | |
| ( "E1", 0, 4, 0), | |
| ( "E2", 3, 0, 1), | |
| ( "E3", 4, 0, 0), | |
| ( "E4", 5, 0, 0), | |
| ( "E5", 6, 0, 0), | |
| ( "E6", 7, 3, 1), | |
| ( "F2", 3, 0, 0), | |
| ( "F3", 4, 0, 1), | |
| ( "F5", 5, 0, 1), | |
| ], | |
| "384-cm49": [ | |
| ( "A1", 0, 7, 1), | |
| ( "A2", 2, 9, 1), | |
| ( "A3", 3, 9, 0), | |
| ( "A4", 4, 9, 1), | |
| ( "A5", 5, 9, 0), | |
| ( "A6", 6, 9, 0), | |
| ( "A7", 6, 9, 1), | |
| ( "B1", 0, 7, 0), | |
| ( "B2", 0, 6, 0), | |
| ( "B3", 2, 9, 0), | |
| ( "B4", 4, 9, 0), | |
| ( "C1", 0, 5, 1), | |
| ( "C2", 0, 6, 1), | |
| ( "C4", 3, 9, 1), | |
| ( "C5", 7, 6, 1), | |
| ( "C6", 7, 5, 1), | |
| ( "C7", 7, 6, 0), | |
| ( "D1", 0, 4, 0), | |
| ( "D2", 0, 5, 0), | |
| ( "D3", 0, 2, 0), | |
| ( "D4", 5, 9, 1), | |
| ( "D6", 7, 4, 1), | |
| ( "D7", 7, 5, 0), | |
| ( "E2", 0, 4, 1), | |
| ( "E6", 6, 0, 1), | |
| ( "E7", 7, 4, 0), | |
| ( "F1", 0, 2, 1), | |
| ( "F2", 0, 1, 0), | |
| ( "F3", 3, 0, 1), | |
| ( "F4", 4, 0, 0), | |
| ( "F5", 5, 0, 0), | |
| ( "F6", 6, 0, 0), | |
| ( "F7", 7, 3, 1), | |
| ( "G1", 0, 1, 1), | |
| ( "G3", 3, 0, 0), | |
| ( "G4", 4, 0, 1), | |
| ( "G6", 5, 0, 1), | |
| ], | |
| "5k-sg48": [ | |
| ( "2", 8, 0, 0), | |
| ( "3", 9, 0, 1), | |
| ( "4", 9, 0, 0), | |
| ( "6", 13, 0, 1), | |
| ( "9", 15, 0, 0), | |
| ( "10", 16, 0, 0), | |
| ( "11", 17, 0, 0), | |
| ( "12", 18, 0, 0), | |
| ( "13", 19, 0, 0), | |
| ( "14", 23, 0, 0), | |
| ( "15", 24, 0, 0), | |
| ( "16", 24, 0, 1), | |
| ( "17", 23, 0, 1), | |
| ( "18", 22, 0, 1), | |
| ( "19", 21, 0, 1), | |
| ( "20", 19, 0, 1), | |
| ( "21", 18, 0, 1), | |
| ( "23", 19, 31, 0), | |
| ( "25", 19, 31, 1), | |
| ( "26", 18, 31, 0), | |
| ( "27", 18, 31, 1), | |
| ( "28", 17, 31, 0), | |
| ( "31", 16, 31, 1), | |
| ( "32", 16, 31, 0), | |
| ( "34", 13, 31, 1), | |
| ( "35", 12, 31, 1), | |
| ( "36", 9, 31, 1), | |
| ( "37", 13, 31, 0), | |
| ( "38", 8, 31, 1), | |
| ( "39", 4, 31, 0), | |
| ( "40", 5, 31, 0), | |
| ( "41", 6, 31, 0), | |
| ( "42", 8, 31, 0), | |
| ( "43", 9, 31, 0), | |
| ( "44", 6, 0, 1), | |
| ( "45", 7, 0, 1), | |
| ( "46", 5, 0, 0), | |
| ( "47", 6, 0, 0), | |
| ( "48", 7, 0, 0), | |
| ], | |
| "u4k-sg48": [ | |
| ( "2", 8, 0, 0), | |
| ( "3", 9, 0, 1), | |
| ( "4", 9, 0, 0), | |
| ( "6", 13, 0, 1), | |
| ( "9", 15, 0, 0), | |
| ( "10", 16, 0, 0), | |
| ( "11", 17, 0, 0), | |
| ( "12", 18, 0, 0), | |
| ( "13", 19, 0, 0), | |
| ( "14", 23, 0, 0), | |
| ( "15", 24, 0, 0), | |
| ( "16", 24, 0, 1), | |
| ( "17", 23, 0, 1), | |
| ( "18", 22, 0, 1), | |
| ( "19", 21, 0, 1), | |
| ( "20", 19, 0, 1), | |
| ( "21", 18, 0, 1), | |
| ( "23", 19, 21, 0), | |
| ( "25", 19, 21, 1), | |
| ( "26", 18, 21, 0), | |
| ( "27", 18, 21, 1), | |
| ( "28", 17, 21, 0), | |
| ( "31", 16, 21, 1), | |
| ( "32", 16, 21, 0), | |
| ( "34", 13, 21, 1), | |
| ( "35", 12, 21, 1), | |
| ( "36", 9, 21, 1), | |
| ( "37", 13, 21, 0), | |
| ( "38", 8, 21, 1), | |
| ( "39", 6, 21, 0), | |
| ( "40", 5, 21, 0), | |
| ( "41", 4, 21, 0), | |
| ( "42", 8, 21, 0), | |
| ( "43", 9, 21, 0), | |
| ( "44", 6, 0, 1), | |
| ( "45", 7, 0, 1), | |
| ( "46", 5, 0, 0), | |
| ( "47", 6, 0, 0), | |
| ( "48", 7, 0, 0), | |
| ], | |
| "5k-uwg30": [ | |
| ( "A1", 19, 31, 1), | |
| ( "A2", 19, 31, 0), | |
| ( "A4", 12, 31, 0), | |
| ( "A5", 4, 31, 0), | |
| ( "B1", 19, 0, 0), | |
| ( "B3", 12, 31, 1), | |
| ( "B5", 5, 31, 0), | |
| ( "C1", 24, 0, 1), | |
| ( "C3", 12, 0, 0), | |
| ( "C5", 6, 31, 0), | |
| ( "D1", 24, 0, 0), | |
| ( "D3", 13, 0, 0), | |
| ( "D5", 6, 0, 0), | |
| ( "E1", 23, 0, 1), | |
| ( "E3", 13, 0, 1), | |
| ( "E4", 9, 0, 1), | |
| ( "E5", 5, 0, 0), | |
| ( "F1", 23, 0, 0), | |
| ( "F2", 19, 0, 1), | |
| ( "F4", 12, 0, 1), | |
| ( "F5", 6, 0, 1), | |
| ], | |
| "lm4k-cm49": [ | |
| ( "A1", 5, 21, 1), | |
| ( "A2", 6, 21, 0), | |
| ( "A3", 12, 21, 1), | |
| ( "A4", 13, 21, 0), | |
| ( "A5", 17, 21, 1), | |
| ( "A6", 19, 21, 1), | |
| ( "A7", 22, 21, 1), | |
| ( "B1", 4, 21, 1), | |
| ( "B2", 7, 21, 1), | |
| ( "B4", 15, 21, 0), | |
| ( "B6", 18, 21, 0), | |
| ( "B7", 23, 21, 1), | |
| ( "C1", 4, 21, 0), | |
| ( "C3", 9, 21, 0), | |
| ( "C4", 19, 21, 0), | |
| ( "C6", 21, 21, 1), | |
| ( "C7", 23, 21, 0), | |
| ( "D1", 7, 0, 1), | |
| ( "D2", 6, 0, 1), | |
| ( "D3", 10, 0, 0), | |
| ( "D6", 19, 0, 1), | |
| ( "D7", 21, 0, 0), | |
| ( "E1", 6, 0, 0), | |
| ( "E2", 12, 0, 1), | |
| ( "E3", 7, 0, 0), | |
| ( "E4", 12, 0, 0), | |
| ( "E5", 19, 0, 0), | |
| ( "E6", 24, 0, 1), | |
| ( "E7", 22, 0, 0), | |
| ( "F2", 8, 0, 1), | |
| ( "F3", 8, 0, 0), | |
| ( "F4", 13, 0, 1), | |
| ( "F5", 23, 0, 0), | |
| ( "F6", 24, 0, 0), | |
| ( "F7", 21, 0, 1), | |
| ( "G3", 13, 0, 0), | |
| ( "G6", 23, 0, 1), | |
| ], | |
| "lm4k-cm36": [ | |
| ( "A1", 5, 21, 1), | |
| ( "A2", 7, 21, 1), | |
| ( "A3", 9, 21, 1), | |
| ( "A4", 16, 21, 1), | |
| ( "A5", 19, 21, 1), | |
| ( "A6", 22, 21, 1), | |
| ( "B1", 4, 21, 1), | |
| ( "B2", 6, 21, 0), | |
| ( "B3", 12, 21, 1), | |
| ( "B4", 13, 21, 0), | |
| ( "B5", 21, 21, 1), | |
| ( "B6", 23, 21, 1), | |
| ( "C1", 7, 0, 1), | |
| ( "C5", 23, 21, 0), | |
| ( "C6", 23, 0, 0), | |
| ( "D1", 6, 0, 1), | |
| ( "D6", 24, 0, 0), | |
| ( "E1", 7, 0, 0), | |
| ( "E2", 13, 0, 0), | |
| ( "E3", 14, 0, 1), | |
| ( "E5", 22, 0, 1), | |
| ( "E6", 24, 0, 1), | |
| ( "F1", 6, 0, 0), | |
| ( "F2", 10, 0, 0), | |
| ( "F3", 12, 0, 1), | |
| ( "F4", 19, 0, 0), | |
| ( "F5", 22, 0, 0), | |
| ( "F6", 23, 0, 1), | |
| ], | |
| "lm4k-swg25tr": [ | |
| ( "A1", 22, 21, 1), | |
| ( "A3", 13, 21, 0), | |
| ( "A4", 12, 21, 1), | |
| ( "A5", 5, 21, 1), | |
| ( "B1", 21, 21, 1), | |
| ( "B5", 6, 21, 0), | |
| ( "C1", 23, 0, 1), | |
| ( "C2", 19, 21, 1), | |
| ( "C4", 13, 0, 0), | |
| ( "C5", 7, 0, 1), | |
| ( "D1", 24, 0, 0), | |
| ( "D2", 23, 0, 0), | |
| ( "D3", 19, 0, 0), | |
| ( "D5", 6, 0, 1), | |
| ( "E1", 24, 0, 1), | |
| ( "E3", 12, 0, 1), | |
| ( "E4", 7, 0, 0), | |
| ( "E5", 6, 0, 0), | |
| ] | |
| } | |
| # This database contains the locations of configuration bits of the DSP tiles | |
| # The standard configuration is stored under the key "default". If it is necessary to | |
| # override it for a certain DSP on a certain device use the key "{device}_{x}_{y}" where | |
| # {x} and {y} are the location of the DSP0 tile of the DSP (NOT the tile the cbit is in). | |
| # x and y are relative to the DSP0 tile. | |
| dsp_config_db = { | |
| "default" : { | |
| "C_REG": (0, 0, "CBIT_0"), | |
| "A_REG": (0, 0, "CBIT_1"), | |
| "B_REG": (0, 0, "CBIT_2"), | |
| "D_REG": (0, 0, "CBIT_3"), | |
| "TOP_8x8_MULT_REG": (0, 0, "CBIT_4"), | |
| "BOT_8x8_MULT_REG": (0, 0, "CBIT_5"), | |
| "PIPELINE_16x16_MULT_REG1": (0, 0, "CBIT_6"), | |
| "PIPELINE_16x16_MULT_REG2": (0, 0, "CBIT_7"), | |
| "TOPOUTPUT_SELECT_0": (0, 1, "CBIT_0"), | |
| "TOPOUTPUT_SELECT_1": (0, 1, "CBIT_1"), | |
| "TOPADDSUB_LOWERINPUT_0": (0, 1, "CBIT_2"), | |
| "TOPADDSUB_LOWERINPUT_1": (0, 1, "CBIT_3"), | |
| "TOPADDSUB_UPPERINPUT": (0, 1, "CBIT_4"), | |
| "TOPADDSUB_CARRYSELECT_0": (0, 1, "CBIT_5"), | |
| "TOPADDSUB_CARRYSELECT_1": (0, 1, "CBIT_6"), | |
| "BOTOUTPUT_SELECT_0": (0, 1, "CBIT_7"), | |
| "BOTOUTPUT_SELECT_1": (0, 2, "CBIT_0"), | |
| "BOTADDSUB_LOWERINPUT_0": (0, 2, "CBIT_1"), | |
| "BOTADDSUB_LOWERINPUT_1": (0, 2, "CBIT_2"), | |
| "BOTADDSUB_UPPERINPUT": (0, 2, "CBIT_3"), | |
| "BOTADDSUB_CARRYSELECT_0": (0, 2, "CBIT_4"), | |
| "BOTADDSUB_CARRYSELECT_1": (0, 2, "CBIT_5"), | |
| "MODE_8x8": (0, 2, "CBIT_6"), | |
| "A_SIGNED": (0, 2, "CBIT_7"), | |
| "B_SIGNED": (0, 3, "CBIT_0") | |
| }, | |
| "5k_0_15": { | |
| "TOPOUTPUT_SELECT_1": (0, 4, "CBIT_3"), | |
| "TOPADDSUB_LOWERINPUT_0": (0, 4, "CBIT_4"), | |
| "TOPADDSUB_LOWERINPUT_1": (0, 4, "CBIT_5"), | |
| "TOPADDSUB_UPPERINPUT": (0, 4, "CBIT_6") | |
| } | |
| } | |
| # SPRAM data for UltraPlus devices, use icefuzz/tests/fuzz_spram.py | |
| # to generate this | |
| spram_db = { | |
| "5k" : { | |
| (0, 0, 1): { | |
| "ADDRESS_0": (0, 2, "lutff_0/in_1"), | |
| "ADDRESS_10": (0, 2, "lutff_2/in_0"), | |
| "ADDRESS_11": (0, 2, "lutff_3/in_0"), | |
| "ADDRESS_12": (0, 2, "lutff_4/in_0"), | |
| "ADDRESS_13": (0, 2, "lutff_5/in_0"), | |
| "ADDRESS_1": (0, 2, "lutff_1/in_1"), | |
| "ADDRESS_2": (0, 2, "lutff_2/in_1"), | |
| "ADDRESS_3": (0, 2, "lutff_3/in_1"), | |
| "ADDRESS_4": (0, 2, "lutff_4/in_1"), | |
| "ADDRESS_5": (0, 2, "lutff_5/in_1"), | |
| "ADDRESS_6": (0, 2, "lutff_6/in_1"), | |
| "ADDRESS_7": (0, 2, "lutff_7/in_1"), | |
| "ADDRESS_8": (0, 2, "lutff_0/in_0"), | |
| "ADDRESS_9": (0, 2, "lutff_1/in_0"), | |
| "CHIPSELECT": (0, 3, "lutff_6/in_1"), | |
| "CLOCK": (0, 1, "clk"), | |
| "DATAIN_0": (0, 1, "lutff_0/in_3"), | |
| "DATAIN_10": (0, 1, "lutff_2/in_1"), | |
| "DATAIN_11": (0, 1, "lutff_3/in_1"), | |
| "DATAIN_12": (0, 1, "lutff_4/in_1"), | |
| "DATAIN_13": (0, 1, "lutff_5/in_1"), | |
| "DATAIN_14": (0, 1, "lutff_6/in_1"), | |
| "DATAIN_15": (0, 1, "lutff_7/in_1"), | |
| "DATAIN_1": (0, 1, "lutff_1/in_3"), | |
| "DATAIN_2": (0, 1, "lutff_2/in_3"), | |
| "DATAIN_3": (0, 1, "lutff_3/in_3"), | |
| "DATAIN_4": (0, 1, "lutff_4/in_3"), | |
| "DATAIN_5": (0, 1, "lutff_5/in_3"), | |
| "DATAIN_6": (0, 1, "lutff_6/in_3"), | |
| "DATAIN_7": (0, 1, "lutff_7/in_3"), | |
| "DATAIN_8": (0, 1, "lutff_0/in_1"), | |
| "DATAIN_9": (0, 1, "lutff_1/in_1"), | |
| "DATAOUT_0": (0, 1, "slf_op_0"), | |
| "DATAOUT_10": (0, 2, "slf_op_2"), | |
| "DATAOUT_11": (0, 2, "slf_op_3"), | |
| "DATAOUT_12": (0, 2, "slf_op_4"), | |
| "DATAOUT_13": (0, 2, "slf_op_5"), | |
| "DATAOUT_14": (0, 2, "slf_op_6"), | |
| "DATAOUT_15": (0, 2, "slf_op_7"), | |
| "DATAOUT_1": (0, 1, "slf_op_1"), | |
| "DATAOUT_2": (0, 1, "slf_op_2"), | |
| "DATAOUT_3": (0, 1, "slf_op_3"), | |
| "DATAOUT_4": (0, 1, "slf_op_4"), | |
| "DATAOUT_5": (0, 1, "slf_op_5"), | |
| "DATAOUT_6": (0, 1, "slf_op_6"), | |
| "DATAOUT_7": (0, 1, "slf_op_7"), | |
| "DATAOUT_8": (0, 2, "slf_op_0"), | |
| "DATAOUT_9": (0, 2, "slf_op_1"), | |
| "MASKWREN_0": (0, 3, "lutff_0/in_0"), | |
| "MASKWREN_1": (0, 3, "lutff_1/in_0"), | |
| "MASKWREN_2": (0, 3, "lutff_2/in_0"), | |
| "MASKWREN_3": (0, 3, "lutff_3/in_0"), | |
| "POWEROFF": (0, 4, "lutff_4/in_3"), | |
| "SLEEP": (0, 4, "lutff_2/in_3"), | |
| "SPRAM_EN": (0, 1, "CBIT_0"), | |
| "STANDBY": (0, 4, "lutff_0/in_3"), | |
| "WREN": (0, 3, "lutff_4/in_1"), | |
| }, | |
| (0, 0, 2): { | |
| "ADDRESS_0": (0, 2, "lutff_6/in_0"), | |
| "ADDRESS_10": (0, 3, "lutff_0/in_1"), | |
| "ADDRESS_11": (0, 3, "lutff_1/in_1"), | |
| "ADDRESS_12": (0, 3, "lutff_2/in_1"), | |
| "ADDRESS_13": (0, 3, "lutff_3/in_1"), | |
| "ADDRESS_1": (0, 2, "lutff_7/in_0"), | |
| "ADDRESS_2": (0, 3, "lutff_0/in_3"), | |
| "ADDRESS_3": (0, 3, "lutff_1/in_3"), | |
| "ADDRESS_4": (0, 3, "lutff_2/in_3"), | |
| "ADDRESS_5": (0, 3, "lutff_3/in_3"), | |
| "ADDRESS_6": (0, 3, "lutff_4/in_3"), | |
| "ADDRESS_7": (0, 3, "lutff_5/in_3"), | |
| "ADDRESS_8": (0, 3, "lutff_6/in_3"), | |
| "ADDRESS_9": (0, 3, "lutff_7/in_3"), | |
| "CHIPSELECT": (0, 3, "lutff_7/in_1"), | |
| "CLOCK": (0, 2, "clk"), | |
| "DATAIN_0": (0, 1, "lutff_0/in_0"), | |
| "DATAIN_10": (0, 2, "lutff_2/in_3"), | |
| "DATAIN_11": (0, 2, "lutff_3/in_3"), | |
| "DATAIN_12": (0, 2, "lutff_4/in_3"), | |
| "DATAIN_13": (0, 2, "lutff_5/in_3"), | |
| "DATAIN_14": (0, 2, "lutff_6/in_3"), | |
| "DATAIN_15": (0, 2, "lutff_7/in_3"), | |
| "DATAIN_1": (0, 1, "lutff_1/in_0"), | |
| "DATAIN_2": (0, 1, "lutff_2/in_0"), | |
| "DATAIN_3": (0, 1, "lutff_3/in_0"), | |
| "DATAIN_4": (0, 1, "lutff_4/in_0"), | |
| "DATAIN_5": (0, 1, "lutff_5/in_0"), | |
| "DATAIN_6": (0, 1, "lutff_6/in_0"), | |
| "DATAIN_7": (0, 1, "lutff_7/in_0"), | |
| "DATAIN_8": (0, 2, "lutff_0/in_3"), | |
| "DATAIN_9": (0, 2, "lutff_1/in_3"), | |
| "DATAOUT_0": (0, 3, "slf_op_0"), | |
| "DATAOUT_10": (0, 4, "slf_op_2"), | |
| "DATAOUT_11": (0, 4, "slf_op_3"), | |
| "DATAOUT_12": (0, 4, "slf_op_4"), | |
| "DATAOUT_13": (0, 4, "slf_op_5"), | |
| "DATAOUT_14": (0, 4, "slf_op_6"), | |
| "DATAOUT_15": (0, 4, "slf_op_7"), | |
| "DATAOUT_1": (0, 3, "slf_op_1"), | |
| "DATAOUT_2": (0, 3, "slf_op_2"), | |
| "DATAOUT_3": (0, 3, "slf_op_3"), | |
| "DATAOUT_4": (0, 3, "slf_op_4"), | |
| "DATAOUT_5": (0, 3, "slf_op_5"), | |
| "DATAOUT_6": (0, 3, "slf_op_6"), | |
| "DATAOUT_7": (0, 3, "slf_op_7"), | |
| "DATAOUT_8": (0, 4, "slf_op_0"), | |
| "DATAOUT_9": (0, 4, "slf_op_1"), | |
| "MASKWREN_0": (0, 3, "lutff_4/in_0"), | |
| "MASKWREN_1": (0, 3, "lutff_5/in_0"), | |
| "MASKWREN_2": (0, 3, "lutff_6/in_0"), | |
| "MASKWREN_3": (0, 3, "lutff_7/in_0"), | |
| "POWEROFF": (0, 4, "lutff_5/in_3"), | |
| "SLEEP": (0, 4, "lutff_3/in_3"), | |
| "SPRAM_EN": (0, 1, "CBIT_1"), | |
| "STANDBY": (0, 4, "lutff_1/in_3"), | |
| "WREN": (0, 3, "lutff_5/in_1"), | |
| }, | |
| (25, 0, 3): { | |
| "ADDRESS_0": (25, 2, "lutff_0/in_1"), | |
| "ADDRESS_10": (25, 2, "lutff_2/in_0"), | |
| "ADDRESS_11": (25, 2, "lutff_3/in_0"), | |
| "ADDRESS_12": (25, 2, "lutff_4/in_0"), | |
| "ADDRESS_13": (25, 2, "lutff_5/in_0"), | |
| "ADDRESS_1": (25, 2, "lutff_1/in_1"), | |
| "ADDRESS_2": (25, 2, "lutff_2/in_1"), | |
| "ADDRESS_3": (25, 2, "lutff_3/in_1"), | |
| "ADDRESS_4": (25, 2, "lutff_4/in_1"), | |
| "ADDRESS_5": (25, 2, "lutff_5/in_1"), | |
| "ADDRESS_6": (25, 2, "lutff_6/in_1"), | |
| "ADDRESS_7": (25, 2, "lutff_7/in_1"), | |
| "ADDRESS_8": (25, 2, "lutff_0/in_0"), | |
| "ADDRESS_9": (25, 2, "lutff_1/in_0"), | |
| "CHIPSELECT": (25, 3, "lutff_6/in_1"), | |
| "CLOCK": (25, 1, "clk"), | |
| "DATAIN_0": (25, 1, "lutff_0/in_3"), | |
| "DATAIN_10": (25, 1, "lutff_2/in_1"), | |
| "DATAIN_11": (25, 1, "lutff_3/in_1"), | |
| "DATAIN_12": (25, 1, "lutff_4/in_1"), | |
| "DATAIN_13": (25, 1, "lutff_5/in_1"), | |
| "DATAIN_14": (25, 1, "lutff_6/in_1"), | |
| "DATAIN_15": (25, 1, "lutff_7/in_1"), | |
| "DATAIN_1": (25, 1, "lutff_1/in_3"), | |
| "DATAIN_2": (25, 1, "lutff_2/in_3"), | |
| "DATAIN_3": (25, 1, "lutff_3/in_3"), | |
| "DATAIN_4": (25, 1, "lutff_4/in_3"), | |
| "DATAIN_5": (25, 1, "lutff_5/in_3"), | |
| "DATAIN_6": (25, 1, "lutff_6/in_3"), | |
| "DATAIN_7": (25, 1, "lutff_7/in_3"), | |
| "DATAIN_8": (25, 1, "lutff_0/in_1"), | |
| "DATAIN_9": (25, 1, "lutff_1/in_1"), | |
| "DATAOUT_0": (25, 1, "slf_op_0"), | |
| "DATAOUT_10": (25, 2, "slf_op_2"), | |
| "DATAOUT_11": (25, 2, "slf_op_3"), | |
| "DATAOUT_12": (25, 2, "slf_op_4"), | |
| "DATAOUT_13": (25, 2, "slf_op_5"), | |
| "DATAOUT_14": (25, 2, "slf_op_6"), | |
| "DATAOUT_15": (25, 2, "slf_op_7"), | |
| "DATAOUT_1": (25, 1, "slf_op_1"), | |
| "DATAOUT_2": (25, 1, "slf_op_2"), | |
| "DATAOUT_3": (25, 1, "slf_op_3"), | |
| "DATAOUT_4": (25, 1, "slf_op_4"), | |
| "DATAOUT_5": (25, 1, "slf_op_5"), | |
| "DATAOUT_6": (25, 1, "slf_op_6"), | |
| "DATAOUT_7": (25, 1, "slf_op_7"), | |
| "DATAOUT_8": (25, 2, "slf_op_0"), | |
| "DATAOUT_9": (25, 2, "slf_op_1"), | |
| "MASKWREN_0": (25, 3, "lutff_0/in_0"), | |
| "MASKWREN_1": (25, 3, "lutff_1/in_0"), | |
| "MASKWREN_2": (25, 3, "lutff_2/in_0"), | |
| "MASKWREN_3": (25, 3, "lutff_3/in_0"), | |
| "POWEROFF": (25, 4, "lutff_4/in_3"), | |
| "SLEEP": (25, 4, "lutff_2/in_3"), | |
| "SPRAM_EN": (25, 1, "CBIT_0"), | |
| "STANDBY": (25, 4, "lutff_0/in_3"), | |
| "WREN": (25, 3, "lutff_4/in_1"), | |
| }, | |
| (25, 0, 4): { | |
| "ADDRESS_0": (25, 2, "lutff_6/in_0"), | |
| "ADDRESS_10": (25, 3, "lutff_0/in_1"), | |
| "ADDRESS_11": (25, 3, "lutff_1/in_1"), | |
| "ADDRESS_12": (25, 3, "lutff_2/in_1"), | |
| "ADDRESS_13": (25, 3, "lutff_3/in_1"), | |
| "ADDRESS_1": (25, 2, "lutff_7/in_0"), | |
| "ADDRESS_2": (25, 3, "lutff_0/in_3"), | |
| "ADDRESS_3": (25, 3, "lutff_1/in_3"), | |
| "ADDRESS_4": (25, 3, "lutff_2/in_3"), | |
| "ADDRESS_5": (25, 3, "lutff_3/in_3"), | |
| "ADDRESS_6": (25, 3, "lutff_4/in_3"), | |
| "ADDRESS_7": (25, 3, "lutff_5/in_3"), | |
| "ADDRESS_8": (25, 3, "lutff_6/in_3"), | |
| "ADDRESS_9": (25, 3, "lutff_7/in_3"), | |
| "CHIPSELECT": (25, 3, "lutff_7/in_1"), | |
| "CLOCK": (25, 2, "clk"), | |
| "DATAIN_0": (25, 1, "lutff_0/in_0"), | |
| "DATAIN_10": (25, 2, "lutff_2/in_3"), | |
| "DATAIN_11": (25, 2, "lutff_3/in_3"), | |
| "DATAIN_12": (25, 2, "lutff_4/in_3"), | |
| "DATAIN_13": (25, 2, "lutff_5/in_3"), | |
| "DATAIN_14": (25, 2, "lutff_6/in_3"), | |
| "DATAIN_15": (25, 2, "lutff_7/in_3"), | |
| "DATAIN_1": (25, 1, "lutff_1/in_0"), | |
| "DATAIN_2": (25, 1, "lutff_2/in_0"), | |
| "DATAIN_3": (25, 1, "lutff_3/in_0"), | |
| "DATAIN_4": (25, 1, "lutff_4/in_0"), | |
| "DATAIN_5": (25, 1, "lutff_5/in_0"), | |
| "DATAIN_6": (25, 1, "lutff_6/in_0"), | |
| "DATAIN_7": (25, 1, "lutff_7/in_0"), | |
| "DATAIN_8": (25, 2, "lutff_0/in_3"), | |
| "DATAIN_9": (25, 2, "lutff_1/in_3"), | |
| "DATAOUT_0": (25, 3, "slf_op_0"), | |
| "DATAOUT_10": (25, 4, "slf_op_2"), | |
| "DATAOUT_11": (25, 4, "slf_op_3"), | |
| "DATAOUT_12": (25, 4, "slf_op_4"), | |
| "DATAOUT_13": (25, 4, "slf_op_5"), | |
| "DATAOUT_14": (25, 4, "slf_op_6"), | |
| "DATAOUT_15": (25, 4, "slf_op_7"), | |
| "DATAOUT_1": (25, 3, "slf_op_1"), | |
| "DATAOUT_2": (25, 3, "slf_op_2"), | |
| "DATAOUT_3": (25, 3, "slf_op_3"), | |
| "DATAOUT_4": (25, 3, "slf_op_4"), | |
| "DATAOUT_5": (25, 3, "slf_op_5"), | |
| "DATAOUT_6": (25, 3, "slf_op_6"), | |
| "DATAOUT_7": (25, 3, "slf_op_7"), | |
| "DATAOUT_8": (25, 4, "slf_op_0"), | |
| "DATAOUT_9": (25, 4, "slf_op_1"), | |
| "MASKWREN_0": (25, 3, "lutff_4/in_0"), | |
| "MASKWREN_1": (25, 3, "lutff_5/in_0"), | |
| "MASKWREN_2": (25, 3, "lutff_6/in_0"), | |
| "MASKWREN_3": (25, 3, "lutff_7/in_0"), | |
| "POWEROFF": (25, 4, "lutff_5/in_3"), | |
| "SLEEP": (25, 4, "lutff_3/in_3"), | |
| "SPRAM_EN": (25, 1, "CBIT_1"), | |
| "STANDBY": (25, 4, "lutff_1/in_3"), | |
| "WREN": (25, 3, "lutff_5/in_1"), | |
| } | |
| } | |
| } | |
| # This contains the data for extra cells not included | |
| # in any previous databases | |
| extra_cells_db = { | |
| "5k" : { | |
| ("HFOSC", (0, 31, 1)) : { | |
| "CLKHFPU": (0, 29, "lutff_0/in_1"), | |
| "CLKHFEN": (0, 29, "lutff_7/in_3"), | |
| "CLKHF": (0, 29, "glb_netwk_4"), | |
| "CLKHF_FABRIC": (0, 28, "slf_op_7"), | |
| "TRIM0": (25, 28, "lutff_4/in_0"), | |
| "TRIM1": (25, 28, "lutff_5/in_0"), | |
| "TRIM2": (25, 28, "lutff_6/in_0"), | |
| "TRIM3": (25, 28, "lutff_7/in_0"), | |
| "TRIM4": (25, 29, "lutff_0/in_3"), | |
| "TRIM5": (25, 29, "lutff_1/in_3"), | |
| "TRIM6": (25, 29, "lutff_2/in_3"), | |
| "TRIM7": (25, 29, "lutff_3/in_3"), | |
| "TRIM8": (25, 29, "lutff_4/in_3"), | |
| "TRIM9": (25, 29, "lutff_5/in_3"), | |
| "CLKHF_DIV_1": (0, 16, "CBIT_4"), | |
| "CLKHF_DIV_0": (0, 16, "CBIT_3"), | |
| "TRIM_EN": (0, 16, "CBIT_5") | |
| }, | |
| ("LFOSC", (25, 31, 1)) : { | |
| "CLKLFPU": (25, 29, "lutff_0/in_1"), | |
| "CLKLFEN": (25, 29, "lutff_7/in_3"), | |
| "CLKLF": (25, 29, "glb_netwk_5"), | |
| "CLKLF_FABRIC": (25, 29, "slf_op_0") | |
| }, | |
| ("RGBA_DRV", (0, 30, 0)) : { | |
| "CURREN": (25, 29, "lutff_6/in_3"), | |
| "RGBLEDEN": (0, 30, "lutff_1/in_1"), | |
| "RGB0PWM": (0, 30, "lutff_2/in_1"), | |
| "RGB1PWM": (0, 30, "lutff_3/in_1"), | |
| "RGB2PWM": (0, 30, "lutff_4/in_1"), | |
| "RGBA_DRV_EN": (0, 28, "CBIT_5"), | |
| "RGB0_CURRENT_0": (0, 28, "CBIT_6"), | |
| "RGB0_CURRENT_1": (0, 28, "CBIT_7"), | |
| "RGB0_CURRENT_2": (0, 29, "CBIT_0"), | |
| "RGB0_CURRENT_3": (0, 29, "CBIT_1"), | |
| "RGB0_CURRENT_4": (0, 29, "CBIT_2"), | |
| "RGB0_CURRENT_5": (0, 29, "CBIT_3"), | |
| "RGB1_CURRENT_0": (0, 29, "CBIT_4"), | |
| "RGB1_CURRENT_1": (0, 29, "CBIT_5"), | |
| "RGB1_CURRENT_2": (0, 29, "CBIT_6"), | |
| "RGB1_CURRENT_3": (0, 29, "CBIT_7"), | |
| "RGB1_CURRENT_4": (0, 30, "CBIT_0"), | |
| "RGB1_CURRENT_5": (0, 30, "CBIT_1"), | |
| "RGB2_CURRENT_0": (0, 30, "CBIT_2"), | |
| "RGB2_CURRENT_1": (0, 30, "CBIT_3"), | |
| "RGB2_CURRENT_2": (0, 30, "CBIT_4"), | |
| "RGB2_CURRENT_3": (0, 30, "CBIT_5"), | |
| "RGB2_CURRENT_4": (0, 30, "CBIT_6"), | |
| "RGB2_CURRENT_5": (0, 30, "CBIT_7"), | |
| "CURRENT_MODE": (0, 28, "CBIT_4"), | |
| "RGB0": (4, 31, 0), | |
| "RGB1": (5, 31, 0), | |
| "RGB2": (6, 31, 0), | |
| }, | |
| ("I2C", (0, 31, 0)): { | |
| "I2CIRQ": (0, 30, "slf_op_7"), | |
| "I2CWKUP": (0, 29, "slf_op_5"), | |
| "I2C_ENABLE_0": (13, 31, "cbit2usealt_in_0"), | |
| "I2C_ENABLE_1": (12, 31, "cbit2usealt_in_1"), | |
| "SBACKO": (0, 30, "slf_op_6"), | |
| "SBADRI0": (0, 30, "lutff_1/in_0"), | |
| "SBADRI1": (0, 30, "lutff_2/in_0"), | |
| "SBADRI2": (0, 30, "lutff_3/in_0"), | |
| "SBADRI3": (0, 30, "lutff_4/in_0"), | |
| "SBADRI4": (0, 30, "lutff_5/in_0"), | |
| "SBADRI5": (0, 30, "lutff_6/in_0"), | |
| "SBADRI6": (0, 30, "lutff_7/in_0"), | |
| "SBADRI7": (0, 29, "lutff_2/in_0"), | |
| "SBCLKI": (0, 30, "clk"), | |
| "SBDATI0": (0, 29, "lutff_5/in_0"), | |
| "SBDATI1": (0, 29, "lutff_6/in_0"), | |
| "SBDATI2": (0, 29, "lutff_7/in_0"), | |
| "SBDATI3": (0, 30, "lutff_0/in_3"), | |
| "SBDATI4": (0, 30, "lutff_5/in_1"), | |
| "SBDATI5": (0, 30, "lutff_6/in_1"), | |
| "SBDATI6": (0, 30, "lutff_7/in_1"), | |
| "SBDATI7": (0, 30, "lutff_0/in_0"), | |
| "SBDATO0": (0, 29, "slf_op_6"), | |
| "SBDATO1": (0, 29, "slf_op_7"), | |
| "SBDATO2": (0, 30, "slf_op_0"), | |
| "SBDATO3": (0, 30, "slf_op_1"), | |
| "SBDATO4": (0, 30, "slf_op_2"), | |
| "SBDATO5": (0, 30, "slf_op_3"), | |
| "SBDATO6": (0, 30, "slf_op_4"), | |
| "SBDATO7": (0, 30, "slf_op_5"), | |
| "SBRWI": (0, 29, "lutff_4/in_0"), | |
| "SBSTBI": (0, 29, "lutff_3/in_0"), | |
| "SCLI": (0, 29, "lutff_2/in_1"), | |
| "SCLO": (0, 29, "slf_op_3"), | |
| "SCLOE": (0, 29, "slf_op_4"), | |
| "SDAI": (0, 29, "lutff_1/in_1"), | |
| "SDAO": (0, 29, "slf_op_1"), | |
| "SDAOE": (0, 29, "slf_op_2"), | |
| "SDA_INPUT_DELAYED": (12, 31, "SDA_input_delay"), | |
| "SDA_OUTPUT_DELAYED": (12, 31, "SDA_output_delay"), | |
| }, | |
| ("I2C", (25, 31, 0)): { | |
| "I2CIRQ": (25, 30, "slf_op_7"), | |
| "I2CWKUP": (25, 29, "slf_op_5"), | |
| "I2C_ENABLE_0": (19, 31, "cbit2usealt_in_0"), | |
| "I2C_ENABLE_1": (19, 31, "cbit2usealt_in_1"), | |
| "SBACKO": (25, 30, "slf_op_6"), | |
| "SBADRI0": (25, 30, "lutff_1/in_0"), | |
| "SBADRI1": (25, 30, "lutff_2/in_0"), | |
| "SBADRI2": (25, 30, "lutff_3/in_0"), | |
| "SBADRI3": (25, 30, "lutff_4/in_0"), | |
| "SBADRI4": (25, 30, "lutff_5/in_0"), | |
| "SBADRI5": (25, 30, "lutff_6/in_0"), | |
| "SBADRI6": (25, 30, "lutff_7/in_0"), | |
| "SBADRI7": (25, 29, "lutff_2/in_0"), | |
| "SBCLKI": (25, 30, "clk"), | |
| "SBDATI0": (25, 29, "lutff_5/in_0"), | |
| "SBDATI1": (25, 29, "lutff_6/in_0"), | |
| "SBDATI2": (25, 29, "lutff_7/in_0"), | |
| "SBDATI3": (25, 30, "lutff_0/in_3"), | |
| "SBDATI4": (25, 30, "lutff_5/in_1"), | |
| "SBDATI5": (25, 30, "lutff_6/in_1"), | |
| "SBDATI6": (25, 30, "lutff_7/in_1"), | |
| "SBDATI7": (25, 30, "lutff_0/in_0"), | |
| "SBDATO0": (25, 29, "slf_op_6"), | |
| "SBDATO1": (25, 29, "slf_op_7"), | |
| "SBDATO2": (25, 30, "slf_op_0"), | |
| "SBDATO3": (25, 30, "slf_op_1"), | |
| "SBDATO4": (25, 30, "slf_op_2"), | |
| "SBDATO5": (25, 30, "slf_op_3"), | |
| "SBDATO6": (25, 30, "slf_op_4"), | |
| "SBDATO7": (25, 30, "slf_op_5"), | |
| "SBRWI": (25, 29, "lutff_4/in_0"), | |
| "SBSTBI": (25, 29, "lutff_3/in_0"), | |
| "SCLI": (25, 29, "lutff_2/in_1"), | |
| "SCLO": (25, 29, "slf_op_3"), | |
| "SCLOE": (25, 29, "slf_op_4"), | |
| "SDAI": (25, 29, "lutff_1/in_1"), | |
| "SDAO": (25, 29, "slf_op_1"), | |
| "SDAOE": (25, 29, "slf_op_2"), | |
| "SDA_INPUT_DELAYED": (19, 31, "SDA_input_delay"), | |
| "SDA_OUTPUT_DELAYED": (19, 31, "SDA_output_delay"), | |
| }, | |
| ("SPI", (0, 0, 0)): { | |
| "MCSNO0": (0, 21, "slf_op_2"), | |
| "MCSNO1": (0, 21, "slf_op_4"), | |
| "MCSNO2": (0, 21, "slf_op_7"), | |
| "MCSNO3": (0, 22, "slf_op_1"), | |
| "MCSNOE0": (0, 21, "slf_op_3"), | |
| "MCSNOE1": (0, 21, "slf_op_5"), | |
| "MCSNOE2": (0, 22, "slf_op_0"), | |
| "MCSNOE3": (0, 22, "slf_op_2"), | |
| "MI": (0, 22, "lutff_0/in_1"), | |
| "MO": (0, 20, "slf_op_6"), | |
| "MOE": (0, 20, "slf_op_7"), | |
| "SBACKO": (0, 20, "slf_op_1"), | |
| "SBADRI0": (0, 19, "lutff_1/in_1"), | |
| "SBADRI1": (0, 19, "lutff_2/in_1"), | |
| "SBADRI2": (0, 20, "lutff_0/in_3"), | |
| "SBADRI3": (0, 20, "lutff_1/in_3"), | |
| "SBADRI4": (0, 20, "lutff_2/in_3"), | |
| "SBADRI5": (0, 20, "lutff_3/in_3"), | |
| "SBADRI6": (0, 20, "lutff_4/in_3"), | |
| "SBADRI7": (0, 20, "lutff_5/in_3"), | |
| "SBCLKI": (0, 20, "clk"), | |
| "SBDATI0": (0, 19, "lutff_1/in_3"), | |
| "SBDATI1": (0, 19, "lutff_2/in_3"), | |
| "SBDATI2": (0, 19, "lutff_3/in_3"), | |
| "SBDATI3": (0, 19, "lutff_4/in_3"), | |
| "SBDATI4": (0, 19, "lutff_5/in_3"), | |
| "SBDATI5": (0, 19, "lutff_6/in_3"), | |
| "SBDATI6": (0, 19, "lutff_7/in_3"), | |
| "SBDATI7": (0, 19, "lutff_0/in_1"), | |
| "SBDATO0": (0, 19, "slf_op_1"), | |
| "SBDATO1": (0, 19, "slf_op_2"), | |
| "SBDATO2": (0, 19, "slf_op_3"), | |
| "SBDATO3": (0, 19, "slf_op_4"), | |
| "SBDATO4": (0, 19, "slf_op_5"), | |
| "SBDATO5": (0, 19, "slf_op_6"), | |
| "SBDATO6": (0, 19, "slf_op_7"), | |
| "SBDATO7": (0, 20, "slf_op_0"), | |
| "SBRWI": (0, 19, "lutff_0/in_3"), | |
| "SBSTBI": (0, 20, "lutff_6/in_3"), | |
| "SCKI": (0, 22, "lutff_1/in_1"), | |
| "SCKO": (0, 21, "slf_op_0"), | |
| "SCKOE": (0, 21, "slf_op_1"), | |
| "SCSNI": (0, 22, "lutff_2/in_1"), | |
| "SI": (0, 22, "lutff_7/in_3"), | |
| "SO": (0, 20, "slf_op_4"), | |
| "SOE": (0, 20, "slf_op_5"), | |
| "SPIIRQ": (0, 20, "slf_op_2"), | |
| "SPIWKUP": (0, 20, "slf_op_3"), | |
| "SPI_ENABLE_0": (7, 0, "cbit2usealt_in_0"), | |
| "SPI_ENABLE_1": (7, 0, "cbit2usealt_in_1"), | |
| "SPI_ENABLE_2": (6, 0, "cbit2usealt_in_0"), | |
| "SPI_ENABLE_3": (6, 0, "cbit2usealt_in_1"), | |
| }, | |
| ("SPI", (25, 0, 1)): { | |
| "MCSNO0": (25, 21, "slf_op_2"), | |
| "MCSNO1": (25, 21, "slf_op_4"), | |
| "MCSNO2": (25, 21, "slf_op_7"), | |
| "MCSNO3": (25, 22, "slf_op_1"), | |
| "MCSNOE0": (25, 21, "slf_op_3"), | |
| "MCSNOE1": (25, 21, "slf_op_5"), | |
| "MCSNOE2": (25, 22, "slf_op_0"), | |
| "MCSNOE3": (25, 22, "slf_op_2"), | |
| "MI": (25, 22, "lutff_0/in_1"), | |
| "MO": (25, 20, "slf_op_6"), | |
| "MOE": (25, 20, "slf_op_7"), | |
| "SBACKO": (25, 20, "slf_op_1"), | |
| "SBADRI0": (25, 19, "lutff_1/in_1"), | |
| "SBADRI1": (25, 19, "lutff_2/in_1"), | |
| "SBADRI2": (25, 20, "lutff_0/in_3"), | |
| "SBADRI3": (25, 20, "lutff_1/in_3"), | |
| "SBADRI4": (25, 20, "lutff_2/in_3"), | |
| "SBADRI5": (25, 20, "lutff_3/in_3"), | |
| "SBADRI6": (25, 20, "lutff_4/in_3"), | |
| "SBADRI7": (25, 20, "lutff_5/in_3"), | |
| "SBCLKI": (25, 20, "clk"), | |
| "SBDATI0": (25, 19, "lutff_1/in_3"), | |
| "SBDATI1": (25, 19, "lutff_2/in_3"), | |
| "SBDATI2": (25, 19, "lutff_3/in_3"), | |
| "SBDATI3": (25, 19, "lutff_4/in_3"), | |
| "SBDATI4": (25, 19, "lutff_5/in_3"), | |
| "SBDATI5": (25, 19, "lutff_6/in_3"), | |
| "SBDATI6": (25, 19, "lutff_7/in_3"), | |
| "SBDATI7": (25, 19, "lutff_0/in_1"), | |
| "SBDATO0": (25, 19, "slf_op_1"), | |
| "SBDATO1": (25, 19, "slf_op_2"), | |
| "SBDATO2": (25, 19, "slf_op_3"), | |
| "SBDATO3": (25, 19, "slf_op_4"), | |
| "SBDATO4": (25, 19, "slf_op_5"), | |
| "SBDATO5": (25, 19, "slf_op_6"), | |
| "SBDATO6": (25, 19, "slf_op_7"), | |
| "SBDATO7": (25, 20, "slf_op_0"), | |
| "SBRWI": (25, 19, "lutff_0/in_3"), | |
| "SBSTBI": (25, 20, "lutff_6/in_3"), | |
| "SCKI": (25, 22, "lutff_1/in_1"), | |
| "SCKO": (25, 21, "slf_op_0"), | |
| "SCKOE": (25, 21, "slf_op_1"), | |
| "SCSNI": (25, 22, "lutff_2/in_1"), | |
| "SI": (25, 22, "lutff_7/in_3"), | |
| "SO": (25, 20, "slf_op_4"), | |
| "SOE": (25, 20, "slf_op_5"), | |
| "SPIIRQ": (25, 20, "slf_op_2"), | |
| "SPIWKUP": (25, 20, "slf_op_3"), | |
| "SPI_ENABLE_0": (23, 0, "cbit2usealt_in_0"), | |
| "SPI_ENABLE_1": (24, 0, "cbit2usealt_in_0"), | |
| "SPI_ENABLE_2": (23, 0, "cbit2usealt_in_1"), | |
| "SPI_ENABLE_3": (24, 0, "cbit2usealt_in_1"), | |
| }, | |
| ("LEDDA_IP", (0, 31, 2)): { | |
| "LEDDADDR0": (0, 28, "lutff_4/in_0"), | |
| "LEDDADDR1": (0, 28, "lutff_5/in_0"), | |
| "LEDDADDR2": (0, 28, "lutff_6/in_0"), | |
| "LEDDADDR3": (0, 28, "lutff_7/in_0"), | |
| "LEDDCLK": (0, 29, "clk"), | |
| "LEDDCS": (0, 28, "lutff_2/in_0"), | |
| "LEDDDAT0": (0, 28, "lutff_2/in_1"), | |
| "LEDDDAT1": (0, 28, "lutff_3/in_1"), | |
| "LEDDDAT2": (0, 28, "lutff_4/in_1"), | |
| "LEDDDAT3": (0, 28, "lutff_5/in_1"), | |
| "LEDDDAT4": (0, 28, "lutff_6/in_1"), | |
| "LEDDDAT5": (0, 28, "lutff_7/in_1"), | |
| "LEDDDAT6": (0, 28, "lutff_0/in_0"), | |
| "LEDDDAT7": (0, 28, "lutff_1/in_0"), | |
| "LEDDDEN": (0, 28, "lutff_1/in_1"), | |
| "LEDDEXE": (0, 28, "lutff_0/in_1"), | |
| "LEDDON": (0, 29, "slf_op_0"), | |
| "PWMOUT0": (0, 28, "slf_op_4"), | |
| "PWMOUT1": (0, 28, "slf_op_5"), | |
| "PWMOUT2": (0, 28, "slf_op_6"), | |
| }, | |
| ("IO_I3C", (25, 27, 0)): { | |
| "PU_ENB": (25, 27, "lutff_6/in_0"), | |
| "WEAK_PU_ENB": (25, 27, "lutff_4/in_0"), | |
| "PACKAGE_PIN": (19, 31, 0) | |
| }, | |
| ("IO_I3C", (25, 27, 1)): { | |
| "PU_ENB": (25, 27, "lutff_7/in_0"), | |
| "WEAK_PU_ENB": (25, 27, "lutff_5/in_0"), | |
| "PACKAGE_PIN": (19, 31, 1) | |
| } | |
| }, | |
| "u4k" : { | |
| ("HFOSC", (0, 21, 1)) : { | |
| "CLKHFPU": (0, 19, "lutff_0/in_1"), | |
| "CLKHFEN": (0, 19, "lutff_7/in_3"), | |
| "CLKHF": (0, 19, "glb_netwk_4"), | |
| "CLKLF_FABRIC": (0, 18, "slf_op_7"), | |
| "CLKHF_DIV_1": (0, 16, "CBIT_4"), | |
| "CLKHF_DIV_0": (0, 16, "CBIT_3") | |
| }, | |
| ("LFOSC", (25, 21, 1)) : { | |
| "CLKLFPU": (25, 19, "lutff_0/in_1"), | |
| "CLKLFEN": (25, 19, "lutff_7/in_3"), | |
| "CLKLF": (25, 19, "glb_netwk_5"), | |
| "CLKLF_FABRIC": (25, 19, "slf_op_0") | |
| }, | |
| ("SMCCLK", (25, 3, 0)) : { | |
| "CLK": (25, 3, "slf_op_5") | |
| }, | |
| } | |
| } | |
| iotile_full_db = parse_db(iceboxdb.database_io_txt) | |
| logictile_db = parse_db(iceboxdb.database_logic_txt, "1k") | |
| logictile_5k_db = parse_db(iceboxdb.database_logic_txt, "5k") | |
| logictile_8k_db = parse_db(iceboxdb.database_logic_txt, "8k") | |
| logictile_384_db = parse_db(iceboxdb.database_logic_txt, "384") | |
| rambtile_db = parse_db(iceboxdb.database_ramb_txt, "1k") | |
| ramttile_db = parse_db(iceboxdb.database_ramt_txt, "1k") | |
| rambtile_8k_db = parse_db(iceboxdb.database_ramb_8k_txt, "8k") | |
| ramttile_8k_db = parse_db(iceboxdb.database_ramt_8k_txt, "8k") | |
| ipcon_5k_db = parse_db(iceboxdb.database_ipcon_5k_txt, "5k") | |
| dsp0_5k_db = parse_db(iceboxdb.database_dsp0_5k_txt, "5k") | |
| dsp1_5k_db = parse_db(iceboxdb.database_dsp1_5k_txt, "5k") | |
| #This bit doesn't exist in DB because icecube won't ever set it, | |
| #but it exists | |
| dsp1_5k_db.append([["B4[7]"], "IpConfig", "CBIT_5"]) | |
| dsp2_5k_db = parse_db(iceboxdb.database_dsp2_5k_txt, "5k") | |
| dsp3_5k_db = parse_db(iceboxdb.database_dsp3_5k_txt, "5k") | |
| dsp3_5k_db.append([["B2[7]"], "IpConfig", "CBIT_3"]) # for u4k HFOSC.CLKHF_DIV | |
| dsp3_5k_db.append([["B5[7]"], "IpConfig", "CBIT_4"]) | |
| #Add missing LC_ bits to DSP and IPCon databases | |
| for db_to_fix in [ipcon_5k_db, dsp0_5k_db, dsp1_5k_db, dsp2_5k_db, dsp3_5k_db]: | |
| for entry in db_to_fix: | |
| if len(entry) >= 2 and entry[1].startswith("LC_"): | |
| for lentry in logictile_5k_db: | |
| if len(lentry) >= 2 and lentry[1] == entry[1]: | |
| entry[0] = lentry[0] | |
| iotile_l_db = list() | |
| iotile_r_db = list() | |
| iotile_t_db = list() | |
| iotile_b_db = list() | |
| for entry in iotile_full_db: | |
| if entry[1] == "buffer" and entry[2].startswith("IO_L."): | |
| new_entry = entry[:] | |
| new_entry[2] = new_entry[2][5:] | |
| iotile_l_db.append(new_entry) | |
| elif entry[1] == "buffer" and entry[2].startswith("IO_R."): | |
| new_entry = entry[:] | |
| new_entry[2] = new_entry[2][5:] | |
| iotile_r_db.append(new_entry) | |
| elif entry[1] == "buffer" and entry[2].startswith("IO_T."): | |
| new_entry = entry[:] | |
| new_entry[2] = new_entry[2][5:] | |
| iotile_t_db.append(new_entry) | |
| elif entry[1] == "buffer" and entry[2].startswith("IO_B."): | |
| new_entry = entry[:] | |
| new_entry[2] = new_entry[2][5:] | |
| iotile_b_db.append(new_entry) | |
| else: | |
| iotile_l_db.append(entry) | |
| iotile_r_db.append(entry) | |
| iotile_t_db.append(entry) | |
| iotile_b_db.append(entry) | |
| logictile_db.append([["B1[49]"], "buffer", "carry_in", "carry_in_mux"]) | |
| logictile_db.append([["B1[50]"], "CarryInSet"]) | |
| logictile_5k_db.append([["B1[49]"], "buffer", "carry_in", "carry_in_mux"]) | |
| logictile_5k_db.append([["B1[50]"], "CarryInSet"]) | |
| logictile_8k_db.append([["B1[49]"], "buffer", "carry_in", "carry_in_mux"]) | |
| logictile_8k_db.append([["B1[50]"], "CarryInSet"]) | |
| logictile_384_db.append([["B1[49]"], "buffer", "carry_in", "carry_in_mux"]) | |
| logictile_384_db.append([["B1[50]"], "CarryInSet"]) | |
| # The 5k series has a couple of extra IO configuration bits. Add them in to a copy of the db here | |
| iotile_t_5k_db = list(iotile_t_db) | |
| iotile_t_5k_db.append([["B14[15]"], "IoCtrl", "padeb_test_1"]) | |
| iotile_t_5k_db.append([["B15[14]"], "IoCtrl", "padeb_test_0"]) | |
| iotile_t_5k_db.append([["B7[10]"], "IoCtrl", "cf_bit_32"]) | |
| iotile_t_5k_db.append([["B6[10]"], "IoCtrl", "cf_bit_33"]) | |
| iotile_t_5k_db.append([["B7[15]"], "IoCtrl", "cf_bit_34"]) | |
| iotile_t_5k_db.append([["B6[15]"], "IoCtrl", "cf_bit_35"]) | |
| iotile_t_5k_db.append([["B13[10]"], "IoCtrl", "cf_bit_36"]) | |
| iotile_t_5k_db.append([["B12[10]"], "IoCtrl", "cf_bit_37"]) | |
| iotile_t_5k_db.append([["B13[15]"], "IoCtrl", "cf_bit_38"]) | |
| iotile_t_5k_db.append([["B12[15]"], "IoCtrl", "cf_bit_39"]) | |
| iotile_t_5k_db.append([["B10[3]"], "IpConfig", "cbit2usealt_in_0"]) | |
| iotile_t_5k_db.append([["B12[2]"], "IpConfig", "cbit2usealt_in_1"]) | |
| iotile_t_5k_db.append([["B12[3]"], "IpConfig", "SDA_input_delay"]) | |
| iotile_t_5k_db.append([["B15[3]"], "IpConfig", "SDA_output_delay"]) | |
| iotile_b_5k_db = list(iotile_b_db) | |
| iotile_b_5k_db.append([["B14[15]"], "IoCtrl", "padeb_test_1"]) | |
| iotile_b_5k_db.append([["B15[14]"], "IoCtrl", "padeb_test_0"]) | |
| iotile_b_5k_db.append([["B7[10]"], "IoCtrl", "cf_bit_32"]) | |
| iotile_b_5k_db.append([["B6[10]"], "IoCtrl", "cf_bit_33"]) | |
| iotile_b_5k_db.append([["B7[15]"], "IoCtrl", "cf_bit_34"]) | |
| iotile_b_5k_db.append([["B6[15]"], "IoCtrl", "cf_bit_35"]) | |
| iotile_b_5k_db.append([["B13[10]"], "IoCtrl", "cf_bit_36"]) | |
| iotile_b_5k_db.append([["B12[10]"], "IoCtrl", "cf_bit_37"]) | |
| iotile_b_5k_db.append([["B13[15]"], "IoCtrl", "cf_bit_38"]) | |
| iotile_b_5k_db.append([["B12[15]"], "IoCtrl", "cf_bit_39"]) | |
| iotile_b_5k_db.append([["B10[3]"], "IpConfig", "cbit2usealt_in_0"]) | |
| iotile_b_5k_db.append([["B12[2]"], "IpConfig", "cbit2usealt_in_1"]) | |
| iotile_b_5k_db.append([["B12[3]"], "IpConfig", "SDA_input_delay"]) | |
| iotile_b_5k_db.append([["B15[3]"], "IpConfig", "SDA_output_delay"]) | |
| for db in [iotile_l_db, iotile_r_db, iotile_t_db, iotile_b_db, iotile_t_5k_db, iotile_b_5k_db, logictile_db, logictile_5k_db, logictile_8k_db, logictile_384_db, rambtile_db, ramttile_db, rambtile_8k_db, ramttile_8k_db, dsp0_5k_db, dsp1_5k_db, dsp2_5k_db, dsp3_5k_db, ipcon_5k_db]: | |
| for entry in db: | |
| if entry[1] in ("buffer", "routing"): | |
| entry[2] = netname_normalize(entry[2], | |
| ramb=(db == rambtile_db), | |
| ramt=(db == ramttile_db), | |
| ramb_8k=(db == rambtile_8k_db), | |
| ramt_8k=(db == ramttile_8k_db)) | |
| entry[3] = netname_normalize(entry[3], | |
| ramb=(db == rambtile_db), | |
| ramt=(db == ramttile_db), | |
| ramb_8k=(db == rambtile_8k_db), | |
| ramt_8k=(db == ramttile_8k_db)) | |
| unique_entries = dict() | |
| while db: | |
| entry = db.pop() | |
| key = " ".join(entry[1:]) + str(entry) | |
| unique_entries[key] = entry | |
| for key in sorted(unique_entries): | |
| db.append(unique_entries[key]) | |
| if __name__ == "__main__": | |
| run_checks() |