diff options
47 files changed, 14018 insertions, 1461 deletions
@@ -123,7 +123,7 @@ LDFLAGS += -rdynamic LDLIBS += -lrt endif -YOSYS_VER := 0.9+3624 +YOSYS_VER := 0.9+3645 GIT_REV := $(shell cd $(YOSYS_SRC) && git rev-parse --short HEAD 2> /dev/null || echo UNKNOWN) OBJS = kernel/version_$(GIT_REV).o @@ -586,6 +586,7 @@ $(eval $(call add_include_file,kernel/utils.h)) $(eval $(call add_include_file,kernel/satgen.h)) $(eval $(call add_include_file,kernel/ff.h)) $(eval $(call add_include_file,kernel/ffinit.h)) +$(eval $(call add_include_file,kernel/mem.h)) $(eval $(call add_include_file,libs/ezsat/ezsat.h)) $(eval $(call add_include_file,libs/ezsat/ezminisat.h)) $(eval $(call add_include_file,libs/sha1/sha1.h)) @@ -601,7 +602,7 @@ $(eval $(call add_include_file,backends/cxxrtl/cxxrtl_vcd_capi.cc)) $(eval $(call add_include_file,backends/cxxrtl/cxxrtl_vcd_capi.h)) OBJS += kernel/driver.o kernel/register.o kernel/rtlil.o kernel/log.o kernel/calc.o kernel/yosys.o -OBJS += kernel/cellaigs.o kernel/celledges.o kernel/satgen.o +OBJS += kernel/cellaigs.o kernel/celledges.o kernel/satgen.o kernel/mem.o kernel/log.o: CXXFLAGS += -DYOSYS_SRC='"$(YOSYS_SRC)"' kernel/yosys.o: CXXFLAGS += -DYOSYS_DATDIR='"$(DATDIR)"' -DYOSYS_PROGRAM_PREFIX='"$(PROGRAM_PREFIX)"' @@ -789,6 +790,7 @@ test: $(TARGETS) $(EXTRA_TARGETS) +cd tests/arch/anlogic && bash run-test.sh $(SEEDOPT) +cd tests/arch/gowin && bash run-test.sh $(SEEDOPT) +cd tests/arch/intel_alm && bash run-test.sh $(SEEDOPT) + +cd tests/arch/nexus && bash run-test.sh $(SEEDOPT) +cd tests/rpc && bash run-test.sh +cd tests/memfile && bash run-test.sh +cd tests/verilog && bash run-test.sh diff --git a/backends/btor/btor.cc b/backends/btor/btor.cc index 5abab8978..639c6f129 100644 --- a/backends/btor/btor.cc +++ b/backends/btor/btor.cc @@ -27,6 +27,7 @@ #include "kernel/sigtools.h" #include "kernel/celltypes.h" #include "kernel/log.h" +#include "kernel/mem.h" #include <string> USING_YOSYS_NAMESPACE @@ -68,12 +69,15 @@ struct BtorWorker // ff inputs that need to be evaluated (<nid>, <ff_cell>) vector<pair<int, Cell*>> ff_todo; + vector<pair<int, Mem*>> mem_todo; pool<Cell*> cell_recursion_guard; vector<int> bad_properties; dict<SigBit, bool> initbits; pool<Wire*> statewires; pool<string> srcsymbols; + vector<Mem> memories; + dict<Cell*, Mem*> mem_cells; string indent, info_filename; vector<string> info_lines; @@ -704,49 +708,45 @@ struct BtorWorker goto okay; } - if (cell->type == ID($mem)) + if (cell->type.in(ID($mem), ID($memrd), ID($memwr), ID($meminit))) { - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - int nwords = cell->getParam(ID::SIZE).as_int(); - int rdports = cell->getParam(ID::RD_PORTS).as_int(); - int wrports = cell->getParam(ID::WR_PORTS).as_int(); + Mem *mem = mem_cells[cell]; - Const wr_clk_en = cell->getParam(ID::WR_CLK_ENABLE); - Const rd_clk_en = cell->getParam(ID::RD_CLK_ENABLE); + int abits = ceil_log2(mem->size); - bool asyncwr = wr_clk_en.is_fully_zero(); + bool asyncwr = false; + bool syncwr = false; - if (!asyncwr && !wr_clk_en.is_fully_ones()) - log_error("Memory %s.%s has mixed async/sync write ports.\n", - log_id(module), log_id(cell)); - - if (!rd_clk_en.is_fully_zero()) - log_error("Memory %s.%s has sync read ports.\n", - log_id(module), log_id(cell)); + for (auto &port : mem->wr_ports) { + if (port.clk_enable) + syncwr = true; + else + asyncwr = true; + } - SigSpec sig_rd_addr = sigmap(cell->getPort(ID::RD_ADDR)); - SigSpec sig_rd_data = sigmap(cell->getPort(ID::RD_DATA)); + if (asyncwr && syncwr) + log_error("Memory %s.%s has mixed async/sync write ports.\n", + log_id(module), log_id(mem->memid)); - SigSpec sig_wr_addr = sigmap(cell->getPort(ID::WR_ADDR)); - SigSpec sig_wr_data = sigmap(cell->getPort(ID::WR_DATA)); - SigSpec sig_wr_en = sigmap(cell->getPort(ID::WR_EN)); + for (auto &port : mem->rd_ports) + if (port.clk_enable) + log_error("Memory %s.%s has sync read ports.\n", + log_id(module), log_id(mem->memid)); - int data_sid = get_bv_sid(width); + int data_sid = get_bv_sid(mem->width); int bool_sid = get_bv_sid(1); - int sid = get_mem_sid(abits, width); + int sid = get_mem_sid(abits, mem->width); - Const initdata = cell->getParam(ID::INIT); - initdata.exts(nwords*width); int nid_init_val = -1; - if (!initdata.is_fully_undef()) + if (!mem->inits.empty()) { + Const initdata = mem->get_init_data(); bool constword = true; - Const firstword = initdata.extract(0, width); + Const firstword = initdata.extract(0, mem->width); - for (int i = 1; i < nwords; i++) { - Const thisword = initdata.extract(i*width, width); + for (int i = 1; i < mem->size; i++) { + Const thisword = initdata.extract(i*mem->width, mem->width); if (thisword != firstword) { constword = false; break; @@ -764,8 +764,8 @@ struct BtorWorker nid_init_val = next_nid++; btorf("%d state %d\n", nid_init_val, sid); - for (int i = 0; i < nwords; i++) { - Const thisword = initdata.extract(i*width, width); + for (int i = 0; i < mem->size; i++) { + Const thisword = initdata.extract(i*mem->width, mem->width); if (thisword.is_fully_undef()) continue; Const thisaddr(i, abits); @@ -784,10 +784,10 @@ struct BtorWorker int nid = next_nid++; int nid_head = nid; - if (cell->name[0] == '$') + if (mem->memid[0] == '$') btorf("%d state %d\n", nid, sid); else - btorf("%d state %d %s\n", nid, sid, log_id(cell)); + btorf("%d state %d %s\n", nid, sid, log_id(mem->memid)); if (nid_init_val >= 0) { @@ -797,15 +797,14 @@ struct BtorWorker if (asyncwr) { - for (int port = 0; port < wrports; port++) + for (auto &port : mem->wr_ports) { - SigSpec wa = sig_wr_addr.extract(port*abits, abits); - SigSpec wd = sig_wr_data.extract(port*width, width); - SigSpec we = sig_wr_en.extract(port*width, width); + SigSpec wa = port.addr; + wa.extend_u0(abits); int wa_nid = get_sig_nid(wa); - int wd_nid = get_sig_nid(wd); - int we_nid = get_sig_nid(we); + int wd_nid = get_sig_nid(port.data); + int we_nid = get_sig_nid(port.en); int nid2 = next_nid++; btorf("%d read %d %d %d\n", nid2, data_sid, nid_head, wa_nid); @@ -835,22 +834,22 @@ struct BtorWorker } } - for (int port = 0; port < rdports; port++) + for (auto &port : mem->rd_ports) { - SigSpec ra = sig_rd_addr.extract(port*abits, abits); - SigSpec rd = sig_rd_data.extract(port*width, width); + SigSpec ra = port.addr; + ra.extend_u0(abits); int ra_nid = get_sig_nid(ra); int rd_nid = next_nid++; btorf("%d read %d %d %d\n", rd_nid, data_sid, nid_head, ra_nid); - add_nid_sig(rd_nid, rd); + add_nid_sig(rd_nid, port.data); } if (!asyncwr) { - ff_todo.push_back(make_pair(nid, cell)); + mem_todo.push_back(make_pair(nid, mem)); } else { @@ -1065,6 +1064,15 @@ struct BtorWorker if (!info_filename.empty()) infof("name %s\n", log_id(module)); + memories = Mem::get_all_memories(module); + + dict<IdString, Mem*> mem_dict; + for (auto &mem : memories) + mem_dict[mem.memid] = &mem; + for (auto cell : module->cells()) + if (cell->type.in(ID($mem), ID($memwr), ID($memrd), ID($meminit))) + mem_cells[cell] = mem_dict[cell->parameters.at(ID::MEMID).decode_string()]; + btorf_push("inputs"); for (auto wire : module->wires()) @@ -1201,7 +1209,7 @@ struct BtorWorker continue; } - while (!ff_todo.empty()) + while (!ff_todo.empty() || !mem_todo.empty()) { vector<pair<int, Cell*>> todo; todo.swap(ff_todo); @@ -1213,70 +1221,71 @@ struct BtorWorker btorf_push(stringf("next %s", log_id(cell))); - if (cell->type == ID($mem)) - { - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - int wrports = cell->getParam(ID::WR_PORTS).as_int(); + SigSpec sig = sigmap(cell->getPort(ID::D)); + int nid_q = get_sig_nid(sig); + int sid = get_bv_sid(GetSize(sig)); + btorf("%d next %d %d %d%s\n", next_nid++, sid, nid, nid_q, getinfo(cell).c_str()); - SigSpec sig_wr_addr = sigmap(cell->getPort(ID::WR_ADDR)); - SigSpec sig_wr_data = sigmap(cell->getPort(ID::WR_DATA)); - SigSpec sig_wr_en = sigmap(cell->getPort(ID::WR_EN)); + btorf_pop(stringf("next %s", log_id(cell))); + } - int data_sid = get_bv_sid(width); - int bool_sid = get_bv_sid(1); - int sid = get_mem_sid(abits, width); - int nid_head = nid; + vector<pair<int, Mem*>> mtodo; + mtodo.swap(mem_todo); - for (int port = 0; port < wrports; port++) - { - SigSpec wa = sig_wr_addr.extract(port*abits, abits); - SigSpec wd = sig_wr_data.extract(port*width, width); - SigSpec we = sig_wr_en.extract(port*width, width); + for (auto &it : mtodo) + { + int nid = it.first; + Mem *mem = it.second; - int wa_nid = get_sig_nid(wa); - int wd_nid = get_sig_nid(wd); - int we_nid = get_sig_nid(we); + btorf_push(stringf("next %s", log_id(mem->memid))); - int nid2 = next_nid++; - btorf("%d read %d %d %d\n", nid2, data_sid, nid_head, wa_nid); + int abits = ceil_log2(mem->size); - int nid3 = next_nid++; - btorf("%d not %d %d\n", nid3, data_sid, we_nid); + int data_sid = get_bv_sid(mem->width); + int bool_sid = get_bv_sid(1); + int sid = get_mem_sid(abits, mem->width); + int nid_head = nid; - int nid4 = next_nid++; - btorf("%d and %d %d %d\n", nid4, data_sid, nid2, nid3); + for (auto &port : mem->wr_ports) + { + SigSpec wa = port.addr; + wa.extend_u0(abits); - int nid5 = next_nid++; - btorf("%d and %d %d %d\n", nid5, data_sid, wd_nid, we_nid); + int wa_nid = get_sig_nid(wa); + int wd_nid = get_sig_nid(port.data); + int we_nid = get_sig_nid(port.en); - int nid6 = next_nid++; - btorf("%d or %d %d %d\n", nid6, data_sid, nid5, nid4); + int nid2 = next_nid++; + btorf("%d read %d %d %d\n", nid2, data_sid, nid_head, wa_nid); - int nid7 = next_nid++; - btorf("%d write %d %d %d %d\n", nid7, sid, nid_head, wa_nid, nid6); + int nid3 = next_nid++; + btorf("%d not %d %d\n", nid3, data_sid, we_nid); - int nid8 = next_nid++; - btorf("%d redor %d %d\n", nid8, bool_sid, we_nid); + int nid4 = next_nid++; + btorf("%d and %d %d %d\n", nid4, data_sid, nid2, nid3); - int nid9 = next_nid++; - btorf("%d ite %d %d %d %d\n", nid9, sid, nid8, nid7, nid_head); + int nid5 = next_nid++; + btorf("%d and %d %d %d\n", nid5, data_sid, wd_nid, we_nid); - nid_head = nid9; - } + int nid6 = next_nid++; + btorf("%d or %d %d %d\n", nid6, data_sid, nid5, nid4); - int nid2 = next_nid++; - btorf("%d next %d %d %d%s\n", nid2, sid, nid, nid_head, getinfo(cell).c_str()); - } - else - { - SigSpec sig = sigmap(cell->getPort(ID::D)); - int nid_q = get_sig_nid(sig); - int sid = get_bv_sid(GetSize(sig)); - btorf("%d next %d %d %d%s\n", next_nid++, sid, nid, nid_q, getinfo(cell).c_str()); + int nid7 = next_nid++; + btorf("%d write %d %d %d %d\n", nid7, sid, nid_head, wa_nid, nid6); + + int nid8 = next_nid++; + btorf("%d redor %d %d\n", nid8, bool_sid, we_nid); + + int nid9 = next_nid++; + btorf("%d ite %d %d %d %d\n", nid9, sid, nid8, nid7, nid_head); + + nid_head = nid9; } - btorf_pop(stringf("next %s", log_id(cell))); + int nid2 = next_nid++; + btorf("%d next %d %d %d%s\n", nid2, sid, nid, nid_head, (mem->cell ? getinfo(mem->cell) : getinfo(mem->mem)).c_str()); + + btorf_pop(stringf("next %s", log_id(mem->memid))); } } diff --git a/backends/smt2/smt2.cc b/backends/smt2/smt2.cc index 0b4e20ac6..a185fdd74 100644 --- a/backends/smt2/smt2.cc +++ b/backends/smt2/smt2.cc @@ -22,6 +22,7 @@ #include "kernel/sigtools.h" #include "kernel/celltypes.h" #include "kernel/log.h" +#include "kernel/mem.h" #include <string> USING_YOSYS_NAMESPACE @@ -40,12 +41,15 @@ struct Smt2Worker std::map<RTLIL::SigBit, RTLIL::Cell*> bit_driver; std::set<RTLIL::Cell*> exported_cells, hiercells, hiercells_queue; pool<Cell*> recursive_cells, registers; + std::vector<Mem> memories; + dict<Cell*, Mem*> mem_cells; + std::set<Mem*> memory_queue; pool<SigBit> clock_posedge, clock_negedge; vector<string> ex_state_eq, ex_input_eq; std::map<RTLIL::SigBit, std::pair<int, int>> fcache; - std::map<Cell*, int> memarrays; + std::map<Mem*, int> memarrays; std::map<int, int> bvsizes; dict<IdString, char*> ids; @@ -116,12 +120,73 @@ struct Smt2Worker makebits(stringf("%s_is", get_id(module))); + dict<IdString, Mem*> mem_dict; + memories = Mem::get_all_memories(module); + for (auto &mem : memories) + { + mem_dict[mem.memid] = &mem; + for (auto &port : mem.wr_ports) + { + if (port.clk_enable) { + SigSpec clk = sigmap(port.clk); + for (int i = 0; i < GetSize(clk); i++) + { + if (clk[i].wire == nullptr) + continue; + if (port.clk_polarity) + clock_posedge.insert(clk[i]); + else + clock_negedge.insert(clk[i]); + } + } + for (auto bit : sigmap(port.en)) + noclock.insert(bit); + for (auto bit : sigmap(port.addr)) + noclock.insert(bit); + for (auto bit : sigmap(port.data)) + noclock.insert(bit); + } + for (auto &port : mem.rd_ports) + { + if (port.clk_enable) { + SigSpec clk = sigmap(port.clk); + for (int i = 0; i < GetSize(clk); i++) + { + if (clk[i].wire == nullptr) + continue; + if (port.clk_polarity) + clock_posedge.insert(clk[i]); + else + clock_negedge.insert(clk[i]); + } + } + for (auto bit : sigmap(port.en)) + noclock.insert(bit); + for (auto bit : sigmap(port.addr)) + noclock.insert(bit); + for (auto bit : sigmap(port.data)) + noclock.insert(bit); + Cell *driver = port.cell ? port.cell : mem.cell; + for (auto bit : sigmap(port.data)) { + if (bit_driver.count(bit)) + log_error("Found multiple drivers for %s.\n", log_signal(bit)); + bit_driver[bit] = driver; + } + } + } + for (auto cell : module->cells()) for (auto &conn : cell->connections()) { if (GetSize(conn.second) == 0) continue; + // Handled above. + if (cell->type.in(ID($mem), ID($memrd), ID($memwr), ID($meminit))) { + mem_cells[cell] = mem_dict[cell->parameters.at(ID::MEMID).decode_string()]; + continue; + } + bool is_input = ct.cell_input(cell->type, conn.first); bool is_output = ct.cell_output(cell->type, conn.first); @@ -135,24 +200,6 @@ struct Smt2Worker log_error("Unsupported or unknown directionality on port %s of cell %s.%s (%s).\n", log_id(conn.first), log_id(module), log_id(cell), log_id(cell->type)); - if (cell->type.in(ID($mem)) && conn.first.in(ID::RD_CLK, ID::WR_CLK)) - { - SigSpec clk = sigmap(conn.second); - for (int i = 0; i < GetSize(clk); i++) - { - if (clk[i].wire == nullptr) - continue; - - if (cell->getParam(conn.first == ID::RD_CLK ? ID::RD_CLK_ENABLE : ID::WR_CLK_ENABLE)[i] != State::S1) - continue; - - if (cell->getParam(conn.first == ID::RD_CLK ? ID::RD_CLK_POLARITY : ID::WR_CLK_POLARITY)[i] == State::S1) - clock_posedge.insert(clk[i]); - else - clock_negedge.insert(clk[i]); - } - } - else if (cell->type.in(ID($dff), ID($_DFF_P_), ID($_DFF_N_)) && conn.first.in(ID::CLK, ID::C)) { bool posedge = (cell->type == ID($_DFF_N_)) || (cell->type == ID($dff) && cell->getParam(ID::CLK_POLARITY).as_bool()); @@ -647,27 +694,35 @@ struct Smt2Worker // FIXME: $slice $concat } - if (memmode && cell->type == ID($mem)) + if (memmode && cell->type.in(ID($mem), ID($memrd), ID($memwr), ID($meminit))) { + Mem *mem = mem_cells[cell]; + + if (memarrays.count(mem)) { + recursive_cells.erase(cell); + return; + } + int arrayid = idcounter++; - memarrays[cell] = arrayid; - - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - int rd_ports = cell->getParam(ID::RD_PORTS).as_int(); - int wr_ports = cell->getParam(ID::WR_PORTS).as_int(); - - bool async_read = false; - if (!cell->getParam(ID::WR_CLK_ENABLE).is_fully_ones()) { - if (!cell->getParam(ID::WR_CLK_ENABLE).is_fully_zero()) - log_error("Memory %s.%s has mixed clocked/nonclocked write ports. This is not supported by \"write_smt2\".\n", log_id(cell), log_id(module)); - async_read = true; + memarrays[mem] = arrayid; + + int abits = ceil_log2(mem->size); + + bool has_sync_wr = false; + bool has_async_wr = false; + for (auto &port : mem->wr_ports) { + if (port.clk_enable) + has_sync_wr = true; + else + has_async_wr = true; } + if (has_async_wr && has_sync_wr) + log_error("Memory %s.%s has mixed clocked/nonclocked write ports. This is not supported by \"write_smt2\".\n", log_id(cell), log_id(module)); - decls.push_back(stringf("; yosys-smt2-memory %s %d %d %d %d %s\n", get_id(cell), abits, width, rd_ports, wr_ports, async_read ? "async" : "sync")); + decls.push_back(stringf("; yosys-smt2-memory %s %d %d %d %d %s\n", get_id(mem->memid), abits, mem->width, GetSize(mem->rd_ports), GetSize(mem->wr_ports), has_async_wr ? "async" : "sync")); string memstate; - if (async_read) { + if (has_async_wr) { memstate = stringf("%s#%d#final", get_id(module), arrayid); } else { memstate = stringf("%s#%d#0", get_id(module), arrayid); @@ -675,80 +730,79 @@ struct Smt2Worker if (statebv) { - int mem_size = cell->getParam(ID::SIZE).as_int(); - int mem_offset = cell->getParam(ID::OFFSET).as_int(); - - makebits(memstate, width*mem_size, get_id(cell)); + makebits(memstate, mem->width*mem->size, get_id(mem->memid)); decls.push_back(stringf("(define-fun |%s_m %s| ((state |%s_s|)) (_ BitVec %d) (|%s| state))\n", - get_id(module), get_id(cell), get_id(module), width*mem_size, memstate.c_str())); + get_id(module), get_id(mem->memid), get_id(module), mem->width*mem->size, memstate.c_str())); - for (int i = 0; i < rd_ports; i++) + for (int i = 0; i < GetSize(mem->rd_ports); i++) { - SigSpec addr_sig = cell->getPort(ID::RD_ADDR).extract(abits*i, abits); - SigSpec data_sig = cell->getPort(ID::RD_DATA).extract(width*i, width); + auto &port = mem->rd_ports[i]; + SigSpec addr_sig = port.addr; + addr_sig.extend_u0(abits); std::string addr = get_bv(addr_sig); - if (cell->getParam(ID::RD_CLK_ENABLE).extract(i).as_bool()) + if (port.clk_enable) log_error("Read port %d (%s) of memory %s.%s is clocked. This is not supported by \"write_smt2\"! " - "Call \"memory\" with -nordff to avoid this error.\n", i, log_signal(data_sig), log_id(cell), log_id(module)); + "Call \"memory\" with -nordff to avoid this error.\n", i, log_signal(port.data), log_id(mem->memid), log_id(module)); decls.push_back(stringf("(define-fun |%s_m:R%dA %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); + get_id(module), i, get_id(mem->memid), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); std::string read_expr = "#b"; - for (int k = 0; k < width; k++) + for (int k = 0; k < mem->width; k++) read_expr += "0"; - for (int k = 0; k < mem_size; k++) + for (int k = 0; k < mem->size; k++) read_expr = stringf("(ite (= (|%s_m:R%dA %s| state) #b%s) ((_ extract %d %d) (|%s| state))\n %s)", - get_id(module), i, get_id(cell), Const(k+mem_offset, abits).as_string().c_str(), - width*(k+1)-1, width*k, memstate.c_str(), read_expr.c_str()); + get_id(module), i, get_id(mem->memid), Const(k+mem->start_offset, abits).as_string().c_str(), + mem->width*(k+1)-1, mem->width*k, memstate.c_str(), read_expr.c_str()); decls.push_back(stringf("(define-fun |%s#%d| ((state |%s_s|)) (_ BitVec %d)\n %s) ; %s\n", - get_id(module), idcounter, get_id(module), width, read_expr.c_str(), log_signal(data_sig))); + get_id(module), idcounter, get_id(module), mem->width, read_expr.c_str(), log_signal(port.data))); decls.push_back(stringf("(define-fun |%s_m:R%dD %s| ((state |%s_s|)) (_ BitVec %d) (|%s#%d| state))\n", - get_id(module), i, get_id(cell), get_id(module), width, get_id(module), idcounter)); + get_id(module), i, get_id(mem->memid), get_id(module), mem->width, get_id(module), idcounter)); - register_bv(data_sig, idcounter++); + register_bv(port.data, idcounter++); } } else { if (statedt) dtmembers.push_back(stringf(" (|%s| (Array (_ BitVec %d) (_ BitVec %d))) ; %s\n", - memstate.c_str(), abits, width, get_id(cell))); + memstate.c_str(), abits, mem->width, get_id(mem->memid))); else decls.push_back(stringf("(declare-fun |%s| (|%s_s|) (Array (_ BitVec %d) (_ BitVec %d))) ; %s\n", - memstate.c_str(), get_id(module), abits, width, get_id(cell))); + memstate.c_str(), get_id(module), abits, mem->width, get_id(mem->memid))); decls.push_back(stringf("(define-fun |%s_m %s| ((state |%s_s|)) (Array (_ BitVec %d) (_ BitVec %d)) (|%s| state))\n", - get_id(module), get_id(cell), get_id(module), abits, width, memstate.c_str())); + get_id(module), get_id(mem->memid), get_id(module), abits, mem->width, memstate.c_str())); - for (int i = 0; i < rd_ports; i++) + for (int i = 0; i < GetSize(mem->rd_ports); i++) { - SigSpec addr_sig = cell->getPort(ID::RD_ADDR).extract(abits*i, abits); - SigSpec data_sig = cell->getPort(ID::RD_DATA).extract(width*i, width); + auto &port = mem->rd_ports[i]; + SigSpec addr_sig = port.addr; + addr_sig.extend_u0(abits); std::string addr = get_bv(addr_sig); - if (cell->getParam(ID::RD_CLK_ENABLE).extract(i).as_bool()) + if (port.clk_enable) log_error("Read port %d (%s) of memory %s.%s is clocked. This is not supported by \"write_smt2\"! " - "Call \"memory\" with -nordff to avoid this error.\n", i, log_signal(data_sig), log_id(cell), log_id(module)); + "Call \"memory\" with -nordff to avoid this error.\n", i, log_signal(port.data), log_id(mem->memid), log_id(module)); decls.push_back(stringf("(define-fun |%s_m:R%dA %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); + get_id(module), i, get_id(mem->memid), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); decls.push_back(stringf("(define-fun |%s#%d| ((state |%s_s|)) (_ BitVec %d) (select (|%s| state) (|%s_m:R%dA %s| state))) ; %s\n", - get_id(module), idcounter, get_id(module), width, memstate.c_str(), get_id(module), i, get_id(cell), log_signal(data_sig))); + get_id(module), idcounter, get_id(module), mem->width, memstate.c_str(), get_id(module), i, get_id(mem->memid), log_signal(port.data))); decls.push_back(stringf("(define-fun |%s_m:R%dD %s| ((state |%s_s|)) (_ BitVec %d) (|%s#%d| state))\n", - get_id(module), i, get_id(cell), get_id(module), width, get_id(module), idcounter)); + get_id(module), i, get_id(mem->memid), get_id(module), mem->width, get_id(module), idcounter)); - register_bv(data_sig, idcounter++); + register_bv(port.data, idcounter++); } } - registers.insert(cell); + memory_queue.insert(mem); recursive_cells.erase(cell); return; } @@ -977,7 +1031,7 @@ struct Smt2Worker } } - for (int iter = 1; !registers.empty(); iter++) + for (int iter = 1; !registers.empty() || !memory_queue.empty(); iter++) { pool<Cell*> this_regs; this_regs.swap(registers); @@ -1010,152 +1064,156 @@ struct Smt2Worker if (cell->type == ID($anyconst)) ex_state_eq.push_back(stringf("(= %s %s)", get_bv(cell->getPort(ID::Y)).c_str(), get_bv(cell->getPort(ID::Y), "other_state").c_str())); } + } - if (cell->type == ID($mem)) - { - int arrayid = memarrays.at(cell); + std::set<Mem*> this_mems; + this_mems.swap(memory_queue); + + for (auto mem : this_mems) + { + int arrayid = memarrays.at(mem); + + int abits = ceil_log2(mem->size);; - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - int wr_ports = cell->getParam(ID::WR_PORTS).as_int(); + bool has_sync_wr = false; + bool has_async_wr = false; + for (auto &port : mem->wr_ports) { + if (port.clk_enable) + has_sync_wr = true; + else + has_async_wr = true; + } - bool async_read = false; - string initial_memstate, final_memstate; + string initial_memstate, final_memstate; - if (!cell->getParam(ID::WR_CLK_ENABLE).is_fully_ones()) { - log_assert(cell->getParam(ID::WR_CLK_ENABLE).is_fully_zero()); - async_read = true; - initial_memstate = stringf("%s#%d#0", get_id(module), arrayid); - final_memstate = stringf("%s#%d#final", get_id(module), arrayid); + if (has_async_wr) { + log_assert(!has_sync_wr); + initial_memstate = stringf("%s#%d#0", get_id(module), arrayid); + final_memstate = stringf("%s#%d#final", get_id(module), arrayid); + } + + if (statebv) + { + if (has_async_wr) { + makebits(final_memstate, mem->width*mem->size, get_id(mem->memid)); } - if (statebv) + for (int i = 0; i < GetSize(mem->wr_ports); i++) { - int mem_size = cell->getParam(ID::SIZE).as_int(); - int mem_offset = cell->getParam(ID::OFFSET).as_int(); - - if (async_read) { - makebits(final_memstate, width*mem_size, get_id(cell)); + auto &port = mem->wr_ports[i]; + SigSpec addr_sig = port.addr; + addr_sig.extend_u0(abits); + + std::string addr = get_bv(addr_sig); + std::string data = get_bv(port.data); + std::string mask = get_bv(port.en); + + decls.push_back(stringf("(define-fun |%s_m:W%dA %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", + get_id(module), i, get_id(mem->memid), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); + addr = stringf("(|%s_m:W%dA %s| state)", get_id(module), i, get_id(mem->memid)); + + decls.push_back(stringf("(define-fun |%s_m:W%dD %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", + get_id(module), i, get_id(mem->memid), get_id(module), mem->width, data.c_str(), log_signal(port.data))); + data = stringf("(|%s_m:W%dD %s| state)", get_id(module), i, get_id(mem->memid)); + + decls.push_back(stringf("(define-fun |%s_m:W%dM %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", + get_id(module), i, get_id(mem->memid), get_id(module), mem->width, mask.c_str(), log_signal(port.en))); + mask = stringf("(|%s_m:W%dM %s| state)", get_id(module), i, get_id(mem->memid)); + + std::string data_expr; + + for (int k = mem->size-1; k >= 0; k--) { + std::string new_data = stringf("(bvor (bvand %s %s) (bvand ((_ extract %d %d) (|%s#%d#%d| state)) (bvnot %s)))", + data.c_str(), mask.c_str(), mem->width*(k+1)-1, mem->width*k, get_id(module), arrayid, i, mask.c_str()); + data_expr += stringf("\n (ite (= %s #b%s) %s ((_ extract %d %d) (|%s#%d#%d| state)))", + addr.c_str(), Const(k+mem->start_offset, abits).as_string().c_str(), new_data.c_str(), + mem->width*(k+1)-1, mem->width*k, get_id(module), arrayid, i); } - for (int i = 0; i < wr_ports; i++) - { - SigSpec addr_sig = cell->getPort(ID::WR_ADDR).extract(abits*i, abits); - SigSpec data_sig = cell->getPort(ID::WR_DATA).extract(width*i, width); - SigSpec mask_sig = cell->getPort(ID::WR_EN).extract(width*i, width); + decls.push_back(stringf("(define-fun |%s#%d#%d| ((state |%s_s|)) (_ BitVec %d) (concat%s)) ; %s\n", + get_id(module), arrayid, i+1, get_id(module), mem->width*mem->size, data_expr.c_str(), get_id(mem->memid))); + } + } + else + { + if (has_async_wr) { + if (statedt) + dtmembers.push_back(stringf(" (|%s| (Array (_ BitVec %d) (_ BitVec %d))) ; %s\n", + initial_memstate.c_str(), abits, mem->width, get_id(mem->memid))); + else + decls.push_back(stringf("(declare-fun |%s| (|%s_s|) (Array (_ BitVec %d) (_ BitVec %d))) ; %s\n", + initial_memstate.c_str(), get_id(module), abits, mem->width, get_id(mem->memid))); + } - std::string addr = get_bv(addr_sig); - std::string data = get_bv(data_sig); - std::string mask = get_bv(mask_sig); + for (int i = 0; i < GetSize(mem->wr_ports); i++) + { + auto &port = mem->wr_ports[i]; + SigSpec addr_sig = port.addr; + addr_sig.extend_u0(abits); - decls.push_back(stringf("(define-fun |%s_m:W%dA %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); - addr = stringf("(|%s_m:W%dA %s| state)", get_id(module), i, get_id(cell)); + std::string addr = get_bv(addr_sig); + std::string data = get_bv(port.data); + std::string mask = get_bv(port.en); - decls.push_back(stringf("(define-fun |%s_m:W%dD %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), width, data.c_str(), log_signal(data_sig))); - data = stringf("(|%s_m:W%dD %s| state)", get_id(module), i, get_id(cell)); + decls.push_back(stringf("(define-fun |%s_m:W%dA %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", + get_id(module), i, get_id(mem->memid), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); + addr = stringf("(|%s_m:W%dA %s| state)", get_id(module), i, get_id(mem->memid)); - decls.push_back(stringf("(define-fun |%s_m:W%dM %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), width, mask.c_str(), log_signal(mask_sig))); - mask = stringf("(|%s_m:W%dM %s| state)", get_id(module), i, get_id(cell)); + decls.push_back(stringf("(define-fun |%s_m:W%dD %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", + get_id(module), i, get_id(mem->memid), get_id(module), mem->width, data.c_str(), log_signal(port.data))); + data = stringf("(|%s_m:W%dD %s| state)", get_id(module), i, get_id(mem->memid)); - std::string data_expr; + decls.push_back(stringf("(define-fun |%s_m:W%dM %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", + get_id(module), i, get_id(mem->memid), get_id(module), mem->width, mask.c_str(), log_signal(port.en))); + mask = stringf("(|%s_m:W%dM %s| state)", get_id(module), i, get_id(mem->memid)); - for (int k = mem_size-1; k >= 0; k--) { - std::string new_data = stringf("(bvor (bvand %s %s) (bvand ((_ extract %d %d) (|%s#%d#%d| state)) (bvnot %s)))", - data.c_str(), mask.c_str(), width*(k+1)-1, width*k, get_id(module), arrayid, i, mask.c_str()); - data_expr += stringf("\n (ite (= %s #b%s) %s ((_ extract %d %d) (|%s#%d#%d| state)))", - addr.c_str(), Const(k+mem_offset, abits).as_string().c_str(), new_data.c_str(), - width*(k+1)-1, width*k, get_id(module), arrayid, i); - } + data = stringf("(bvor (bvand %s %s) (bvand (select (|%s#%d#%d| state) %s) (bvnot %s)))", + data.c_str(), mask.c_str(), get_id(module), arrayid, i, addr.c_str(), mask.c_str()); - decls.push_back(stringf("(define-fun |%s#%d#%d| ((state |%s_s|)) (_ BitVec %d) (concat%s)) ; %s\n", - get_id(module), arrayid, i+1, get_id(module), width*mem_size, data_expr.c_str(), get_id(cell))); - } + decls.push_back(stringf("(define-fun |%s#%d#%d| ((state |%s_s|)) (Array (_ BitVec %d) (_ BitVec %d)) " + "(store (|%s#%d#%d| state) %s %s)) ; %s\n", + get_id(module), arrayid, i+1, get_id(module), abits, mem->width, + get_id(module), arrayid, i, addr.c_str(), data.c_str(), get_id(mem->memid))); } - else - { - if (async_read) { - if (statedt) - dtmembers.push_back(stringf(" (|%s| (Array (_ BitVec %d) (_ BitVec %d))) ; %s\n", - initial_memstate.c_str(), abits, width, get_id(cell))); - else - decls.push_back(stringf("(declare-fun |%s| (|%s_s|) (Array (_ BitVec %d) (_ BitVec %d))) ; %s\n", - initial_memstate.c_str(), get_id(module), abits, width, get_id(cell))); - } - - for (int i = 0; i < wr_ports; i++) - { - SigSpec addr_sig = cell->getPort(ID::WR_ADDR).extract(abits*i, abits); - SigSpec data_sig = cell->getPort(ID::WR_DATA).extract(width*i, width); - SigSpec mask_sig = cell->getPort(ID::WR_EN).extract(width*i, width); + } - std::string addr = get_bv(addr_sig); - std::string data = get_bv(data_sig); - std::string mask = get_bv(mask_sig); + std::string expr_d = stringf("(|%s#%d#%d| state)", get_id(module), arrayid, GetSize(mem->wr_ports)); + std::string expr_q = stringf("(|%s#%d#0| next_state)", get_id(module), arrayid); + trans.push_back(stringf(" (= %s %s) ; %s\n", expr_d.c_str(), expr_q.c_str(), get_id(mem->memid))); + ex_state_eq.push_back(stringf("(= (|%s#%d#0| state) (|%s#%d#0| other_state))", get_id(module), arrayid, get_id(module), arrayid)); - decls.push_back(stringf("(define-fun |%s_m:W%dA %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), abits, addr.c_str(), log_signal(addr_sig))); - addr = stringf("(|%s_m:W%dA %s| state)", get_id(module), i, get_id(cell)); + if (has_async_wr) + hier.push_back(stringf(" (= %s (|%s| state)) ; %s\n", expr_d.c_str(), final_memstate.c_str(), get_id(mem->memid))); - decls.push_back(stringf("(define-fun |%s_m:W%dD %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), width, data.c_str(), log_signal(data_sig))); - data = stringf("(|%s_m:W%dD %s| state)", get_id(module), i, get_id(cell)); + Const init_data = mem->get_init_data(); - decls.push_back(stringf("(define-fun |%s_m:W%dM %s| ((state |%s_s|)) (_ BitVec %d) %s) ; %s\n", - get_id(module), i, get_id(cell), get_id(module), width, mask.c_str(), log_signal(mask_sig))); - mask = stringf("(|%s_m:W%dM %s| state)", get_id(module), i, get_id(cell)); + for (int i = 0; i < mem->size; i++) + { + if (i*mem->width >= GetSize(init_data)) + break; - data = stringf("(bvor (bvand %s %s) (bvand (select (|%s#%d#%d| state) %s) (bvnot %s)))", - data.c_str(), mask.c_str(), get_id(module), arrayid, i, addr.c_str(), mask.c_str()); + Const initword = init_data.extract(i*mem->width, mem->width, State::Sx); + Const initmask = initword; + bool gen_init_constr = false; - decls.push_back(stringf("(define-fun |%s#%d#%d| ((state |%s_s|)) (Array (_ BitVec %d) (_ BitVec %d)) " - "(store (|%s#%d#%d| state) %s %s)) ; %s\n", - get_id(module), arrayid, i+1, get_id(module), abits, width, - get_id(module), arrayid, i, addr.c_str(), data.c_str(), get_id(cell))); + for (int k = 0; k < GetSize(initword); k++) { + if (initword[k] == State::S0 || initword[k] == State::S1) { + gen_init_constr = true; + initmask[k] = State::S1; + } else { + initmask[k] = State::S0; + initword[k] = State::S0; } } - std::string expr_d = stringf("(|%s#%d#%d| state)", get_id(module), arrayid, wr_ports); - std::string expr_q = stringf("(|%s#%d#0| next_state)", get_id(module), arrayid); - trans.push_back(stringf(" (= %s %s) ; %s\n", expr_d.c_str(), expr_q.c_str(), get_id(cell))); - ex_state_eq.push_back(stringf("(= (|%s#%d#0| state) (|%s#%d#0| other_state))", get_id(module), arrayid, get_id(module), arrayid)); - - if (async_read) - hier.push_back(stringf(" (= %s (|%s| state)) ; %s\n", expr_d.c_str(), final_memstate.c_str(), get_id(cell))); - - Const init_data = cell->getParam(ID::INIT); - int memsize = cell->getParam(ID::SIZE).as_int(); - - for (int i = 0; i < memsize; i++) + if (gen_init_constr) { - if (i*width >= GetSize(init_data)) - break; - - Const initword = init_data.extract(i*width, width, State::Sx); - Const initmask = initword; - bool gen_init_constr = false; - - for (int k = 0; k < GetSize(initword); k++) { - if (initword[k] == State::S0 || initword[k] == State::S1) { - gen_init_constr = true; - initmask[k] = State::S1; - } else { - initmask[k] = State::S0; - initword[k] = State::S0; - } - } - - if (gen_init_constr) - { - if (statebv) - /* FIXME */; - else - init_list.push_back(stringf("(= (bvand (select (|%s#%d#0| state) #b%s) #b%s) #b%s) ; %s[%d]", - get_id(module), arrayid, Const(i, abits).as_string().c_str(), - initmask.as_string().c_str(), initword.as_string().c_str(), get_id(cell), i)); - } + if (statebv) + /* FIXME */; + else + init_list.push_back(stringf("(= (bvand (select (|%s#%d#0| state) #b%s) #b%s) #b%s) ; %s[%d]", + get_id(module), arrayid, Const(i, abits).as_string().c_str(), + initmask.as_string().c_str(), initword.as_string().c_str(), get_id(mem->memid), i)); } } } @@ -1586,7 +1644,7 @@ struct Smt2Backend : public Backend { for (auto module : sorted_modules) { - if (module->get_blackbox_attribute() || module->has_memories_warn() || module->has_processes_warn()) + if (module->get_blackbox_attribute() || module->has_processes_warn()) continue; log("Creating SMT-LIBv2 representation of module %s.\n", log_id(module)); diff --git a/backends/verilog/verilog_backend.cc b/backends/verilog/verilog_backend.cc index bf980129d..9523f4a52 100644 --- a/backends/verilog/verilog_backend.cc +++ b/backends/verilog/verilog_backend.cc @@ -26,6 +26,7 @@ #include "kernel/log.h" #include "kernel/sigtools.h" #include "kernel/ff.h" +#include "kernel/mem.h" #include <string> #include <sstream> #include <set> @@ -434,10 +435,250 @@ void dump_wire(std::ostream &f, std::string indent, RTLIL::Wire *wire) #endif } -void dump_memory(std::ostream &f, std::string indent, RTLIL::Memory *memory) +void dump_memory(std::ostream &f, std::string indent, Mem &mem) { - dump_attributes(f, indent, memory->attributes); - f << stringf("%s" "reg [%d:0] %s [%d:%d];\n", indent.c_str(), memory->width-1, id(memory->name).c_str(), memory->size+memory->start_offset-1, memory->start_offset); + std::string mem_id = id(mem.memid); + + dump_attributes(f, indent, mem.attributes); + f << stringf("%s" "reg [%d:0] %s [%d:%d];\n", indent.c_str(), mem.width-1, mem_id.c_str(), mem.size+mem.start_offset-1, mem.start_offset); + + // for memory block make something like: + // reg [7:0] memid [3:0]; + // initial begin + // memid[0] = ... + // end + if (!mem.inits.empty()) + { + if (extmem) + { + std::string extmem_filename = stringf("%s-%d.mem", extmem_prefix.c_str(), extmem_counter++); + + std::string extmem_filename_esc; + for (auto c : extmem_filename) + { + if (c == '\n') + extmem_filename_esc += "\\n"; + else if (c == '\t') + extmem_filename_esc += "\\t"; + else if (c < 32) + extmem_filename_esc += stringf("\\%03o", c); + else if (c == '"') + extmem_filename_esc += "\\\""; + else if (c == '\\') + extmem_filename_esc += "\\\\"; + else + extmem_filename_esc += c; + } + f << stringf("%s" "initial $readmemb(\"%s\", %s);\n", indent.c_str(), extmem_filename_esc.c_str(), mem_id.c_str()); + + std::ofstream extmem_f(extmem_filename, std::ofstream::trunc); + if (extmem_f.fail()) + log_error("Can't open file `%s' for writing: %s\n", extmem_filename.c_str(), strerror(errno)); + else + { + Const data = mem.get_init_data(); + for (int i=0; i<mem.size; i++) + { + RTLIL::Const element = data.extract(i*mem.width, mem.width); + for (int j=0; j<element.size(); j++) + { + switch (element[element.size()-j-1]) + { + case State::S0: extmem_f << '0'; break; + case State::S1: extmem_f << '1'; break; + case State::Sx: extmem_f << 'x'; break; + case State::Sz: extmem_f << 'z'; break; + case State::Sa: extmem_f << '_'; break; + case State::Sm: log_error("Found marker state in final netlist."); + } + } + extmem_f << '\n'; + } + } + } + else + { + f << stringf("%s" "initial begin\n", indent.c_str()); + for (auto &init : mem.inits) { + int words = GetSize(init.data) / mem.width; + int start = init.addr.as_int(); + for (int i=0; i<words; i++) + { + f << stringf("%s" " %s[%d] = ", indent.c_str(), mem_id.c_str(), i + start); + dump_const(f, init.data.extract(i*mem.width, mem.width)); + f << stringf(";\n"); + } + } + f << stringf("%s" "end\n", indent.c_str()); + } + } + + // create a map : "edge clk" -> expressions within that clock domain + dict<std::string, std::vector<std::string>> clk_to_lof_body; + clk_to_lof_body[""] = std::vector<std::string>(); + std::string clk_domain_str; + // create a list of reg declarations + std::vector<std::string> lof_reg_declarations; + + // read ports + for (auto &port : mem.rd_ports) + { + if (port.clk_enable) + { + { + std::ostringstream os; + dump_sigspec(os, port.clk); + clk_domain_str = stringf("%sedge %s", port.clk_polarity ? "pos" : "neg", os.str().c_str()); + if( clk_to_lof_body.count(clk_domain_str) == 0 ) + clk_to_lof_body[clk_domain_str] = std::vector<std::string>(); + } + if (!port.transparent) + { + // for clocked read ports make something like: + // reg [..] temp_id; + // always @(posedge clk) + // if (rd_en) temp_id <= array_reg[r_addr]; + // assign r_data = temp_id; + std::string temp_id = next_auto_id(); + lof_reg_declarations.push_back( stringf("reg [%d:0] %s;\n", port.data.size() - 1, temp_id.c_str()) ); + { + std::ostringstream os; + if (port.en != RTLIL::SigBit(true)) + { + os << stringf("if ("); + dump_sigspec(os, port.en); + os << stringf(") "); + } + os << stringf("%s <= %s[", temp_id.c_str(), mem_id.c_str()); + dump_sigspec(os, port.addr); + os << stringf("];\n"); + clk_to_lof_body[clk_domain_str].push_back(os.str()); + } + { + std::ostringstream os; + dump_sigspec(os, port.data); + std::string line = stringf("assign %s = %s;\n", os.str().c_str(), temp_id.c_str()); + clk_to_lof_body[""].push_back(line); + } + } + else + { + // for rd-transparent read-ports make something like: + // reg [..] temp_id; + // always @(posedge clk) + // temp_id <= r_addr; + // assign r_data = array_reg[temp_id]; + std::string temp_id = next_auto_id(); + lof_reg_declarations.push_back( stringf("reg [%d:0] %s;\n", port.addr.size() - 1, temp_id.c_str()) ); + { + std::ostringstream os; + dump_sigspec(os, port.addr); + std::string line = stringf("%s <= %s;\n", temp_id.c_str(), os.str().c_str()); + clk_to_lof_body[clk_domain_str].push_back(line); + } + { + std::ostringstream os; + dump_sigspec(os, port.data); + std::string line = stringf("assign %s = %s[%s];\n", os.str().c_str(), mem_id.c_str(), temp_id.c_str()); + clk_to_lof_body[""].push_back(line); + } + } + } else { + // for non-clocked read-ports make something like: + // assign r_data = array_reg[r_addr]; + std::ostringstream os, os2; + dump_sigspec(os, port.data); + dump_sigspec(os2, port.addr); + std::string line = stringf("assign %s = %s[%s];\n", os.str().c_str(), mem_id.c_str(), os2.str().c_str()); + clk_to_lof_body[""].push_back(line); + } + } + + // write ports + for (auto &port : mem.wr_ports) + { + { + std::ostringstream os; + dump_sigspec(os, port.clk); + clk_domain_str = stringf("%sedge %s", port.clk_polarity ? "pos" : "neg", os.str().c_str()); + if( clk_to_lof_body.count(clk_domain_str) == 0 ) + clk_to_lof_body[clk_domain_str] = std::vector<std::string>(); + } + // make something like: + // always @(posedge clk) + // if (wr_en_bit) memid[w_addr][??] <= w_data[??]; + // ... + for (int i = 0; i < GetSize(port.en); i++) + { + int start_i = i, width = 1; + SigBit wen_bit = port.en[i]; + + while (i+1 < GetSize(port.en) && active_sigmap(port.en[i+1]) == active_sigmap(wen_bit)) + i++, width++; + + if (wen_bit == State::S0) + continue; + + std::ostringstream os; + if (wen_bit != State::S1) + { + os << stringf("if ("); + dump_sigspec(os, wen_bit); + os << stringf(") "); + } + os << stringf("%s[", mem_id.c_str()); + dump_sigspec(os, port.addr); + if (width == GetSize(port.en)) + os << stringf("] <= "); + else + os << stringf("][%d:%d] <= ", i, start_i); + dump_sigspec(os, port.data.extract(start_i, width)); + os << stringf(";\n"); + clk_to_lof_body[clk_domain_str].push_back(os.str()); + } + } + // Output Verilog that looks something like this: + // reg [..] _3_; + // always @(posedge CLK2) begin + // _3_ <= memory[D1ADDR]; + // if (A1EN) + // memory[A1ADDR] <= A1DATA; + // if (A2EN) + // memory[A2ADDR] <= A2DATA; + // ... + // end + // always @(negedge CLK1) begin + // if (C1EN) + // memory[C1ADDR] <= C1DATA; + // end + // ... + // assign D1DATA = _3_; + // assign D2DATA <= memory[D2ADDR]; + + // the reg ... definitions + for(auto ® : lof_reg_declarations) + { + f << stringf("%s" "%s", indent.c_str(), reg.c_str()); + } + // the block of expressions by clock domain + for(auto &pair : clk_to_lof_body) + { + std::string clk_domain = pair.first; + std::vector<std::string> lof_lines = pair.second; + if( clk_domain != "") + { + f << stringf("%s" "always%s @(%s) begin\n", indent.c_str(), systemverilog ? "_ff" : "", clk_domain.c_str()); + for(auto &line : lof_lines) + f << stringf("%s%s" "%s", indent.c_str(), indent.c_str(), line.c_str()); + f << stringf("%s" "end\n", indent.c_str()); + } + else + { + // the non-clocked assignments + for(auto &line : lof_lines) + f << stringf("%s" "%s", indent.c_str(), line.c_str()); + } + } } void dump_cell_expr_port(std::ostream &f, RTLIL::Cell *cell, std::string port, bool gen_signed = true) @@ -1095,274 +1336,6 @@ bool dump_cell_expr(std::ostream &f, std::string indent, RTLIL::Cell *cell) return true; } - if (cell->type == ID($mem)) - { - RTLIL::IdString memid = cell->parameters[ID::MEMID].decode_string(); - std::string mem_id = id(cell->parameters[ID::MEMID].decode_string()); - int abits = cell->parameters[ID::ABITS].as_int(); - int size = cell->parameters[ID::SIZE].as_int(); - int offset = cell->parameters[ID::OFFSET].as_int(); - int width = cell->parameters[ID::WIDTH].as_int(); - bool use_init = !(RTLIL::SigSpec(cell->parameters[ID::INIT]).is_fully_undef()); - - // for memory block make something like: - // reg [7:0] memid [3:0]; - // initial begin - // memid[0] = ... - // end - dump_attributes(f, indent.c_str(), cell->attributes); - f << stringf("%s" "reg [%d:%d] %s [%d:%d];\n", indent.c_str(), width-1, 0, mem_id.c_str(), size+offset-1, offset); - if (use_init) - { - if (extmem) - { - std::string extmem_filename = stringf("%s-%d.mem", extmem_prefix.c_str(), extmem_counter++); - - std::string extmem_filename_esc; - for (auto c : extmem_filename) - { - if (c == '\n') - extmem_filename_esc += "\\n"; - else if (c == '\t') - extmem_filename_esc += "\\t"; - else if (c < 32) - extmem_filename_esc += stringf("\\%03o", c); - else if (c == '"') - extmem_filename_esc += "\\\""; - else if (c == '\\') - extmem_filename_esc += "\\\\"; - else - extmem_filename_esc += c; - } - f << stringf("%s" "initial $readmemb(\"%s\", %s);\n", indent.c_str(), extmem_filename_esc.c_str(), mem_id.c_str()); - - std::ofstream extmem_f(extmem_filename, std::ofstream::trunc); - if (extmem_f.fail()) - log_error("Can't open file `%s' for writing: %s\n", extmem_filename.c_str(), strerror(errno)); - else - { - for (int i=0; i<size; i++) - { - RTLIL::Const element = cell->parameters[ID::INIT].extract(i*width, width); - for (int j=0; j<element.size(); j++) - { - switch (element[element.size()-j-1]) - { - case State::S0: extmem_f << '0'; break; - case State::S1: extmem_f << '1'; break; - case State::Sx: extmem_f << 'x'; break; - case State::Sz: extmem_f << 'z'; break; - case State::Sa: extmem_f << '_'; break; - case State::Sm: log_error("Found marker state in final netlist."); - } - } - extmem_f << '\n'; - } - } - - } - else - { - f << stringf("%s" "initial begin\n", indent.c_str()); - for (int i=0; i<size; i++) - { - f << stringf("%s" " %s[%d] = ", indent.c_str(), mem_id.c_str(), i); - dump_const(f, cell->parameters[ID::INIT].extract(i*width, width)); - f << stringf(";\n"); - } - f << stringf("%s" "end\n", indent.c_str()); - } - } - - // create a map : "edge clk" -> expressions within that clock domain - dict<std::string, std::vector<std::string>> clk_to_lof_body; - clk_to_lof_body[""] = std::vector<std::string>(); - std::string clk_domain_str; - // create a list of reg declarations - std::vector<std::string> lof_reg_declarations; - - int nread_ports = cell->parameters[ID::RD_PORTS].as_int(); - RTLIL::SigSpec sig_rd_clk, sig_rd_en, sig_rd_data, sig_rd_addr; - bool use_rd_clk, rd_clk_posedge, rd_transparent; - // read ports - for (int i=0; i < nread_ports; i++) - { - sig_rd_clk = cell->getPort(ID::RD_CLK).extract(i); - sig_rd_en = cell->getPort(ID::RD_EN).extract(i); - sig_rd_data = cell->getPort(ID::RD_DATA).extract(i*width, width); - sig_rd_addr = cell->getPort(ID::RD_ADDR).extract(i*abits, abits); - use_rd_clk = cell->parameters[ID::RD_CLK_ENABLE].extract(i).as_bool(); - rd_clk_posedge = cell->parameters[ID::RD_CLK_POLARITY].extract(i).as_bool(); - rd_transparent = cell->parameters[ID::RD_TRANSPARENT].extract(i).as_bool(); - if (use_rd_clk) - { - { - std::ostringstream os; - dump_sigspec(os, sig_rd_clk); - clk_domain_str = stringf("%sedge %s", rd_clk_posedge ? "pos" : "neg", os.str().c_str()); - if( clk_to_lof_body.count(clk_domain_str) == 0 ) - clk_to_lof_body[clk_domain_str] = std::vector<std::string>(); - } - if (!rd_transparent) - { - // for clocked read ports make something like: - // reg [..] temp_id; - // always @(posedge clk) - // if (rd_en) temp_id <= array_reg[r_addr]; - // assign r_data = temp_id; - std::string temp_id = next_auto_id(); - lof_reg_declarations.push_back( stringf("reg [%d:0] %s;\n", sig_rd_data.size() - 1, temp_id.c_str()) ); - { - std::ostringstream os; - if (sig_rd_en != RTLIL::SigBit(true)) - { - os << stringf("if ("); - dump_sigspec(os, sig_rd_en); - os << stringf(") "); - } - os << stringf("%s <= %s[", temp_id.c_str(), mem_id.c_str()); - dump_sigspec(os, sig_rd_addr); - os << stringf("];\n"); - clk_to_lof_body[clk_domain_str].push_back(os.str()); - } - { - std::ostringstream os; - dump_sigspec(os, sig_rd_data); - std::string line = stringf("assign %s = %s;\n", os.str().c_str(), temp_id.c_str()); - clk_to_lof_body[""].push_back(line); - } - } - else - { - // for rd-transparent read-ports make something like: - // reg [..] temp_id; - // always @(posedge clk) - // temp_id <= r_addr; - // assign r_data = array_reg[temp_id]; - std::string temp_id = next_auto_id(); - lof_reg_declarations.push_back( stringf("reg [%d:0] %s;\n", sig_rd_addr.size() - 1, temp_id.c_str()) ); - { - std::ostringstream os; - dump_sigspec(os, sig_rd_addr); - std::string line = stringf("%s <= %s;\n", temp_id.c_str(), os.str().c_str()); - clk_to_lof_body[clk_domain_str].push_back(line); - } - { - std::ostringstream os; - dump_sigspec(os, sig_rd_data); - std::string line = stringf("assign %s = %s[%s];\n", os.str().c_str(), mem_id.c_str(), temp_id.c_str()); - clk_to_lof_body[""].push_back(line); - } - } - } else { - // for non-clocked read-ports make something like: - // assign r_data = array_reg[r_addr]; - std::ostringstream os, os2; - dump_sigspec(os, sig_rd_data); - dump_sigspec(os2, sig_rd_addr); - std::string line = stringf("assign %s = %s[%s];\n", os.str().c_str(), mem_id.c_str(), os2.str().c_str()); - clk_to_lof_body[""].push_back(line); - } - } - - int nwrite_ports = cell->parameters[ID::WR_PORTS].as_int(); - RTLIL::SigSpec sig_wr_clk, sig_wr_data, sig_wr_addr, sig_wr_en; - bool wr_clk_posedge; - - // write ports - for (int i=0; i < nwrite_ports; i++) - { - sig_wr_clk = cell->getPort(ID::WR_CLK).extract(i); - sig_wr_data = cell->getPort(ID::WR_DATA).extract(i*width, width); - sig_wr_addr = cell->getPort(ID::WR_ADDR).extract(i*abits, abits); - sig_wr_en = cell->getPort(ID::WR_EN).extract(i*width, width); - wr_clk_posedge = cell->parameters[ID::WR_CLK_POLARITY].extract(i).as_bool(); - { - std::ostringstream os; - dump_sigspec(os, sig_wr_clk); - clk_domain_str = stringf("%sedge %s", wr_clk_posedge ? "pos" : "neg", os.str().c_str()); - if( clk_to_lof_body.count(clk_domain_str) == 0 ) - clk_to_lof_body[clk_domain_str] = std::vector<std::string>(); - } - // make something like: - // always @(posedge clk) - // if (wr_en_bit) memid[w_addr][??] <= w_data[??]; - // ... - for (int i = 0; i < GetSize(sig_wr_en); i++) - { - int start_i = i, width = 1; - SigBit wen_bit = sig_wr_en[i]; - - while (i+1 < GetSize(sig_wr_en) && active_sigmap(sig_wr_en[i+1]) == active_sigmap(wen_bit)) - i++, width++; - - if (wen_bit == State::S0) - continue; - - std::ostringstream os; - if (wen_bit != State::S1) - { - os << stringf("if ("); - dump_sigspec(os, wen_bit); - os << stringf(") "); - } - os << stringf("%s[", mem_id.c_str()); - dump_sigspec(os, sig_wr_addr); - if (width == GetSize(sig_wr_en)) - os << stringf("] <= "); - else - os << stringf("][%d:%d] <= ", i, start_i); - dump_sigspec(os, sig_wr_data.extract(start_i, width)); - os << stringf(";\n"); - clk_to_lof_body[clk_domain_str].push_back(os.str()); - } - } - // Output Verilog that looks something like this: - // reg [..] _3_; - // always @(posedge CLK2) begin - // _3_ <= memory[D1ADDR]; - // if (A1EN) - // memory[A1ADDR] <= A1DATA; - // if (A2EN) - // memory[A2ADDR] <= A2DATA; - // ... - // end - // always @(negedge CLK1) begin - // if (C1EN) - // memory[C1ADDR] <= C1DATA; - // end - // ... - // assign D1DATA = _3_; - // assign D2DATA <= memory[D2ADDR]; - - // the reg ... definitions - for(auto ® : lof_reg_declarations) - { - f << stringf("%s" "%s", indent.c_str(), reg.c_str()); - } - // the block of expressions by clock domain - for(auto &pair : clk_to_lof_body) - { - std::string clk_domain = pair.first; - std::vector<std::string> lof_lines = pair.second; - if( clk_domain != "") - { - f << stringf("%s" "always%s @(%s) begin\n", indent.c_str(), systemverilog ? "_ff" : "", clk_domain.c_str()); - for(auto &line : lof_lines) - f << stringf("%s%s" "%s", indent.c_str(), indent.c_str(), line.c_str()); - f << stringf("%s" "end\n", indent.c_str()); - } - else - { - // the non-clocked assignments - for(auto &line : lof_lines) - f << stringf("%s" "%s", indent.c_str(), line.c_str()); - } - } - - return true; - } - if (cell->type.in(ID($assert), ID($assume), ID($cover))) { f << stringf("%s" "always%s if (", indent.c_str(), systemverilog ? "_comb" : " @*"); @@ -1483,13 +1456,17 @@ bool dump_cell_expr(std::ostream &f, std::string indent, RTLIL::Cell *cell) return true; } - // FIXME: $memrd, $memwr, $fsm + // FIXME: $fsm return false; } void dump_cell(std::ostream &f, std::string indent, RTLIL::Cell *cell) { + // Handled by dump_memory + if (cell->type.in(ID($mem), ID($memwr), ID($memrd), ID($meminit))) + return; + if (cell->type[0] == '$' && !noexpr) { if (dump_cell_expr(f, indent, cell)) return; @@ -1812,8 +1789,8 @@ void dump_module(std::ostream &f, std::string indent, RTLIL::Module *module) for (auto w : module->wires()) dump_wire(f, indent + " ", w); - for (auto it = module->memories.begin(); it != module->memories.end(); ++it) - dump_memory(f, indent + " ", it->second); + for (auto &mem : Mem::get_all_memories(module)) + dump_memory(f, indent + " ", mem); for (auto cell : module->cells()) dump_cell(f, indent + " ", cell); diff --git a/frontends/rpc/rpc_frontend.cc b/frontends/rpc/rpc_frontend.cc index 5a40001cb..c12640ef0 100644 --- a/frontends/rpc/rpc_frontend.cc +++ b/frontends/rpc/rpc_frontend.cc @@ -401,10 +401,11 @@ struct RpcFrontend : public Pass { std::string arg = args[argidx]; if (arg == "-exec" && argidx+1 < args.size()) { command.insert(command.begin(), args.begin() + argidx + 1, args.end()); + argidx = args.size()-1; continue; } if (arg == "-path" && argidx+1 < args.size()) { - path = args[argidx+1]; + path = args[++argidx]; continue; } break; diff --git a/kernel/mem.cc b/kernel/mem.cc new file mode 100644 index 000000000..0301a913c --- /dev/null +++ b/kernel/mem.cc @@ -0,0 +1,436 @@ +/* + * yosys -- Yosys Open SYnthesis Suite + * + * Copyright (C) 2020 Marcelina KoÅ›cielnicka <mwk@0x04.net> + * + * 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. + * + */ + +#include "kernel/mem.h" + +USING_YOSYS_NAMESPACE + +void Mem::remove() { + if (cell) { + module->remove(cell); + cell = nullptr; + } + if (mem) { + module->memories.erase(mem->name); + delete mem; + mem = nullptr; + } + for (auto &port : rd_ports) { + if (port.cell) { + module->remove(port.cell); + port.cell = nullptr; + } + } + for (auto &port : wr_ports) { + if (port.cell) { + module->remove(port.cell); + port.cell = nullptr; + } + } + for (auto &init : inits) { + if (init.cell) { + module->remove(init.cell); + init.cell = nullptr; + } + } +} + +void Mem::emit() { + if (packed) { + if (mem) { + module->memories.erase(mem->name); + delete mem; + mem = nullptr; + } + if (!cell) { + if (memid.empty()) + memid = NEW_ID; + cell = module->addCell(memid, ID($mem)); + } + cell->attributes = attributes; + cell->parameters[ID::MEMID] = Const(memid.str()); + cell->parameters[ID::WIDTH] = Const(width); + cell->parameters[ID::OFFSET] = Const(start_offset); + cell->parameters[ID::SIZE] = Const(size); + cell->parameters[ID::RD_PORTS] = Const(GetSize(rd_ports)); + cell->parameters[ID::WR_PORTS] = Const(GetSize(wr_ports)); + Const rd_clk_enable, rd_clk_polarity, rd_transparent; + Const wr_clk_enable, wr_clk_polarity; + SigSpec rd_clk, rd_en, rd_addr, rd_data; + SigSpec wr_clk, wr_en, wr_addr, wr_data; + int abits = 0; + for (auto &port : rd_ports) + abits = std::max(abits, GetSize(port.addr)); + for (auto &port : wr_ports) + abits = std::max(abits, GetSize(port.addr)); + cell->parameters[ID::ABITS] = Const(abits); + for (auto &port : rd_ports) { + if (port.cell) { + module->remove(port.cell); + port.cell = nullptr; + } + rd_clk_enable.bits.push_back(State(port.clk_enable)); + rd_clk_polarity.bits.push_back(State(port.clk_polarity)); + rd_transparent.bits.push_back(State(port.transparent)); + rd_clk.append(port.clk); + log_assert(GetSize(port.clk) == 1); + rd_en.append(port.en); + log_assert(GetSize(port.en) == 1); + SigSpec addr = port.addr; + addr.extend_u0(abits, false); + rd_addr.append(addr); + log_assert(GetSize(addr) == abits); + rd_data.append(port.data); + log_assert(GetSize(port.data) == width); + } + if (rd_ports.empty()) { + rd_clk_enable = State::S0; + rd_clk_polarity = State::S0; + rd_transparent = State::S0; + } + cell->parameters[ID::RD_CLK_ENABLE] = rd_clk_enable; + cell->parameters[ID::RD_CLK_POLARITY] = rd_clk_polarity; + cell->parameters[ID::RD_TRANSPARENT] = rd_transparent; + cell->setPort(ID::RD_CLK, rd_clk); + cell->setPort(ID::RD_EN, rd_en); + cell->setPort(ID::RD_ADDR, rd_addr); + cell->setPort(ID::RD_DATA, rd_data); + for (auto &port : wr_ports) { + if (port.cell) { + module->remove(port.cell); + port.cell = nullptr; + } + wr_clk_enable.bits.push_back(State(port.clk_enable)); + wr_clk_polarity.bits.push_back(State(port.clk_polarity)); + wr_clk.append(port.clk); + log_assert(GetSize(port.clk) == 1); + wr_en.append(port.en); + log_assert(GetSize(port.en) == width); + SigSpec addr = port.addr; + addr.extend_u0(abits, false); + wr_addr.append(addr); + log_assert(GetSize(addr) == abits); + wr_data.append(port.data); + log_assert(GetSize(port.data) == width); + } + if (wr_ports.empty()) { + wr_clk_enable = State::S0; + wr_clk_polarity = State::S0; + } + cell->parameters[ID::WR_CLK_ENABLE] = wr_clk_enable; + cell->parameters[ID::WR_CLK_POLARITY] = wr_clk_polarity; + cell->setPort(ID::WR_CLK, wr_clk); + cell->setPort(ID::WR_EN, wr_en); + cell->setPort(ID::WR_ADDR, wr_addr); + cell->setPort(ID::WR_DATA, wr_data); + for (auto &init : inits) { + if (init.cell) { + module->remove(init.cell); + init.cell = nullptr; + } + } + cell->parameters[ID::INIT] = get_init_data(); + } else { + if (cell) { + module->remove(cell); + cell = nullptr; + } + if (!mem) { + if (memid.empty()) + memid = NEW_ID; + mem = new RTLIL::Memory; + mem->name = memid; + module->memories[memid] = mem; + } + mem->width = width; + mem->start_offset = start_offset; + mem->size = size; + for (auto &port : rd_ports) { + if (!port.cell) + port.cell = module->addCell(NEW_ID, ID($memrd)); + port.cell->parameters[ID::MEMID] = memid.str(); + port.cell->parameters[ID::ABITS] = GetSize(port.addr); + port.cell->parameters[ID::WIDTH] = width; + port.cell->parameters[ID::CLK_ENABLE] = port.clk_enable; + port.cell->parameters[ID::CLK_POLARITY] = port.clk_polarity; + port.cell->parameters[ID::TRANSPARENT] = port.transparent; + port.cell->setPort(ID::CLK, port.clk); + port.cell->setPort(ID::EN, port.en); + port.cell->setPort(ID::ADDR, port.addr); + port.cell->setPort(ID::DATA, port.data); + } + int idx = 0; + for (auto &port : wr_ports) { + if (!port.cell) + port.cell = module->addCell(NEW_ID, ID($memwr)); + port.cell->parameters[ID::MEMID] = memid.str(); + port.cell->parameters[ID::ABITS] = GetSize(port.addr); + port.cell->parameters[ID::WIDTH] = width; + port.cell->parameters[ID::CLK_ENABLE] = port.clk_enable; + port.cell->parameters[ID::CLK_POLARITY] = port.clk_polarity; + port.cell->parameters[ID::PRIORITY] = idx++; + port.cell->setPort(ID::CLK, port.clk); + port.cell->setPort(ID::EN, port.en); + port.cell->setPort(ID::ADDR, port.addr); + port.cell->setPort(ID::DATA, port.data); + } + idx = 0; + for (auto &init : inits) { + if (!init.cell) + init.cell = module->addCell(NEW_ID, ID($meminit)); + init.cell->parameters[ID::MEMID] = memid.str(); + init.cell->parameters[ID::ABITS] = GetSize(init.addr); + init.cell->parameters[ID::WIDTH] = width; + init.cell->parameters[ID::WORDS] = GetSize(init.data) / width; + init.cell->parameters[ID::PRIORITY] = idx++; + init.cell->setPort(ID::ADDR, init.addr); + init.cell->setPort(ID::DATA, init.data); + } + } +} + +void Mem::remove_wr_port(int idx) { + if (wr_ports[idx].cell) { + module->remove(wr_ports[idx].cell); + } + wr_ports.erase(wr_ports.begin() + idx); +} + +void Mem::remove_rd_port(int idx) { + if (rd_ports[idx].cell) { + module->remove(rd_ports[idx].cell); + } + rd_ports.erase(rd_ports.begin() + idx); +} + +void Mem::clear_inits() { + for (auto &init : inits) + if (init.cell) + module->remove(init.cell); + inits.clear(); +} + +Const Mem::get_init_data() const { + Const init_data(State::Sx, width * size); + for (auto &init : inits) { + int offset = (init.addr.as_int() - start_offset) * width; + for (int i = 0; i < GetSize(init.data); i++) + if (0 <= i+offset && i+offset < GetSize(init_data)) + init_data.bits[i+offset] = init.data.bits[i]; + } + return init_data; +} + +namespace { + + struct MemIndex { + dict<IdString, pool<Cell *>> rd_ports; + dict<IdString, pool<Cell *>> wr_ports; + dict<IdString, pool<Cell *>> inits; + MemIndex (Module *module) { + for (auto cell: module->cells()) { + if (cell->type == ID($memwr)) + wr_ports[cell->parameters.at(ID::MEMID).decode_string()].insert(cell); + else if (cell->type == ID($memrd)) + rd_ports[cell->parameters.at(ID::MEMID).decode_string()].insert(cell); + else if (cell->type == ID($meminit)) + inits[cell->parameters.at(ID::MEMID).decode_string()].insert(cell); + } + } + }; + + Mem mem_from_memory(Module *module, RTLIL::Memory *mem, const MemIndex &index) { + Mem res(module, mem->name, mem->width, mem->start_offset, mem->size); + res.packed = false; + res.mem = mem; + res.attributes = mem->attributes; + if (index.rd_ports.count(mem->name)) { + for (auto cell : index.rd_ports.at(mem->name)) { + MemRd mrd; + mrd.cell = cell; + mrd.attributes = cell->attributes; + mrd.clk_enable = cell->parameters.at(ID::CLK_ENABLE).as_bool(); + mrd.clk_polarity = cell->parameters.at(ID::CLK_POLARITY).as_bool(); + mrd.transparent = cell->parameters.at(ID::TRANSPARENT).as_bool(); + mrd.clk = cell->getPort(ID::CLK); + mrd.en = cell->getPort(ID::EN); + mrd.addr = cell->getPort(ID::ADDR); + mrd.data = cell->getPort(ID::DATA); + res.rd_ports.push_back(mrd); + } + } + if (index.wr_ports.count(mem->name)) { + std::vector<std::pair<int, MemWr>> ports; + for (auto cell : index.wr_ports.at(mem->name)) { + MemWr mwr; + mwr.cell = cell; + mwr.attributes = cell->attributes; + mwr.clk_enable = cell->parameters.at(ID::CLK_ENABLE).as_bool(); + mwr.clk_polarity = cell->parameters.at(ID::CLK_POLARITY).as_bool(); + mwr.clk = cell->getPort(ID::CLK); + mwr.en = cell->getPort(ID::EN); + mwr.addr = cell->getPort(ID::ADDR); + mwr.data = cell->getPort(ID::DATA); + ports.push_back(std::make_pair(cell->parameters.at(ID::PRIORITY).as_int(), mwr)); + } + std::sort(ports.begin(), ports.end(), [](const std::pair<int, MemWr> &a, const std::pair<int, MemWr> &b) { return a.first < b.first; }); + for (auto &it : ports) + res.wr_ports.push_back(it.second); + } + if (index.inits.count(mem->name)) { + std::vector<std::pair<int, MemInit>> inits; + for (auto cell : index.inits.at(mem->name)) { + MemInit init; + init.cell = cell; + init.attributes = cell->attributes; + auto addr = cell->getPort(ID::ADDR); + auto data = cell->getPort(ID::DATA); + if (!addr.is_fully_const()) + log_error("Non-constant address %s in memory initialization %s.\n", log_signal(addr), log_id(cell)); + if (!data.is_fully_const()) + log_error("Non-constant data %s in memory initialization %s.\n", log_signal(data), log_id(cell)); + init.addr = addr.as_const(); + init.data = data.as_const(); + inits.push_back(std::make_pair(cell->parameters.at(ID::PRIORITY).as_int(), init)); + } + std::sort(inits.begin(), inits.end(), [](const std::pair<int, MemInit> &a, const std::pair<int, MemInit> &b) { return a.first < b.first; }); + for (auto &it : inits) + res.inits.push_back(it.second); + } + return res; + } + + Mem mem_from_cell(Cell *cell) { + Mem res(cell->module, cell->parameters.at(ID::MEMID).decode_string(), + cell->parameters.at(ID::WIDTH).as_int(), + cell->parameters.at(ID::OFFSET).as_int(), + cell->parameters.at(ID::SIZE).as_int() + ); + int abits = cell->parameters.at(ID::ABITS).as_int(); + res.packed = true; + res.cell = cell; + res.attributes = cell->attributes; + Const &init = cell->parameters.at(ID::INIT); + if (!init.is_fully_undef()) { + int pos = 0; + while (pos < res.size) { + Const word = init.extract(pos * res.width, res.width, State::Sx); + if (word.is_fully_undef()) { + pos++; + } else { + int epos; + for (epos = pos; epos < res.size; epos++) { + Const eword = init.extract(epos * res.width, res.width, State::Sx); + if (eword.is_fully_undef()) + break; + } + MemInit minit; + minit.addr = res.start_offset + pos; + minit.data = init.extract(pos * res.width, (epos - pos) * res.width, State::Sx); + res.inits.push_back(minit); + pos = epos; + } + } + } + for (int i = 0; i < cell->parameters.at(ID::RD_PORTS).as_int(); i++) { + MemRd mrd; + mrd.clk_enable = cell->parameters.at(ID::RD_CLK_ENABLE).extract(i, 1).as_bool(); + mrd.clk_polarity = cell->parameters.at(ID::RD_CLK_POLARITY).extract(i, 1).as_bool(); + mrd.transparent = cell->parameters.at(ID::RD_TRANSPARENT).extract(i, 1).as_bool(); + mrd.clk = cell->getPort(ID::RD_CLK).extract(i, 1); + mrd.en = cell->getPort(ID::RD_EN).extract(i, 1); + mrd.addr = cell->getPort(ID::RD_ADDR).extract(i * abits, abits); + mrd.data = cell->getPort(ID::RD_DATA).extract(i * res.width, res.width); + res.rd_ports.push_back(mrd); + } + for (int i = 0; i < cell->parameters.at(ID::WR_PORTS).as_int(); i++) { + MemWr mwr; + mwr.clk_enable = cell->parameters.at(ID::WR_CLK_ENABLE).extract(i, 1).as_bool(); + mwr.clk_polarity = cell->parameters.at(ID::WR_CLK_POLARITY).extract(i, 1).as_bool(); + mwr.clk = cell->getPort(ID::WR_CLK).extract(i, 1); + mwr.en = cell->getPort(ID::WR_EN).extract(i * res.width, res.width); + mwr.addr = cell->getPort(ID::WR_ADDR).extract(i * abits, abits); + mwr.data = cell->getPort(ID::WR_DATA).extract(i * res.width, res.width); + res.wr_ports.push_back(mwr); + } + return res; + } + +} + +std::vector<Mem> Mem::get_all_memories(Module *module) { + std::vector<Mem> res; + MemIndex index(module); + for (auto it: module->memories) { + res.push_back(mem_from_memory(module, it.second, index)); + } + for (auto cell: module->cells()) { + if (cell->type == ID($mem)) + res.push_back(mem_from_cell(cell)); + } + return res; +} + +std::vector<Mem> Mem::get_selected_memories(Module *module) { + std::vector<Mem> res; + MemIndex index(module); + for (auto it: module->memories) { + if (module->design->selected(module, it.second)) + res.push_back(mem_from_memory(module, it.second, index)); + } + for (auto cell: module->selected_cells()) { + if (cell->type == ID($mem)) + res.push_back(mem_from_cell(cell)); + } + return res; +} + +Cell *Mem::extract_rdff(int idx) { + MemRd &port = rd_ports[idx]; + + if (!port.clk_enable) + return nullptr; + + Cell *c; + + if (port.transparent) + { + SigSpec sig_q = module->addWire(stringf("%s$rdreg[%d]$q", memid.c_str(), idx), GetSize(port.addr)); + SigSpec sig_d = port.addr; + port.addr = sig_q; + c = module->addDffe(stringf("%s$rdreg[%d]", memid.c_str(), idx), port.clk, port.en, sig_d, sig_q, port.clk_polarity, true); + } + else + { + SigSpec sig_d = module->addWire(stringf("%s$rdreg[%d]$d", memid.c_str(), idx), width); + SigSpec sig_q = port.data; + port.data = sig_d; + c = module->addDffe(stringf("%s$rdreg[%d]", memid.c_str(), idx), port.clk, port.en, sig_d, sig_q, port.clk_polarity, true); + } + + log("Extracted %s FF from read port %d of %s.%s: %s\n", port.transparent ? "addr" : "data", + idx, log_id(module), log_id(memid), log_id(c)); + + port.en = State::S1; + port.clk = State::S0; + port.clk_enable = false; + port.clk_polarity = true; + + return c; +} diff --git a/kernel/mem.h b/kernel/mem.h new file mode 100644 index 000000000..6d727e71d --- /dev/null +++ b/kernel/mem.h @@ -0,0 +1,78 @@ +/* + * yosys -- Yosys Open SYnthesis Suite + * + * Copyright (C) 2020 Marcelina KoÅ›cielnicka <mwk@0x04.net> + * + * 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. + * + */ + +#ifndef MEM_H +#define MEM_H + +#include "kernel/yosys.h" + +YOSYS_NAMESPACE_BEGIN + +struct MemRd { + dict<IdString, Const> attributes; + Cell *cell; + bool clk_enable, clk_polarity; + bool transparent; + SigSpec clk, en, addr, data; + MemRd() : cell(nullptr) {} +}; + +struct MemWr { + dict<IdString, Const> attributes; + Cell *cell; + bool clk_enable, clk_polarity; + SigSpec clk, en, addr, data; + MemWr() : cell(nullptr) {} +}; + +struct MemInit { + dict<IdString, Const> attributes; + Cell *cell; + Const addr; + Const data; + MemInit() : cell(nullptr) {} +}; + +struct Mem { + Module *module; + IdString memid; + dict<IdString, Const> attributes; + bool packed; + RTLIL::Memory *mem; + Cell *cell; + int width, start_offset, size; + std::vector<MemInit> inits; + std::vector<MemRd> rd_ports; + std::vector<MemWr> wr_ports; + + void remove(); + void emit(); + void remove_wr_port(int idx); + void remove_rd_port(int idx); + void clear_inits(); + Const get_init_data() const; + static std::vector<Mem> get_all_memories(Module *module); + static std::vector<Mem> get_selected_memories(Module *module); + Cell *extract_rdff(int idx); + Mem(Module *module, IdString memid, int width, int start_offset, int size) : module(module), memid(memid), packed(false), mem(nullptr), cell(nullptr), width(width), start_offset(start_offset), size(size) {} +}; + +YOSYS_NAMESPACE_END + +#endif diff --git a/passes/memory/memory_bram.cc b/passes/memory/memory_bram.cc index 3cb0728b7..c6948fdba 100644 --- a/passes/memory/memory_bram.cc +++ b/passes/memory/memory_bram.cc @@ -18,6 +18,7 @@ */ #include "kernel/yosys.h" +#include "kernel/mem.h" USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN @@ -400,9 +401,11 @@ struct rules_t } }; -bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, const rules_t::match_t &match, dict<string, int> &match_properties, int mode) +bool replace_memory(Mem &orig_mem, const rules_t &rules, const rules_t::bram_t &bram, const rules_t::match_t &match, dict<string, int> &match_properties, int mode) { - Module *module = cell->module; + // We will modify ports — make a copy of the structure. + Mem mem(orig_mem); + Module *module = mem.module; auto portinfos = bram.make_portinfos(); int dup_count = 1; @@ -437,46 +440,17 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, log(" Mapping to bram type %s (variant %d):\n", log_id(bram.name), bram.variant); // bram.dump_config(); - int mem_size = cell->getParam(ID::SIZE).as_int(); - int mem_abits = cell->getParam(ID::ABITS).as_int(); - int mem_width = cell->getParam(ID::WIDTH).as_int(); - // int mem_offset = cell->getParam(ID::OFFSET).as_int(); - - bool cell_init = !SigSpec(cell->getParam(ID::INIT)).is_fully_undef(); + bool cell_init = !mem.inits.empty(); vector<Const> initdata; if (cell_init) { - Const initparam = cell->getParam(ID::INIT); - initdata.reserve(mem_size); - for (int i=0; i < mem_size; i++) - initdata.push_back(initparam.extract(mem_width*i, mem_width, State::Sx)); + Const initparam = mem.get_init_data(); + initdata.reserve(mem.size); + for (int i=0; i < mem.size; i++) + initdata.push_back(initparam.extract(mem.width*i, mem.width, State::Sx)); } - int wr_ports = cell->getParam(ID::WR_PORTS).as_int(); - auto wr_clken = SigSpec(cell->getParam(ID::WR_CLK_ENABLE)); - auto wr_clkpol = SigSpec(cell->getParam(ID::WR_CLK_POLARITY)); - wr_clken.extend_u0(wr_ports); - wr_clkpol.extend_u0(wr_ports); - - SigSpec wr_en = cell->getPort(ID::WR_EN); - SigSpec wr_clk = cell->getPort(ID::WR_CLK); - SigSpec wr_data = cell->getPort(ID::WR_DATA); - SigSpec wr_addr = cell->getPort(ID::WR_ADDR); - - int rd_ports = cell->getParam(ID::RD_PORTS).as_int(); - auto rd_clken = SigSpec(cell->getParam(ID::RD_CLK_ENABLE)); - auto rd_clkpol = SigSpec(cell->getParam(ID::RD_CLK_POLARITY)); - auto rd_transp = SigSpec(cell->getParam(ID::RD_TRANSPARENT)); - rd_clken.extend_u0(rd_ports); - rd_clkpol.extend_u0(rd_ports); - rd_transp.extend_u0(rd_ports); - - SigSpec rd_en = cell->getPort(ID::RD_EN); - SigSpec rd_clk = cell->getPort(ID::RD_CLK); - SigSpec rd_data = cell->getPort(ID::RD_DATA); - SigSpec rd_addr = cell->getPort(ID::RD_ADDR); - - if (match.shuffle_enable && bram.dbits >= portinfos.at(match.shuffle_enable - 'A').enable*2 && portinfos.at(match.shuffle_enable - 'A').enable > 0 && wr_ports > 0) + if (match.shuffle_enable && bram.dbits >= portinfos.at(match.shuffle_enable - 'A').enable*2 && portinfos.at(match.shuffle_enable - 'A').enable > 0 && !mem.wr_ports.empty()) { int bucket_size = bram.dbits / portinfos.at(match.shuffle_enable - 'A').enable; log(" Shuffle bit order to accommodate enable buckets of size %d..\n", bucket_size); @@ -487,23 +461,23 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, std::vector<SigSpec> old_wr_data; std::vector<SigSpec> old_rd_data; - for (int i = 0; i < wr_ports; i++) { - old_wr_en.push_back(wr_en.extract(i*mem_width, mem_width)); - old_wr_data.push_back(wr_data.extract(i*mem_width, mem_width)); + for (auto &port : mem.wr_ports) { + old_wr_en.push_back(port.en); + old_wr_data.push_back(port.data); } - for (int i = 0; i < rd_ports; i++) - old_rd_data.push_back(rd_data.extract(i*mem_width, mem_width)); + for (auto &port : mem.rd_ports) + old_rd_data.push_back(port.data); // analyze enable structure std::vector<SigSpec> en_order; dict<SigSpec, vector<int>> bits_wr_en; - for (int i = 0; i < mem_width; i++) { + for (int i = 0; i < mem.width; i++) { SigSpec sig; - for (int j = 0; j < wr_ports; j++) - sig.append(old_wr_en[j][i]); + for (auto &port : mem.wr_ports) + sig.append(port.en[i]); if (bits_wr_en.count(sig) == 0) en_order.push_back(sig); bits_wr_en[sig].push_back(i); @@ -518,7 +492,7 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, std::vector<int> shuffle_map; if (cell_init) - new_initdata.resize(mem_size); + new_initdata.resize(mem.size); for (auto &it : en_order) { @@ -528,29 +502,29 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, SigBit fillbit; for (int i = 0; i < GetSize(bits); i++) { - for (int j = 0; j < wr_ports; j++) { + for (int j = 0; j < GetSize(mem.wr_ports); j++) { new_wr_en[j].append(old_wr_en[j][bits[i]]); new_wr_data[j].append(old_wr_data[j][bits[i]]); fillbit = old_wr_en[j][bits[i]]; } - for (int j = 0; j < rd_ports; j++) + for (int j = 0; j < GetSize(mem.rd_ports); j++) new_rd_data[j].append(old_rd_data[j][bits[i]]); if (cell_init) { - for (int j = 0; j < mem_size; j++) + for (int j = 0; j < mem.size; j++) new_initdata[j].push_back(initdata[j][bits[i]]); } shuffle_map.push_back(bits[i]); } for (int i = 0; i < fillbits; i++) { - for (int j = 0; j < wr_ports; j++) { + for (int j = 0; j < GetSize(mem.wr_ports); j++) { new_wr_en[j].append(fillbit); new_wr_data[j].append(State::S0); } - for (int j = 0; j < rd_ports; j++) + for (int j = 0; j < GetSize(mem.rd_ports); j++) new_rd_data[j].append(State::Sx); if (cell_init) { - for (int j = 0; j < mem_size; j++) + for (int j = 0; j < mem.size; j++) new_initdata[j].push_back(State::Sx); } shuffle_map.push_back(-1); @@ -564,40 +538,38 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, // update mem_*, wr_*, and rd_* variables - mem_width = GetSize(new_wr_en.front()); - wr_en = SigSpec(0, wr_ports * mem_width); - wr_data = SigSpec(0, wr_ports * mem_width); - rd_data = SigSpec(0, rd_ports * mem_width); + mem.width = GetSize(new_wr_en.front()); - for (int i = 0; i < wr_ports; i++) { - wr_en.replace(i*mem_width, new_wr_en[i]); - wr_data.replace(i*mem_width, new_wr_data[i]); + for (int i = 0; i < GetSize(mem.wr_ports); i++) { + auto &port = mem.wr_ports[i]; + port.en = new_wr_en[i]; + port.data = new_wr_data[i]; } - for (int i = 0; i < rd_ports; i++) - rd_data.replace(i*mem_width, new_rd_data[i]); + for (int i = 0; i < GetSize(mem.rd_ports); i++) { + auto &port = mem.rd_ports[i]; + port.data = new_rd_data[i]; + } if (cell_init) { - for (int i = 0; i < mem_size; i++) + for (int i = 0; i < mem.size; i++) initdata[i] = Const(new_initdata[i]); } } // assign write ports pair<SigBit, bool> wr_clkdom; - for (int cell_port_i = 0, bram_port_i = 0; cell_port_i < wr_ports; cell_port_i++) + for (int cell_port_i = 0, bram_port_i = 0; cell_port_i < GetSize(mem.wr_ports); cell_port_i++) { - bool clken = wr_clken[cell_port_i] == State::S1; - bool clkpol = wr_clkpol[cell_port_i] == State::S1; - SigBit clksig = wr_clk[cell_port_i]; + auto &port = mem.wr_ports[cell_port_i]; - pair<SigBit, bool> clkdom(clksig, clkpol); - if (!clken) + pair<SigBit, bool> clkdom(port.clk, port.clk_polarity); + if (!port.clk_enable) clkdom = pair<SigBit, bool>(State::S1, false); wr_clkdom = clkdom; log(" Write port #%d is in clock domain %s%s.\n", cell_port_i, clkdom.second ? "" : "!", - clken ? log_signal(clkdom.first) : "~async~"); + port.clk_enable ? log_signal(clkdom.first) : "~async~"); for (; bram_port_i < GetSize(portinfos); bram_port_i++) { @@ -609,7 +581,7 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, skip_bram_wport: continue; - if (clken) { + if (port.clk_enable) { if (pi.clocks == 0) { log(" Bram port %c%d has incompatible clock type.\n", pi.group + 'A', pi.index + 1); goto skip_bram_wport; @@ -618,7 +590,7 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, log(" Bram port %c%d is in a different clock domain.\n", pi.group + 'A', pi.index + 1); goto skip_bram_wport; } - if (clock_polarities.count(pi.clkpol) && clock_polarities.at(pi.clkpol) != clkpol) { + if (clock_polarities.count(pi.clkpol) && clock_polarities.at(pi.clkpol) != port.clk_polarity) { log(" Bram port %c%d has incompatible clock polarity.\n", pi.group + 'A', pi.index + 1); goto skip_bram_wport; } @@ -631,12 +603,12 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, SigSpec sig_en; SigBit last_en_bit = State::S1; - for (int i = 0; i < mem_width; i++) { + for (int i = 0; i < mem.width; i++) { if (pi.enable && i % (bram.dbits / pi.enable) == 0) { - last_en_bit = wr_en[i + cell_port_i*mem_width]; + last_en_bit = port.en[i]; sig_en.append(last_en_bit); } - if (last_en_bit != wr_en[i + cell_port_i*mem_width]) { + if (last_en_bit != port.en[i]) { log(" Bram port %c%d has incompatible enable structure.\n", pi.group + 'A', pi.index + 1); goto skip_bram_wport; } @@ -645,7 +617,7 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, log(" Mapped to bram port %c%d.\n", pi.group + 'A', pi.index + 1); pi.mapped_port = cell_port_i; - if (clken) { + if (port.clk_enable) { clock_domains[pi.clocks] = clkdom; clock_polarities[pi.clkpol] = clkdom.second; pi.sig_clock = clkdom.first; @@ -653,8 +625,8 @@ bool replace_cell(Cell *cell, const rules_t &rules, const rules_t::bram_t &bram, } pi.sig_en = sig_en; - pi.sig_addr = wr_addr.extract(cell_port_i*mem_abits, mem_abits); - pi.sig_data = wr_data.extract(cell_port_i*mem_width, mem_width); + pi.sig_addr = port.addr; + pi.sig_data = port.data; bram_port_i++; goto mapped_wr_port; @@ -710,23 +682,21 @@ grow_read_ports:; // assign read ports - for (int cell_port_i = 0; cell_port_i < rd_ports; cell_port_i++) + for (int cell_port_i = 0; cell_port_i < GetSize(mem.rd_ports); cell_port_i++) { - bool clken = rd_clken[cell_port_i] == State::S1; - bool clkpol = rd_clkpol[cell_port_i] == State::S1; - bool transp = rd_transp[cell_port_i] == State::S1; - SigBit clksig = rd_clk[cell_port_i]; + auto &port = mem.rd_ports[cell_port_i]; + bool transp = port.transparent; - if (wr_ports == 0) + if (mem.wr_ports.empty()) transp = false; - pair<SigBit, bool> clkdom(clksig, clkpol); - if (!clken) + pair<SigBit, bool> clkdom(port.clk, port.clk_polarity); + if (!port.clk_enable) clkdom = pair<SigBit, bool>(State::S1, false); log(" Read port #%d is in clock domain %s%s.\n", cell_port_i, clkdom.second ? "" : "!", - clken ? log_signal(clkdom.first) : "~async~"); + port.clk_enable ? log_signal(clkdom.first) : "~async~"); for (int bram_port_i = 0; bram_port_i < GetSize(portinfos); bram_port_i++) { @@ -736,7 +706,7 @@ grow_read_ports:; skip_bram_rport: continue; - if (clken) { + if (port.clk_enable) { if (pi.clocks == 0) { if (match.make_outreg) { pi.make_outreg = true; @@ -749,20 +719,20 @@ grow_read_ports:; log(" Bram port %c%d.%d is in a different clock domain.\n", pi.group + 'A', pi.index + 1, pi.dupidx + 1); goto skip_bram_rport; } - if (clock_polarities.count(pi.clkpol) && clock_polarities.at(pi.clkpol) != clkpol) { + if (clock_polarities.count(pi.clkpol) && clock_polarities.at(pi.clkpol) != port.clk_polarity) { log(" Bram port %c%d.%d has incompatible clock polarity.\n", pi.group + 'A', pi.index + 1, pi.dupidx + 1); goto skip_bram_rport; } - if (rd_en[cell_port_i] != State::S1 && pi.enable == 0) { + if (port.en != State::S1 && pi.enable == 0) { log(" Bram port %c%d.%d has no read enable input.\n", pi.group + 'A', pi.index + 1, pi.dupidx + 1); goto skip_bram_rport; } skip_bram_rport_clkcheck: if (read_transp.count(pi.transp) && read_transp.at(pi.transp) != transp) { - if (match.make_transp && wr_ports <= 1) { + if (match.make_transp && GetSize(mem.wr_ports) <= 1) { pi.make_transp = true; if (pi.clocks != 0) { - if (wr_ports == 1 && wr_clkdom != clkdom) { + if (GetSize(mem.wr_ports) == 1 && wr_clkdom != clkdom) { log(" Bram port %c%d.%d cannot have soft transparency logic added as read and write clock domains differ.\n", pi.group + 'A', pi.index + 1, pi.dupidx + 1); goto skip_bram_rport; } @@ -783,18 +753,18 @@ grow_read_ports:; log(" Mapped to bram port %c%d.%d.\n", pi.group + 'A', pi.index + 1, pi.dupidx + 1); pi.mapped_port = cell_port_i; - if (clken) { + if (port.clk_enable) { clock_domains[pi.clocks] = clkdom; clock_polarities[pi.clkpol] = clkdom.second; if (!pi.make_transp) read_transp[pi.transp] = transp; pi.sig_clock = clkdom.first; - pi.sig_en = rd_en[cell_port_i]; + pi.sig_en = port.en; pi.effective_clkpol = clkdom.second; } - pi.sig_addr = rd_addr.extract(cell_port_i*mem_abits, mem_abits); - pi.sig_data = rd_data.extract(cell_port_i*mem_width, mem_width); + pi.sig_addr = port.addr; + pi.sig_data = port.data; if (grow_read_ports_cursor < cell_port_i) { grow_read_ports_cursor = cell_port_i; @@ -820,11 +790,11 @@ grow_read_ports:; match_properties["dups"] = dup_count; match_properties["waste"] = match_properties["dups"] * match_properties["bwaste"]; - int cells = ((mem_width + bram.dbits - 1) / bram.dbits) * ((mem_size + (1 << bram.abits) - 1) / (1 << bram.abits)); + int cells = ((mem.width + bram.dbits - 1) / bram.dbits) * ((mem.size + (1 << bram.abits) - 1) / (1 << bram.abits)); match_properties["efficiency"] = (100 * match_properties["bits"]) / (dup_count * cells * bram.dbits * (1 << bram.abits)); - match_properties["dcells"] = ((mem_width + bram.dbits - 1) / bram.dbits); - match_properties["acells"] = ((mem_size + (1 << bram.abits) - 1) / (1 << bram.abits)); + match_properties["dcells"] = ((mem.width + bram.dbits - 1) / bram.dbits); + match_properties["acells"] = ((mem.size + (1 << bram.abits) - 1) / (1 << bram.abits)); match_properties["cells"] = match_properties["dcells"] * match_properties["acells"] * match_properties["dups"]; log(" Updated properties: dups=%d waste=%d efficiency=%d\n", @@ -857,8 +827,8 @@ grow_read_ports:; bool exists = std::get<0>(term); IdString key = std::get<1>(term); const Const &value = std::get<2>(term); - auto it = cell->attributes.find(key); - if (it == cell->attributes.end()) { + auto it = mem.attributes.find(key); + if (it == mem.attributes.end()) { if (exists) continue; found = true; @@ -902,7 +872,7 @@ grow_read_ports:; dict<SigSpec, pair<SigSpec, SigSpec>> dout_cache; - for (int grid_d = 0; grid_d*bram.dbits < mem_width; grid_d++) + for (int grid_d = 0; grid_d*bram.dbits < mem.width; grid_d++) { SigSpec mktr_wraddr, mktr_wrdata, mktr_wrdata_q; vector<SigSpec> mktr_wren; @@ -912,14 +882,14 @@ grow_read_ports:; mktr_wrdata = module->addWire(NEW_ID, bram.dbits); mktr_wrdata_q = module->addWire(NEW_ID, bram.dbits); module->addDff(NEW_ID, make_transp_clk.first, mktr_wrdata, mktr_wrdata_q, make_transp_clk.second); - for (int grid_a = 0; grid_a*(1 << bram.abits) < mem_size; grid_a++) + for (int grid_a = 0; grid_a*(1 << bram.abits) < mem.size; grid_a++) mktr_wren.push_back(module->addWire(NEW_ID, make_transp_enbits)); } - for (int grid_a = 0; grid_a*(1 << bram.abits) < mem_size; grid_a++) + for (int grid_a = 0; grid_a*(1 << bram.abits) < mem.size; grid_a++) for (int dupidx = 0; dupidx < dup_count; dupidx++) { - Cell *c = module->addCell(module->uniquify(stringf("%s.%d.%d.%d", cell->name.c_str(), grid_d, grid_a, dupidx)), bram.name); + Cell *c = module->addCell(module->uniquify(stringf("%s.%d.%d.%d", mem.memid.c_str(), grid_d, grid_a, dupidx)), bram.name); log(" Creating %s cell at grid position <%d %d %d>: %s\n", log_id(bram.name), grid_d, grid_a, dupidx, log_id(c)); for (auto &vp : variant_params) @@ -1063,22 +1033,22 @@ grow_read_ports:; } } - module->remove(cell); + mem.remove(); return true; } -void handle_cell(Cell *cell, const rules_t &rules) +void handle_memory(Mem &mem, const rules_t &rules) { - log("Processing %s.%s:\n", log_id(cell->module), log_id(cell)); + log("Processing %s.%s:\n", log_id(mem.module), log_id(mem.memid)); - bool cell_init = !SigSpec(cell->getParam(ID::INIT)).is_fully_undef(); + bool cell_init = !mem.inits.empty(); dict<string, int> match_properties; - match_properties["words"] = cell->getParam(ID::SIZE).as_int(); - match_properties["abits"] = cell->getParam(ID::ABITS).as_int(); - match_properties["dbits"] = cell->getParam(ID::WIDTH).as_int(); - match_properties["wports"] = cell->getParam(ID::WR_PORTS).as_int(); - match_properties["rports"] = cell->getParam(ID::RD_PORTS).as_int(); + match_properties["words"] = mem.size; + match_properties["abits"] = ceil_log2(mem.size); + match_properties["dbits"] = mem.width; + match_properties["wports"] = GetSize(mem.wr_ports); + match_properties["rports"] = GetSize(mem.rd_ports); match_properties["bits"] = match_properties["words"] * match_properties["dbits"]; match_properties["ports"] = match_properties["wports"] + match_properties["rports"]; @@ -1181,8 +1151,8 @@ void handle_cell(Cell *cell, const rules_t &rules) bool exists = std::get<0>(term); IdString key = std::get<1>(term); const Const &value = std::get<2>(term); - auto it = cell->attributes.find(key); - if (it == cell->attributes.end()) { + auto it = mem.attributes.find(key); + if (it == mem.attributes.end()) { if (exists) continue; found = true; @@ -1219,7 +1189,7 @@ void handle_cell(Cell *cell, const rules_t &rules) if (or_next_if_better && i+1 == GetSize(rules.matches) && vi+1 == GetSize(rules.brams.at(match.name))) log_error("Found 'or_next_if_better' in last match rule.\n"); - if (!replace_cell(cell, rules, bram, match, match_properties, 1)) { + if (!replace_memory(mem, rules, bram, match, match_properties, 1)) { log(" Mapping to bram type %s failed.\n", log_id(match.name)); failed_brams.insert(pair<IdString, int>(bram.name, bram.variant)); goto next_match_rule; @@ -1246,12 +1216,12 @@ void handle_cell(Cell *cell, const rules_t &rules) best_rule_cache.clear(); auto &best_bram = rules.brams.at(rules.matches.at(best_rule.first).name).at(best_rule.second); - if (!replace_cell(cell, rules, best_bram, rules.matches.at(best_rule.first), match_properties, 2)) + if (!replace_memory(mem, rules, best_bram, rules.matches.at(best_rule.first), match_properties, 2)) log_error("Mapping to bram type %s (variant %d) after pre-selection failed.\n", log_id(best_bram.name), best_bram.variant); return; } - if (!replace_cell(cell, rules, bram, match, match_properties, 0)) { + if (!replace_memory(mem, rules, bram, match, match_properties, 0)) { log(" Mapping to bram type %s failed.\n", log_id(match.name)); failed_brams.insert(pair<IdString, int>(bram.name, bram.variant)); goto next_match_rule; @@ -1384,9 +1354,8 @@ struct MemoryBramPass : public Pass { extra_args(args, argidx, design); for (auto mod : design->selected_modules()) - for (auto cell : mod->selected_cells()) - if (cell->type == ID($mem)) - handle_cell(cell, rules); + for (auto &mem : Mem::get_selected_memories(mod)) + handle_memory(mem, rules); } } MemoryBramPass; diff --git a/passes/memory/memory_collect.cc b/passes/memory/memory_collect.cc index 7e82f47dc..ede6ca6a1 100644 --- a/passes/memory/memory_collect.cc +++ b/passes/memory/memory_collect.cc @@ -18,231 +18,11 @@ */ #include "kernel/yosys.h" -#include "kernel/sigtools.h" +#include "kernel/mem.h" USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN -bool memcells_cmp(Cell *a, Cell *b) -{ - if (a->type == ID($memrd) && b->type == ID($memrd)) - return a->name < b->name; - if (a->type == ID($memrd) || b->type == ID($memrd)) - return (a->type == ID($memrd)) < (b->type == ID($memrd)); - return a->parameters.at(ID::PRIORITY).as_int() < b->parameters.at(ID::PRIORITY).as_int(); -} - -Cell *handle_memory(Module *module, RTLIL::Memory *memory) -{ - log("Collecting $memrd, $memwr and $meminit for memory `%s' in module `%s':\n", - memory->name.c_str(), module->name.c_str()); - - Const init_data(State::Sx, memory->size * memory->width); - SigMap sigmap(module); - - int wr_ports = 0; - SigSpec sig_wr_clk; - SigSpec sig_wr_clk_enable; - SigSpec sig_wr_clk_polarity; - SigSpec sig_wr_addr; - SigSpec sig_wr_data; - SigSpec sig_wr_en; - - int rd_ports = 0; - SigSpec sig_rd_clk; - SigSpec sig_rd_clk_enable; - SigSpec sig_rd_clk_polarity; - SigSpec sig_rd_transparent; - SigSpec sig_rd_addr; - SigSpec sig_rd_data; - SigSpec sig_rd_en; - - int addr_bits = 0; - std::vector<Cell*> memcells; - - for (auto cell : module->cells()) - if (cell->type.in(ID($memrd), ID($memwr), ID($meminit)) && memory->name == cell->parameters[ID::MEMID].decode_string()) { - SigSpec addr = sigmap(cell->getPort(ID::ADDR)); - for (int i = 0; i < GetSize(addr); i++) - if (addr[i] != State::S0) - addr_bits = std::max(addr_bits, i+1); - memcells.push_back(cell); - } - - if (memory->start_offset == 0 && addr_bits < 30 && (1 << addr_bits) < memory->size) - memory->size = 1 << addr_bits; - - if (memory->start_offset >= 0) - addr_bits = std::min(addr_bits, ceil_log2(memory->size + memory->start_offset)); - - addr_bits = std::max(addr_bits, 1); - - if (memcells.empty()) { - log(" no cells found. removing memory.\n"); - return nullptr; - } - - std::sort(memcells.begin(), memcells.end(), memcells_cmp); - - for (auto cell : memcells) - { - log(" %s (%s)\n", log_id(cell), log_id(cell->type)); - - if (cell->type == ID($meminit)) - { - SigSpec addr = sigmap(cell->getPort(ID::ADDR)); - SigSpec data = sigmap(cell->getPort(ID::DATA)); - - if (!addr.is_fully_const()) - log_error("Non-constant address %s in memory initialization %s.\n", log_signal(addr), log_id(cell)); - if (!data.is_fully_const()) - log_error("Non-constant data %s in memory initialization %s.\n", log_signal(data), log_id(cell)); - - int offset = (addr.as_int() - memory->start_offset) * memory->width; - - if (offset < 0 || offset + GetSize(data) > GetSize(init_data)) - log_warning("Address %s in memory initialization %s is out-of-bounds.\n", log_signal(addr), log_id(cell)); - - for (int i = 0; i < GetSize(data); i++) - if (0 <= i+offset && i+offset < GetSize(init_data)) - init_data.bits[i+offset] = data[i].data; - - continue; - } - - if (cell->type == ID($memwr)) - { - SigSpec clk = sigmap(cell->getPort(ID::CLK)); - SigSpec clk_enable = SigSpec(cell->parameters[ID::CLK_ENABLE]); - SigSpec clk_polarity = SigSpec(cell->parameters[ID::CLK_POLARITY]); - SigSpec addr = sigmap(cell->getPort(ID::ADDR)); - SigSpec data = sigmap(cell->getPort(ID::DATA)); - SigSpec en = sigmap(cell->getPort(ID::EN)); - - if (!en.is_fully_zero()) - { - clk.extend_u0(1, false); - clk_enable.extend_u0(1, false); - clk_polarity.extend_u0(1, false); - addr.extend_u0(addr_bits, false); - data.extend_u0(memory->width, false); - en.extend_u0(memory->width, false); - - sig_wr_clk.append(clk); - sig_wr_clk_enable.append(clk_enable); - sig_wr_clk_polarity.append(clk_polarity); - sig_wr_addr.append(addr); - sig_wr_data.append(data); - sig_wr_en.append(en); - - wr_ports++; - } - continue; - } - - if (cell->type == ID($memrd)) - { - SigSpec clk = sigmap(cell->getPort(ID::CLK)); - SigSpec clk_enable = SigSpec(cell->parameters[ID::CLK_ENABLE]); - SigSpec clk_polarity = SigSpec(cell->parameters[ID::CLK_POLARITY]); - SigSpec transparent = SigSpec(cell->parameters[ID::TRANSPARENT]); - SigSpec addr = sigmap(cell->getPort(ID::ADDR)); - SigSpec data = sigmap(cell->getPort(ID::DATA)); - SigSpec en = sigmap(cell->getPort(ID::EN)); - - if (!en.is_fully_zero()) - { - clk.extend_u0(1, false); - clk_enable.extend_u0(1, false); - clk_polarity.extend_u0(1, false); - transparent.extend_u0(1, false); - addr.extend_u0(addr_bits, false); - data.extend_u0(memory->width, false); - - sig_rd_clk.append(clk); - sig_rd_clk_enable.append(clk_enable); - sig_rd_clk_polarity.append(clk_polarity); - sig_rd_transparent.append(transparent); - sig_rd_addr.append(addr); - sig_rd_data.append(data); - sig_rd_en.append(en); - - rd_ports++; - } - continue; - } - } - - std::stringstream sstr; - sstr << "$mem$" << memory->name.str() << "$" << (autoidx++); - - Cell *mem = module->addCell(sstr.str(), ID($mem)); - mem->parameters[ID::MEMID] = Const(memory->name.str()); - mem->parameters[ID::WIDTH] = Const(memory->width); - mem->parameters[ID::OFFSET] = Const(memory->start_offset); - mem->parameters[ID::SIZE] = Const(memory->size); - mem->parameters[ID::ABITS] = Const(addr_bits); - mem->parameters[ID::INIT] = init_data; - - log_assert(sig_wr_clk.size() == wr_ports); - log_assert(sig_wr_clk_enable.size() == wr_ports && sig_wr_clk_enable.is_fully_const()); - log_assert(sig_wr_clk_polarity.size() == wr_ports && sig_wr_clk_polarity.is_fully_const()); - log_assert(sig_wr_addr.size() == wr_ports * addr_bits); - log_assert(sig_wr_data.size() == wr_ports * memory->width); - log_assert(sig_wr_en.size() == wr_ports * memory->width); - - mem->parameters[ID::WR_PORTS] = Const(wr_ports); - mem->parameters[ID::WR_CLK_ENABLE] = wr_ports ? sig_wr_clk_enable.as_const() : State::S0; - mem->parameters[ID::WR_CLK_POLARITY] = wr_ports ? sig_wr_clk_polarity.as_const() : State::S0; - - mem->setPort(ID::WR_CLK, sig_wr_clk); - mem->setPort(ID::WR_ADDR, sig_wr_addr); - mem->setPort(ID::WR_DATA, sig_wr_data); - mem->setPort(ID::WR_EN, sig_wr_en); - - log_assert(sig_rd_clk.size() == rd_ports); - log_assert(sig_rd_clk_enable.size() == rd_ports && sig_rd_clk_enable.is_fully_const()); - log_assert(sig_rd_clk_polarity.size() == rd_ports && sig_rd_clk_polarity.is_fully_const()); - log_assert(sig_rd_addr.size() == rd_ports * addr_bits); - log_assert(sig_rd_data.size() == rd_ports * memory->width); - - mem->parameters[ID::RD_PORTS] = Const(rd_ports); - mem->parameters[ID::RD_CLK_ENABLE] = rd_ports ? sig_rd_clk_enable.as_const() : State::S0; - mem->parameters[ID::RD_CLK_POLARITY] = rd_ports ? sig_rd_clk_polarity.as_const() : State::S0; - mem->parameters[ID::RD_TRANSPARENT] = rd_ports ? sig_rd_transparent.as_const() : State::S0; - - mem->setPort(ID::RD_CLK, sig_rd_clk); - mem->setPort(ID::RD_ADDR, sig_rd_addr); - mem->setPort(ID::RD_DATA, sig_rd_data); - mem->setPort(ID::RD_EN, sig_rd_en); - - // Copy attributes from RTLIL memory to $mem - for (auto attr : memory->attributes) - mem->attributes[attr.first] = attr.second; - - for (auto c : memcells) - module->remove(c); - - return mem; -} - -static void handle_module(Design *design, Module *module) -{ - std::vector<pair<Cell*, IdString>> finqueue; - - for (auto &mem_it : module->memories) - if (design->selected(module, mem_it.second)) { - Cell *c = handle_memory(module, mem_it.second); - finqueue.push_back(pair<Cell*, IdString>(c, mem_it.first)); - } - for (auto &it : finqueue) { - delete module->memories.at(it.second); - module->memories.erase(it.second); - if (it.first) - module->rename(it.first, it.second); - } -} - struct MemoryCollectPass : public Pass { MemoryCollectPass() : Pass("memory_collect", "creating multi-port memory cells") { } void help() override @@ -258,8 +38,14 @@ struct MemoryCollectPass : public Pass { void execute(std::vector<std::string> args, RTLIL::Design *design) override { log_header(design, "Executing MEMORY_COLLECT pass (generating $mem cells).\n"); extra_args(args, 1, design); - for (auto module : design->selected_modules()) - handle_module(design, module); + for (auto module : design->selected_modules()) { + for (auto &mem : Mem::get_selected_memories(module)) { + if (!mem.packed) { + mem.packed = true; + mem.emit(); + } + } + } } } MemoryCollectPass; diff --git a/passes/memory/memory_dff.cc b/passes/memory/memory_dff.cc index 68023fd11..4adcb462e 100644 --- a/passes/memory/memory_dff.cc +++ b/passes/memory/memory_dff.cc @@ -46,8 +46,15 @@ struct MemoryDffWorker { sigmap.apply(sig); + dict<SigBit, SigBit> cache; + for (auto &bit : sig) { + if (cache.count(bit)) { + bit = cache[bit]; + continue; + } + if (bit.wire == NULL) continue; @@ -103,6 +110,7 @@ struct MemoryDffWorker d = module->Mux(NEW_ID, rbit, d, cell->getPort(ID::SRST)); } + cache[bit] = d; bit = d; clk = this_clk; clk_polarity = this_clk_polarity; diff --git a/passes/memory/memory_map.cc b/passes/memory/memory_map.cc index 80dd3957d..032b8fbbd 100644 --- a/passes/memory/memory_map.cc +++ b/passes/memory/memory_map.cc @@ -19,6 +19,7 @@ #include "kernel/register.h" #include "kernel/log.h" +#include "kernel/mem.h" #include <sstream> #include <set> #include <stdlib.h> @@ -97,35 +98,26 @@ struct MemoryMapWorker return bit.wire; } - void handle_cell(RTLIL::Cell *cell) + void handle_memory(Mem &mem) { std::set<int> static_ports; std::map<int, RTLIL::SigSpec> static_cells_map; - int wr_ports = cell->parameters[ID::WR_PORTS].as_int(); - int rd_ports = cell->parameters[ID::RD_PORTS].as_int(); - - int mem_size = cell->parameters[ID::SIZE].as_int(); - int mem_width = cell->parameters[ID::WIDTH].as_int(); - int mem_offset = cell->parameters[ID::OFFSET].as_int(); - int mem_abits = cell->parameters[ID::ABITS].as_int(); - - SigSpec init_data = cell->getParam(ID::INIT); - init_data.extend_u0(mem_size*mem_width, true); + SigSpec init_data = mem.get_init_data(); // delete unused memory cell - if (wr_ports == 0 && rd_ports == 0) { - module->remove(cell); + if (mem.rd_ports.empty()) { + mem.remove(); return; } - // check if attributes allow us to infer FFRAM for this cell + // check if attributes allow us to infer FFRAM for this memory for (const auto &attr : attributes) { - if (cell->attributes.count(attr.first)) { - const auto &cell_attr = cell->attributes[attr.first]; + if (mem.attributes.count(attr.first)) { + const auto &cell_attr = mem.attributes[attr.first]; if (attr.second.empty()) { - log("Not mapping memory cell %s in module %s (attribute %s is set).\n", - cell->name.c_str(), module->name.c_str(), attr.first.c_str()); + log("Not mapping memory %s in module %s (attribute %s is set).\n", + mem.memid.c_str(), module->name.c_str(), attr.first.c_str()); return; } @@ -138,11 +130,11 @@ struct MemoryMapWorker } if (!found) { if (cell_attr.flags & RTLIL::CONST_FLAG_STRING) { - log("Not mapping memory cell %s in module %s (attribute %s is set to \"%s\").\n", - cell->name.c_str(), module->name.c_str(), attr.first.c_str(), cell_attr.decode_string().c_str()); + log("Not mapping memory %s in module %s (attribute %s is set to \"%s\").\n", + mem.memid.c_str(), module->name.c_str(), attr.first.c_str(), cell_attr.decode_string().c_str()); } else { - log("Not mapping memory cell %s in module %s (attribute %s is set to %d).\n", - cell->name.c_str(), module->name.c_str(), attr.first.c_str(), cell_attr.as_int()); + log("Not mapping memory %s in module %s (attribute %s is set to %d).\n", + mem.memid.c_str(), module->name.c_str(), attr.first.c_str(), cell_attr.as_int()); } return; } @@ -150,82 +142,75 @@ struct MemoryMapWorker } // all write ports must share the same clock - RTLIL::SigSpec clocks = cell->getPort(ID::WR_CLK); - RTLIL::Const clocks_pol = cell->parameters[ID::WR_CLK_POLARITY]; - RTLIL::Const clocks_en = cell->parameters[ID::WR_CLK_ENABLE]; - clocks_pol.bits.resize(wr_ports); - clocks_en.bits.resize(wr_ports); RTLIL::SigSpec refclock; - RTLIL::State refclock_pol = RTLIL::State::Sx; - for (int i = 0; i < clocks.size(); i++) { - RTLIL::SigSpec wr_en = cell->getPort(ID::WR_EN).extract(i * mem_width, mem_width); - if (wr_en.is_fully_const() && !wr_en.as_bool()) { + bool refclock_pol = false; + for (int i = 0; i < GetSize(mem.wr_ports); i++) { + auto &port = mem.wr_ports[i]; + if (port.en.is_fully_const() && !port.en.as_bool()) { static_ports.insert(i); continue; } - if (clocks_en.bits[i] != RTLIL::State::S1) { - RTLIL::SigSpec wr_addr = cell->getPort(ID::WR_ADDR).extract(i*mem_abits, mem_abits); - RTLIL::SigSpec wr_data = cell->getPort(ID::WR_DATA).extract(i*mem_width, mem_width); - if (wr_addr.is_fully_const()) { - // FIXME: Actually we should check for wr_en.is_fully_const() also and - // create a $adff cell with this ports wr_en input as reset pin when wr_en + if (!port.clk_enable) { + if (port.addr.is_fully_const()) { + // FIXME: Actually we should check for port.en.is_fully_const() also and + // create a $adff cell with this ports port.en input as reset pin when port.en // is not a simple static 1. - static_cells_map[wr_addr.as_int() - mem_offset] = wr_data; + static_cells_map[port.addr.as_int() - mem.start_offset] = port.data; static_ports.insert(i); continue; } - log("Not mapping memory cell %s in module %s (write port %d has no clock).\n", - cell->name.c_str(), module->name.c_str(), i); + log("Not mapping memory %s in module %s (write port %d has no clock).\n", + mem.memid.c_str(), module->name.c_str(), i); return; } if (refclock.size() == 0) { - refclock = clocks.extract(i, 1); - refclock_pol = clocks_pol.bits[i]; + refclock = port.clk; + refclock_pol = port.clk_polarity; } - if (clocks.extract(i, 1) != refclock || clocks_pol.bits[i] != refclock_pol) { - log("Not mapping memory cell %s in module %s (write clock %d is incompatible with other clocks).\n", - cell->name.c_str(), module->name.c_str(), i); + if (port.clk != refclock || port.clk_polarity != refclock_pol) { + log("Not mapping memory %s in module %s (write clock %d is incompatible with other clocks).\n", + mem.memid.c_str(), module->name.c_str(), i); return; } } - log("Mapping memory cell %s in module %s:\n", cell->name.c_str(), module->name.c_str()); + log("Mapping memory %s in module %s:\n", mem.memid.c_str(), module->name.c_str()); std::vector<RTLIL::SigSpec> data_reg_in; std::vector<RTLIL::SigSpec> data_reg_out; int count_static = 0; - for (int i = 0; i < mem_size; i++) + for (int i = 0; i < mem.size; i++) { if (static_cells_map.count(i) > 0) { - data_reg_in.push_back(RTLIL::SigSpec(RTLIL::State::Sz, mem_width)); + data_reg_in.push_back(RTLIL::SigSpec(RTLIL::State::Sz, mem.width)); data_reg_out.push_back(static_cells_map[i]); count_static++; } else { - RTLIL::Cell *c = module->addCell(genid(cell->name, "", i), ID($dff)); - c->parameters[ID::WIDTH] = cell->parameters[ID::WIDTH]; - if (clocks_pol.bits.size() > 0) { - c->parameters[ID::CLK_POLARITY] = RTLIL::Const(clocks_pol.bits[0]); - c->setPort(ID::CLK, clocks.extract(0, 1)); + RTLIL::Cell *c = module->addCell(genid(mem.memid, "", i), ID($dff)); + c->parameters[ID::WIDTH] = mem.width; + if (GetSize(refclock) != 0) { + c->parameters[ID::CLK_POLARITY] = RTLIL::Const(refclock_pol); + c->setPort(ID::CLK, refclock); } else { c->parameters[ID::CLK_POLARITY] = RTLIL::Const(RTLIL::State::S1); c->setPort(ID::CLK, RTLIL::SigSpec(RTLIL::State::S0)); } - RTLIL::Wire *w_in = module->addWire(genid(cell->name, "", i, "$d"), mem_width); + RTLIL::Wire *w_in = module->addWire(genid(mem.memid, "", i, "$d"), mem.width); data_reg_in.push_back(RTLIL::SigSpec(w_in)); c->setPort(ID::D, data_reg_in.back()); - std::string w_out_name = stringf("%s[%d]", cell->parameters[ID::MEMID].decode_string().c_str(), i); + std::string w_out_name = stringf("%s[%d]", mem.memid.c_str(), i); if (module->wires_.count(w_out_name) > 0) - w_out_name = genid(cell->name, "", i, "$q"); + w_out_name = genid(mem.memid, "", i, "$q"); - RTLIL::Wire *w_out = module->addWire(w_out_name, mem_width); - SigSpec w_init = init_data.extract(i*mem_width, mem_width); + RTLIL::Wire *w_out = module->addWire(w_out_name, mem.width); + SigSpec w_init = init_data.extract(i*mem.width, mem.width); if (!w_init.is_fully_undef()) w_out->attributes[ID::init] = w_init.as_const(); @@ -235,76 +220,39 @@ struct MemoryMapWorker } } - log(" created %d $dff cells and %d static cells of width %d.\n", mem_size-count_static, count_static, mem_width); + log(" created %d $dff cells and %d static cells of width %d.\n", mem.size-count_static, count_static, mem.width); int count_dff = 0, count_mux = 0, count_wrmux = 0; - for (int i = 0; i < cell->parameters[ID::RD_PORTS].as_int(); i++) + int abits = ceil_log2(mem.size); + for (int i = 0; i < GetSize(mem.rd_ports); i++) { - RTLIL::SigSpec rd_addr = cell->getPort(ID::RD_ADDR).extract(i*mem_abits, mem_abits); + auto &port = mem.rd_ports[i]; + if (mem.extract_rdff(i)) + count_dff++; + RTLIL::SigSpec rd_addr = port.addr; + rd_addr.extend_u0(abits, false); - if (mem_offset) - rd_addr = module->Sub(NEW_ID, rd_addr, SigSpec(mem_offset, GetSize(rd_addr))); + if (mem.start_offset) + rd_addr = module->Sub(NEW_ID, rd_addr, SigSpec(mem.start_offset, abits)); std::vector<RTLIL::SigSpec> rd_signals; - rd_signals.push_back(cell->getPort(ID::RD_DATA).extract(i*mem_width, mem_width)); - - if (cell->parameters[ID::RD_CLK_ENABLE].bits[i] == RTLIL::State::S1) - { - RTLIL::Cell *dff_cell = nullptr; - - if (cell->parameters[ID::RD_TRANSPARENT].bits[i] == RTLIL::State::S1) - { - dff_cell = module->addCell(genid(cell->name, "$rdreg", i), ID($dff)); - dff_cell->parameters[ID::WIDTH] = RTLIL::Const(mem_abits); - dff_cell->parameters[ID::CLK_POLARITY] = RTLIL::Const(cell->parameters[ID::RD_CLK_POLARITY].bits[i]); - dff_cell->setPort(ID::CLK, cell->getPort(ID::RD_CLK).extract(i, 1)); - dff_cell->setPort(ID::D, rd_addr); - count_dff++; - - RTLIL::Wire *w = module->addWire(genid(cell->name, "$rdreg", i, "$q"), mem_abits); - - dff_cell->setPort(ID::Q, RTLIL::SigSpec(w)); - rd_addr = RTLIL::SigSpec(w); - } - else - { - dff_cell = module->addCell(genid(cell->name, "$rdreg", i), ID($dff)); - dff_cell->parameters[ID::WIDTH] = cell->parameters[ID::WIDTH]; - dff_cell->parameters[ID::CLK_POLARITY] = RTLIL::Const(cell->parameters[ID::RD_CLK_POLARITY].bits[i]); - dff_cell->setPort(ID::CLK, cell->getPort(ID::RD_CLK).extract(i, 1)); - dff_cell->setPort(ID::Q, rd_signals.back()); - count_dff++; - - RTLIL::Wire *w = module->addWire(genid(cell->name, "$rdreg", i, "$d"), mem_width); - - rd_signals.clear(); - rd_signals.push_back(RTLIL::SigSpec(w)); - dff_cell->setPort(ID::D, rd_signals.back()); - } - - SigBit en_bit = cell->getPort(ID::RD_EN).extract(i); - if (en_bit != State::S1) { - SigSpec new_d = module->Mux(genid(cell->name, "$rdenmux", i), - dff_cell->getPort(ID::Q), dff_cell->getPort(ID::D), en_bit); - dff_cell->setPort(ID::D, new_d); - } - } + rd_signals.push_back(port.data); - for (int j = 0; j < mem_abits; j++) + for (int j = 0; j < abits; j++) { std::vector<RTLIL::SigSpec> next_rd_signals; for (size_t k = 0; k < rd_signals.size(); k++) { - RTLIL::Cell *c = module->addCell(genid(cell->name, "$rdmux", i, "", j, "", k), ID($mux)); - c->parameters[ID::WIDTH] = cell->parameters[ID::WIDTH]; + RTLIL::Cell *c = module->addCell(genid(mem.memid, "$rdmux", i, "", j, "", k), ID($mux)); + c->parameters[ID::WIDTH] = mem.width; c->setPort(ID::Y, rd_signals[k]); - c->setPort(ID::S, rd_addr.extract(mem_abits-j-1, 1)); + c->setPort(ID::S, rd_addr.extract(abits-j-1, 1)); count_mux++; - c->setPort(ID::A, module->addWire(genid(cell->name, "$rdmux", i, "", j, "", k, "$a"), mem_width)); - c->setPort(ID::B, module->addWire(genid(cell->name, "$rdmux", i, "", j, "", k, "$b"), mem_width)); + c->setPort(ID::A, module->addWire(genid(mem.memid, "$rdmux", i, "", j, "", k, "$a"), mem.width)); + c->setPort(ID::B, module->addWire(genid(mem.memid, "$rdmux", i, "", j, "", k, "$b"), mem.width)); next_rd_signals.push_back(c->getPort(ID::A)); next_rd_signals.push_back(c->getPort(ID::B)); @@ -313,38 +261,37 @@ struct MemoryMapWorker next_rd_signals.swap(rd_signals); } - for (int j = 0; j < mem_size; j++) + for (int j = 0; j < mem.size; j++) module->connect(RTLIL::SigSig(rd_signals[j], data_reg_out[j])); } log(" read interface: %d $dff and %d $mux cells.\n", count_dff, count_mux); - for (int i = 0; i < mem_size; i++) + for (int i = 0; i < mem.size; i++) { if (static_cells_map.count(i) > 0) continue; RTLIL::SigSpec sig = data_reg_out[i]; - for (int j = 0; j < cell->parameters[ID::WR_PORTS].as_int(); j++) + for (int j = 0; j < GetSize(mem.wr_ports); j++) { - RTLIL::SigSpec wr_addr = cell->getPort(ID::WR_ADDR).extract(j*mem_abits, mem_abits); - RTLIL::SigSpec wr_data = cell->getPort(ID::WR_DATA).extract(j*mem_width, mem_width); - RTLIL::SigSpec wr_en = cell->getPort(ID::WR_EN).extract(j*mem_width, mem_width); + auto &port = mem.wr_ports[j]; + RTLIL::SigSpec wr_addr = port.addr; - if (mem_offset) - wr_addr = module->Sub(NEW_ID, wr_addr, SigSpec(mem_offset, GetSize(wr_addr))); + if (mem.start_offset) + wr_addr = module->Sub(NEW_ID, wr_addr, SigSpec(mem.start_offset, GetSize(wr_addr))); - RTLIL::Wire *w_seladdr = addr_decode(wr_addr, RTLIL::SigSpec(i, mem_abits)); + RTLIL::Wire *w_seladdr = addr_decode(wr_addr, RTLIL::SigSpec(i, GetSize(wr_addr))); int wr_offset = 0; - while (wr_offset < wr_en.size()) + while (wr_offset < port.en.size()) { int wr_width = 1; - RTLIL::SigSpec wr_bit = wr_en.extract(wr_offset, 1); + RTLIL::SigSpec wr_bit = port.en.extract(wr_offset, 1); - while (wr_offset + wr_width < wr_en.size()) { - RTLIL::SigSpec next_wr_bit = wr_en.extract(wr_offset + wr_width, 1); + while (wr_offset + wr_width < port.en.size()) { + RTLIL::SigSpec next_wr_bit = port.en.extract(wr_offset + wr_width, 1); if (next_wr_bit != wr_bit) break; wr_width++; @@ -354,7 +301,7 @@ struct MemoryMapWorker if (wr_bit != State::S1) { - RTLIL::Cell *c = module->addCell(genid(cell->name, "$wren", i, "", j, "", wr_offset), ID($and)); + RTLIL::Cell *c = module->addCell(genid(mem.memid, "$wren", i, "", j, "", wr_offset), ID($and)); c->parameters[ID::A_SIGNED] = RTLIL::Const(0); c->parameters[ID::B_SIGNED] = RTLIL::Const(0); c->parameters[ID::A_WIDTH] = RTLIL::Const(1); @@ -363,17 +310,17 @@ struct MemoryMapWorker c->setPort(ID::A, w); c->setPort(ID::B, wr_bit); - w = module->addWire(genid(cell->name, "$wren", i, "", j, "", wr_offset, "$y")); + w = module->addWire(genid(mem.memid, "$wren", i, "", j, "", wr_offset, "$y")); c->setPort(ID::Y, RTLIL::SigSpec(w)); } - RTLIL::Cell *c = module->addCell(genid(cell->name, "$wrmux", i, "", j, "", wr_offset), ID($mux)); + RTLIL::Cell *c = module->addCell(genid(mem.memid, "$wrmux", i, "", j, "", wr_offset), ID($mux)); c->parameters[ID::WIDTH] = wr_width; c->setPort(ID::A, sig.extract(wr_offset, wr_width)); - c->setPort(ID::B, wr_data.extract(wr_offset, wr_width)); + c->setPort(ID::B, port.data.extract(wr_offset, wr_width)); c->setPort(ID::S, RTLIL::SigSpec(w)); - w = module->addWire(genid(cell->name, "$wrmux", i, "", j, "", wr_offset, "$y"), wr_width); + w = module->addWire(genid(mem.memid, "$wrmux", i, "", j, "", wr_offset, "$y"), wr_width); c->setPort(ID::Y, w); sig.replace(wr_offset, w); @@ -387,17 +334,13 @@ struct MemoryMapWorker log(" write interface: %d write mux blocks.\n", count_wrmux); - module->remove(cell); + mem.remove(); } void run() { - std::vector<RTLIL::Cell*> cells; - for (auto cell : module->selected_cells()) - if (cell->type == ID($mem)) - cells.push_back(cell); - for (auto cell : cells) - handle_cell(cell); + for (auto &mem : Mem::get_selected_memories(module)) + handle_memory(mem); } }; @@ -430,7 +373,7 @@ struct MemoryMapPass : public Pass { bool attr_icase = false; dict<RTLIL::IdString, std::vector<RTLIL::Const>> attributes; - log_header(design, "Executing MEMORY_MAP pass (converting $mem cells to logic and flip-flops).\n"); + log_header(design, "Executing MEMORY_MAP pass (converting memories to logic and flip-flops).\n"); size_t argidx; for (argidx = 1; argidx < args.size(); argidx++) diff --git a/passes/memory/memory_nordff.cc b/passes/memory/memory_nordff.cc index 07bbd9fe8..a4fdcfc38 100644 --- a/passes/memory/memory_nordff.cc +++ b/passes/memory/memory_nordff.cc @@ -19,6 +19,7 @@ #include "kernel/yosys.h" #include "kernel/sigtools.h" +#include "kernel/mem.h" USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN @@ -37,7 +38,7 @@ struct MemoryNordffPass : public Pass { } void execute(std::vector<std::string> args, RTLIL::Design *design) override { - log_header(design, "Executing MEMORY_NORDFF pass (extracting $dff cells from $mem).\n"); + log_header(design, "Executing MEMORY_NORDFF pass (extracting $dff cells from memories).\n"); size_t argidx; for (argidx = 1; argidx < args.size(); argidx++) { @@ -50,70 +51,15 @@ struct MemoryNordffPass : public Pass { extra_args(args, argidx, design); for (auto module : design->selected_modules()) - for (auto cell : vector<Cell*>(module->selected_cells())) + for (auto &mem : Mem::get_selected_memories(module)) { - if (cell->type != ID($mem)) - continue; + bool changed = false; + for (int i = 0; i < GetSize(mem.rd_ports); i++) + if (mem.extract_rdff(i)) + changed = true; - int rd_ports = cell->getParam(ID::RD_PORTS).as_int(); - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - - SigSpec rd_addr = cell->getPort(ID::RD_ADDR); - SigSpec rd_data = cell->getPort(ID::RD_DATA); - SigSpec rd_clk = cell->getPort(ID::RD_CLK); - SigSpec rd_en = cell->getPort(ID::RD_EN); - Const rd_clk_enable = cell->getParam(ID::RD_CLK_ENABLE); - Const rd_clk_polarity = cell->getParam(ID::RD_CLK_POLARITY); - - for (int i = 0; i < rd_ports; i++) - { - bool clk_enable = rd_clk_enable[i] == State::S1; - - if (clk_enable) - { - bool clk_polarity = cell->getParam(ID::RD_CLK_POLARITY)[i] == State::S1; - bool transparent = cell->getParam(ID::RD_TRANSPARENT)[i] == State::S1; - - SigSpec clk = cell->getPort(ID::RD_CLK)[i] ; - SigSpec en = cell->getPort(ID::RD_EN)[i]; - Cell *c; - - if (transparent) - { - SigSpec sig_q = module->addWire(NEW_ID, abits); - SigSpec sig_d = rd_addr.extract(abits * i, abits); - rd_addr.replace(abits * i, sig_q); - if (en != State::S1) - sig_d = module->Mux(NEW_ID, sig_q, sig_d, en); - c = module->addDff(NEW_ID, clk, sig_d, sig_q, clk_polarity); - } - else - { - SigSpec sig_d = module->addWire(NEW_ID, width); - SigSpec sig_q = rd_data.extract(width * i, width); - rd_data.replace(width *i, sig_d); - if (en != State::S1) - sig_d = module->Mux(NEW_ID, sig_q, sig_d, en); - c = module->addDff(NEW_ID, clk, sig_d, sig_q, clk_polarity); - } - - log("Extracted %s FF from read port %d of %s.%s: %s\n", transparent ? "addr" : "data", - i, log_id(module), log_id(cell), log_id(c)); - } - - rd_en[i] = State::S1; - rd_clk[i] = State::S0; - rd_clk_enable[i] = State::S0; - rd_clk_polarity[i] = State::S1; - } - - cell->setPort(ID::RD_ADDR, rd_addr); - cell->setPort(ID::RD_DATA, rd_data); - cell->setPort(ID::RD_CLK, rd_clk); - cell->setPort(ID::RD_EN, rd_en); - cell->setParam(ID::RD_CLK_ENABLE, rd_clk_enable); - cell->setParam(ID::RD_CLK_POLARITY, rd_clk_polarity); + if (changed) + mem.emit(); } } } MemoryNordffPass; diff --git a/passes/memory/memory_unpack.cc b/passes/memory/memory_unpack.cc index d04d4ba7a..16b57d9c3 100644 --- a/passes/memory/memory_unpack.cc +++ b/passes/memory/memory_unpack.cc @@ -17,114 +17,12 @@ * */ -#include "kernel/register.h" -#include "kernel/log.h" -#include <sstream> -#include <algorithm> -#include <stdlib.h> +#include "kernel/yosys.h" +#include "kernel/mem.h" USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN -void handle_memory(RTLIL::Module *module, RTLIL::Cell *memory) -{ - log("Creating $memrd and $memwr for memory `%s' in module `%s':\n", - memory->name.c_str(), module->name.c_str()); - - RTLIL::IdString mem_name = RTLIL::escape_id(memory->parameters.at(ID::MEMID).decode_string()); - - while (module->memories.count(mem_name) != 0) - mem_name = mem_name.str() + stringf("_%d", autoidx++); - - RTLIL::Memory *mem = new RTLIL::Memory; - mem->name = mem_name; - mem->width = memory->parameters.at(ID::WIDTH).as_int(); - mem->start_offset = memory->parameters.at(ID::OFFSET).as_int(); - mem->size = memory->parameters.at(ID::SIZE).as_int(); - module->memories[mem_name] = mem; - - int abits = memory->parameters.at(ID::ABITS).as_int(); - int num_rd_ports = memory->parameters.at(ID::RD_PORTS).as_int(); - int num_wr_ports = memory->parameters.at(ID::WR_PORTS).as_int(); - - for (int i = 0; i < num_rd_ports; i++) - { - RTLIL::Cell *cell = module->addCell(NEW_ID, ID($memrd)); - cell->parameters[ID::MEMID] = mem_name.str(); - cell->parameters[ID::ABITS] = memory->parameters.at(ID::ABITS); - cell->parameters[ID::WIDTH] = memory->parameters.at(ID::WIDTH); - cell->parameters[ID::CLK_ENABLE] = RTLIL::SigSpec(memory->parameters.at(ID::RD_CLK_ENABLE)).extract(i, 1).as_const(); - cell->parameters[ID::CLK_POLARITY] = RTLIL::SigSpec(memory->parameters.at(ID::RD_CLK_POLARITY)).extract(i, 1).as_const(); - cell->parameters[ID::TRANSPARENT] = RTLIL::SigSpec(memory->parameters.at(ID::RD_TRANSPARENT)).extract(i, 1).as_const(); - cell->setPort(ID::CLK, memory->getPort(ID::RD_CLK).extract(i, 1)); - cell->setPort(ID::EN, memory->getPort(ID::RD_EN).extract(i, 1)); - cell->setPort(ID::ADDR, memory->getPort(ID::RD_ADDR).extract(i*abits, abits)); - cell->setPort(ID::DATA, memory->getPort(ID::RD_DATA).extract(i*mem->width, mem->width)); - } - - for (int i = 0; i < num_wr_ports; i++) - { - RTLIL::Cell *cell = module->addCell(NEW_ID, ID($memwr)); - cell->parameters[ID::MEMID] = mem_name.str(); - cell->parameters[ID::ABITS] = memory->parameters.at(ID::ABITS); - cell->parameters[ID::WIDTH] = memory->parameters.at(ID::WIDTH); - cell->parameters[ID::CLK_ENABLE] = RTLIL::SigSpec(memory->parameters.at(ID::WR_CLK_ENABLE)).extract(i, 1).as_const(); - cell->parameters[ID::CLK_POLARITY] = RTLIL::SigSpec(memory->parameters.at(ID::WR_CLK_POLARITY)).extract(i, 1).as_const(); - cell->parameters[ID::PRIORITY] = i; - cell->setPort(ID::CLK, memory->getPort(ID::WR_CLK).extract(i, 1)); - cell->setPort(ID::EN, memory->getPort(ID::WR_EN).extract(i*mem->width, mem->width)); - cell->setPort(ID::ADDR, memory->getPort(ID::WR_ADDR).extract(i*abits, abits)); - cell->setPort(ID::DATA, memory->getPort(ID::WR_DATA).extract(i*mem->width, mem->width)); - } - - Const initval = memory->parameters.at(ID::INIT); - RTLIL::Cell *last_init_cell = nullptr; - SigSpec last_init_data; - int last_init_addr=0; - - for (int i = 0; i < GetSize(initval) && i/mem->width < (1 << abits); i += mem->width) { - Const val = initval.extract(i, mem->width, State::Sx); - for (auto bit : val.bits) - if (bit != State::Sx) - goto found_non_undef_initval; - continue; - found_non_undef_initval: - if (last_init_cell && last_init_addr+1 == i/mem->width) { - last_init_cell->parameters[ID::WORDS] = last_init_cell->parameters[ID::WORDS].as_int() + 1; - last_init_data.append(val); - last_init_addr++; - } else { - if (last_init_cell) - last_init_cell->setPort(ID::DATA, last_init_data); - RTLIL::Cell *cell = module->addCell(NEW_ID, ID($meminit)); - cell->parameters[ID::MEMID] = mem_name.str(); - cell->parameters[ID::ABITS] = memory->parameters.at(ID::ABITS); - cell->parameters[ID::WIDTH] = memory->parameters.at(ID::WIDTH); - cell->parameters[ID::WORDS] = 1; - cell->parameters[ID::PRIORITY] = i/mem->width; - cell->setPort(ID::ADDR, SigSpec(i/mem->width, abits)); - last_init_cell = cell; - last_init_addr = i/mem->width; - last_init_data = val; - } - } - - if (last_init_cell) - last_init_cell->setPort(ID::DATA, last_init_data); - - module->remove(memory); -} - -void handle_module(RTLIL::Design *design, RTLIL::Module *module) -{ - std::vector<RTLIL::IdString> memcells; - for (auto cell : module->cells()) - if (cell->type == ID($mem) && design->selected(module, cell)) - memcells.push_back(cell->name); - for (auto &it : memcells) - handle_memory(module, module->cell(it)); -} - struct MemoryUnpackPass : public Pass { MemoryUnpackPass() : Pass("memory_unpack", "unpack multi-port memory cells") { } void help() override @@ -140,8 +38,14 @@ struct MemoryUnpackPass : public Pass { void execute(std::vector<std::string> args, RTLIL::Design *design) override { log_header(design, "Executing MEMORY_UNPACK pass (generating $memrd/$memwr cells form $mem cells).\n"); extra_args(args, 1, design); - for (auto module : design->selected_modules()) - handle_module(design, module); + for (auto module : design->selected_modules()) { + for (auto &mem : Mem::get_selected_memories(module)) { + if (mem.packed) { + mem.packed = false; + mem.emit(); + } + } + } } } MemoryUnpackPass; diff --git a/passes/opt/opt_mem.cc b/passes/opt/opt_mem.cc index 24df1356b..49a0ac51a 100644 --- a/passes/opt/opt_mem.cc +++ b/passes/opt/opt_mem.cc @@ -19,82 +19,11 @@ #include "kernel/yosys.h" #include "kernel/sigtools.h" +#include "kernel/mem.h" USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN -struct OptMemWorker -{ - RTLIL::Design *design; - RTLIL::Module *module; - SigMap sigmap; - bool restart; - - dict<IdString, vector<IdString>> memrd, memwr, meminit; - pool<IdString> remove_mem, remove_cells; - - OptMemWorker(RTLIL::Module *module) : design(module->design), module(module), sigmap(module), restart(false) - { - for (auto &it : module->memories) - { - memrd[it.first]; - memwr[it.first]; - meminit[it.first]; - } - - for (auto cell : module->cells()) - { - if (cell->type == ID($memrd)) { - IdString id = cell->getParam(ID::MEMID).decode_string(); - memrd.at(id).push_back(cell->name); - } - - if (cell->type == ID($memwr)) { - IdString id = cell->getParam(ID::MEMID).decode_string(); - memwr.at(id).push_back(cell->name); - } - - if (cell->type == ID($meminit)) { - IdString id = cell->getParam(ID::MEMID).decode_string(); - meminit.at(id).push_back(cell->name); - } - } - } - - ~OptMemWorker() - { - for (auto it : remove_mem) - { - for (auto cell_name : memrd[it]) - module->remove(module->cell(cell_name)); - for (auto cell_name : memwr[it]) - module->remove(module->cell(cell_name)); - for (auto cell_name : meminit[it]) - module->remove(module->cell(cell_name)); - - delete module->memories.at(it); - module->memories.erase(it); - } - - for (auto cell_name : remove_cells) - module->remove(module->cell(cell_name)); - } - - int run(RTLIL::Memory *mem) - { - if (restart || remove_mem.count(mem->name)) - return 0; - - if (memwr.at(mem->name).empty() && meminit.at(mem->name).empty()) { - log("Removing memory %s.%s with no write ports or init data.\n", log_id(module), log_id(mem)); - remove_mem.insert(mem->name); - return 1; - } - - return 0; - } -}; - struct OptMemPass : public Pass { OptMemPass() : Pass("opt_mem", "optimize memories") { } void help() override @@ -122,15 +51,11 @@ struct OptMemPass : public Pass { int total_count = 0; for (auto module : design->selected_modules()) { - while (1) { - int cnt = 0; - OptMemWorker worker(module); - for (auto &it : module->memories) - if (module->selected(it.second)) - cnt += worker.run(it.second); - if (!cnt && !worker.restart) - break; - total_count += cnt; + for (auto &mem : Mem::get_selected_memories(module)) { + if (mem.wr_ports.empty() && mem.inits.empty()) { + mem.remove(); + total_count++; + } } } diff --git a/passes/sat/clk2fflogic.cc b/passes/sat/clk2fflogic.cc index 2cb91c009..cbf7c5435 100644 --- a/passes/sat/clk2fflogic.cc +++ b/passes/sat/clk2fflogic.cc @@ -21,6 +21,7 @@ #include "kernel/sigtools.h" #include "kernel/ffinit.h" #include "kernel/ff.h" +#include "kernel/mem.h" USING_YOSYS_NAMESPACE PRIVATE_NAMESPACE_BEGIN @@ -84,89 +85,65 @@ struct Clk2fflogicPass : public Pass { SigMap sigmap(module); FfInitVals initvals(&sigmap, module); - for (auto cell : vector<Cell*>(module->selected_cells())) + for (auto &mem : Mem::get_selected_memories(module)) { - if (cell->type.in(ID($mem))) - { - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - int rd_ports = cell->getParam(ID::RD_PORTS).as_int(); - int wr_ports = cell->getParam(ID::WR_PORTS).as_int(); - - for (int i = 0; i < rd_ports; i++) { - if (cell->getParam(ID::RD_CLK_ENABLE).extract(i).as_bool()) - log_error("Read port %d of memory %s.%s is clocked. This is not supported by \"clk2fflogic\"! " - "Call \"memory\" with -nordff to avoid this error.\n", i, log_id(cell), log_id(module)); - } - - Const wr_clk_en_param = cell->getParam(ID::WR_CLK_ENABLE); - Const wr_clk_pol_param = cell->getParam(ID::WR_CLK_POLARITY); - - SigSpec wr_clk_port = cell->getPort(ID::WR_CLK); - SigSpec wr_en_port = cell->getPort(ID::WR_EN); - SigSpec wr_addr_port = cell->getPort(ID::WR_ADDR); - SigSpec wr_data_port = cell->getPort(ID::WR_DATA); - - for (int wport = 0; wport < wr_ports; wport++) - { - bool clken = wr_clk_en_param[wport] == State::S1; - bool clkpol = wr_clk_pol_param[wport] == State::S1; - - if (!clken) - continue; - - SigBit clk = wr_clk_port[wport]; - SigSpec en = wr_en_port.extract(wport*width, width); - SigSpec addr = wr_addr_port.extract(wport*abits, abits); - SigSpec data = wr_data_port.extract(wport*width, width); + for (int i = 0; i < GetSize(mem.rd_ports); i++) { + auto &port = mem.rd_ports[i]; + if (port.clk_enable) + log_error("Read port %d of memory %s.%s is clocked. This is not supported by \"clk2fflogic\"! " + "Call \"memory\" with -nordff to avoid this error.\n", i, log_id(mem.memid), log_id(module)); + } - log("Modifying write port %d on memory %s.%s: CLK=%s, A=%s, D=%s\n", - wport, log_id(module), log_id(cell), log_signal(clk), - log_signal(addr), log_signal(data)); + for (int i = 0; i < GetSize(mem.wr_ports); i++) + { + auto &port = mem.wr_ports[i]; - Wire *past_clk = module->addWire(NEW_ID); - past_clk->attributes[ID::init] = clkpol ? State::S1 : State::S0; - module->addFf(NEW_ID, clk, past_clk); + if (!port.clk_enable) + continue; - SigSpec clock_edge_pattern; + log("Modifying write port %d on memory %s.%s: CLK=%s, A=%s, D=%s\n", + i, log_id(module), log_id(mem.memid), log_signal(port.clk), + log_signal(port.addr), log_signal(port.data)); - if (clkpol) { - clock_edge_pattern.append(State::S0); - clock_edge_pattern.append(State::S1); - } else { - clock_edge_pattern.append(State::S1); - clock_edge_pattern.append(State::S0); - } + Wire *past_clk = module->addWire(NEW_ID); + past_clk->attributes[ID::init] = port.clk_polarity ? State::S1 : State::S0; + module->addFf(NEW_ID, port.clk, past_clk); - SigSpec clock_edge = module->Eqx(NEW_ID, {clk, SigSpec(past_clk)}, clock_edge_pattern); + SigSpec clock_edge_pattern; - SigSpec en_q = module->addWire(NEW_ID, GetSize(en)); - module->addFf(NEW_ID, en, en_q); + if (port.clk_polarity) { + clock_edge_pattern.append(State::S0); + clock_edge_pattern.append(State::S1); + } else { + clock_edge_pattern.append(State::S1); + clock_edge_pattern.append(State::S0); + } - SigSpec addr_q = module->addWire(NEW_ID, GetSize(addr)); - module->addFf(NEW_ID, addr, addr_q); + SigSpec clock_edge = module->Eqx(NEW_ID, {port.clk, SigSpec(past_clk)}, clock_edge_pattern); - SigSpec data_q = module->addWire(NEW_ID, GetSize(data)); - module->addFf(NEW_ID, data, data_q); + SigSpec en_q = module->addWire(NEW_ID, GetSize(port.en)); + module->addFf(NEW_ID, port.en, en_q); - wr_clk_port[wport] = State::S0; - wr_en_port.replace(wport*width, module->Mux(NEW_ID, Const(0, GetSize(en_q)), en_q, clock_edge)); - wr_addr_port.replace(wport*abits, addr_q); - wr_data_port.replace(wport*width, data_q); + SigSpec addr_q = module->addWire(NEW_ID, GetSize(port.addr)); + module->addFf(NEW_ID, port.addr, addr_q); - wr_clk_en_param[wport] = State::S0; - wr_clk_pol_param[wport] = State::S0; - } + SigSpec data_q = module->addWire(NEW_ID, GetSize(port.data)); + module->addFf(NEW_ID, port.data, data_q); - cell->setParam(ID::WR_CLK_ENABLE, wr_clk_en_param); - cell->setParam(ID::WR_CLK_POLARITY, wr_clk_pol_param); + port.clk = State::S0; + port.en = module->Mux(NEW_ID, Const(0, GetSize(en_q)), en_q, clock_edge); + port.addr = addr_q; + port.data = data_q; - cell->setPort(ID::WR_CLK, wr_clk_port); - cell->setPort(ID::WR_EN, wr_en_port); - cell->setPort(ID::WR_ADDR, wr_addr_port); - cell->setPort(ID::WR_DATA, wr_data_port); + port.clk_enable = false; + port.clk_polarity = false; } + mem.emit(); + } + + for (auto cell : vector<Cell*>(module->selected_cells())) + { SigSpec qval; if (RTLIL::builtin_ff_cell_types().count(cell->type)) { FfData ff(&initvals, cell); diff --git a/passes/sat/sim.cc b/passes/sat/sim.cc index 3d2081a74..75f922dba 100644 --- a/passes/sat/sim.cc +++ b/passes/sat/sim.cc @@ -20,6 +20,7 @@ #include "kernel/yosys.h" #include "kernel/sigtools.h" #include "kernel/celltypes.h" +#include "kernel/mem.h" #include <ctime> @@ -64,6 +65,7 @@ struct SimInstance pool<SigBit> dirty_bits; pool<Cell*> dirty_cells; + pool<IdString> dirty_memories; pool<SimInstance*, hash_ptr_ops> dirty_children; struct ff_state_t @@ -74,16 +76,20 @@ struct SimInstance struct mem_state_t { - Const past_wr_clk; - Const past_wr_en; - Const past_wr_addr; - Const past_wr_data; + Mem *mem; + std::vector<Const> past_wr_clk; + std::vector<Const> past_wr_en; + std::vector<Const> past_wr_addr; + std::vector<Const> past_wr_data; Const data; }; dict<Cell*, ff_state_t> ff_database; - dict<Cell*, mem_state_t> mem_database; + dict<IdString, mem_state_t> mem_database; pool<Cell*> formal_database; + dict<Cell*, IdString> mem_cells; + + std::vector<Mem> memories; dict<Wire*, pair<int, Const>> vcd_database; @@ -120,6 +126,19 @@ struct SimInstance } } + memories = Mem::get_all_memories(module); + for (auto &mem : memories) { + auto &mdb = mem_database[mem.memid]; + mdb.mem = &mem; + for (auto &port : mem.wr_ports) { + mdb.past_wr_clk.push_back(Const(State::Sx)); + mdb.past_wr_en.push_back(Const(State::Sx, GetSize(port.en))); + mdb.past_wr_addr.push_back(Const(State::Sx, GetSize(port.addr))); + mdb.past_wr_data.push_back(Const(State::Sx, GetSize(port.data))); + } + mdb.data = mem.get_init_data(); + } + for (auto cell : module->cells()) { Module *mod = module->design->module(cell->type); @@ -145,29 +164,9 @@ struct SimInstance ff_database[cell] = ff; } - if (cell->type == ID($mem)) + if (cell->type.in(ID($mem), ID($meminit), ID($memwr), ID($memrd))) { - mem_state_t mem; - - mem.past_wr_clk = Const(State::Sx, GetSize(cell->getPort(ID::WR_CLK))); - mem.past_wr_en = Const(State::Sx, GetSize(cell->getPort(ID::WR_EN))); - mem.past_wr_addr = Const(State::Sx, GetSize(cell->getPort(ID::WR_ADDR))); - mem.past_wr_data = Const(State::Sx, GetSize(cell->getPort(ID::WR_DATA))); - - mem.data = cell->getParam(ID::INIT); - int sz = cell->getParam(ID::SIZE).as_int() * cell->getParam(ID::WIDTH).as_int(); - - if (GetSize(mem.data) > sz) - mem.data.bits.resize(sz); - - while (GetSize(mem.data) < sz) - mem.data.bits.push_back(State::Sx); - - mem_database[cell] = mem; - } - if (cell->type.in(ID($memwr),ID($memrd))) - { - log_error("$memrd and $memwr cells have to be merged to stand-alone $mem cells (execute memory_collect pass)\n"); + mem_cells[cell] = cell->parameters.at(ID::MEMID).decode_string(); } if (cell->type.in(ID($assert), ID($cover), ID($assume))) { formal_database.insert(cell); @@ -190,7 +189,8 @@ struct SimInstance for (auto &it : mem_database) { mem_state_t &mem = it.second; - zinit(mem.past_wr_en); + for (auto &val : mem.past_wr_en) + zinit(val); zinit(mem.data); } } @@ -261,37 +261,9 @@ struct SimInstance if (formal_database.count(cell)) return; - if (mem_database.count(cell)) + if (mem_cells.count(cell)) { - mem_state_t &mem = mem_database.at(cell); - - int num_rd_ports = cell->getParam(ID::RD_PORTS).as_int(); - - int size = cell->getParam(ID::SIZE).as_int(); - int offset = cell->getParam(ID::OFFSET).as_int(); - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); - - if (cell->getParam(ID::RD_CLK_ENABLE).as_bool()) - log_error("Memory %s.%s has clocked read ports. Run 'memory' with -nordff.\n", log_id(module), log_id(cell)); - - SigSpec rd_addr_sig = cell->getPort(ID::RD_ADDR); - SigSpec rd_data_sig = cell->getPort(ID::RD_DATA); - - for (int port_idx = 0; port_idx < num_rd_ports; port_idx++) - { - Const addr = get_state(rd_addr_sig.extract(port_idx*abits, abits)); - Const data = Const(State::Sx, width); - - if (addr.is_fully_def()) { - int index = addr.as_int() - offset; - if (index >= 0 && index < size) - data = mem.data.extract(index*width, width); - } - - set_state(rd_data_sig.extract(port_idx*width, width), data); - } - + dirty_memories.insert(mem_cells[cell]); return; } @@ -354,6 +326,29 @@ struct SimInstance log_error("Unsupported cell type: %s (%s.%s)\n", log_id(cell->type), log_id(module), log_id(cell)); } + void update_memory(IdString id) { + auto &mdb = mem_database[id]; + auto &mem = *mdb.mem; + + for (int port_idx = 0; port_idx < GetSize(mem.rd_ports); port_idx++) + { + auto &port = mem.rd_ports[port_idx]; + Const addr = get_state(port.addr); + Const data = Const(State::Sx, mem.width); + + if (port.clk_enable) + log_error("Memory %s.%s has clocked read ports. Run 'memory' with -nordff.\n", log_id(module), log_id(mem.memid)); + + if (addr.is_fully_def()) { + int index = addr.as_int() - mem.start_offset; + if (index >= 0 && index < mem.size) + data = mdb.data.extract(index*mem.width, mem.width); + } + + set_state(port.data, data); + } + } + void update_ph1() { pool<Cell*> queue_cells; @@ -385,6 +380,10 @@ struct SimInstance continue; } + for (auto &memid : dirty_memories) + update_memory(memid); + dirty_memories.clear(); + for (auto wire : queue_outports) if (instance->hasPort(wire->name)) { Const value = get_state(wire); @@ -428,50 +427,40 @@ struct SimInstance for (auto &it : mem_database) { - Cell *cell = it.first; - mem_state_t &mem = it.second; - - int num_wr_ports = cell->getParam(ID::WR_PORTS).as_int(); - - int size = cell->getParam(ID::SIZE).as_int(); - int offset = cell->getParam(ID::OFFSET).as_int(); - int abits = cell->getParam(ID::ABITS).as_int(); - int width = cell->getParam(ID::WIDTH).as_int(); + mem_state_t &mdb = it.second; + auto &mem = *mdb.mem; - Const wr_clk_enable = cell->getParam(ID::WR_CLK_ENABLE); - Const wr_clk_polarity = cell->getParam(ID::WR_CLK_POLARITY); - Const current_wr_clk = get_state(cell->getPort(ID::WR_CLK)); - - for (int port_idx = 0; port_idx < num_wr_ports; port_idx++) + for (int port_idx = 0; port_idx < GetSize(mem.wr_ports); port_idx++) { + auto &port = mem.wr_ports[port_idx]; Const addr, data, enable; - if (wr_clk_enable[port_idx] == State::S0) + if (!port.clk_enable) { - addr = get_state(cell->getPort(ID::WR_ADDR).extract(port_idx*abits, abits)); - data = get_state(cell->getPort(ID::WR_DATA).extract(port_idx*width, width)); - enable = get_state(cell->getPort(ID::WR_EN).extract(port_idx*width, width)); + addr = get_state(port.addr); + data = get_state(port.data); + enable = get_state(port.en); } else { - if (wr_clk_polarity[port_idx] == State::S1 ? - (mem.past_wr_clk[port_idx] == State::S1 || current_wr_clk[port_idx] != State::S1) : - (mem.past_wr_clk[port_idx] == State::S0 || current_wr_clk[port_idx] != State::S0)) + if (port.clk_polarity ? + (mdb.past_wr_clk[port_idx] == State::S1 || get_state(port.clk) != State::S1) : + (mdb.past_wr_clk[port_idx] == State::S0 || get_state(port.clk) != State::S0)) continue; - addr = mem.past_wr_addr.extract(port_idx*abits, abits); - data = mem.past_wr_data.extract(port_idx*width, width); - enable = mem.past_wr_en.extract(port_idx*width, width); + addr = mdb.past_wr_addr[port_idx]; + data = mdb.past_wr_data[port_idx]; + enable = mdb.past_wr_en[port_idx]; } if (addr.is_fully_def()) { - int index = addr.as_int() - offset; - if (index >= 0 && index < size) - for (int i = 0; i < width; i++) - if (enable[i] == State::S1 && mem.data.bits.at(index*width+i) != data[i]) { - mem.data.bits.at(index*width+i) = data[i]; - dirty_cells.insert(cell); + int index = addr.as_int() - mem.start_offset; + if (index >= 0 && index < mem.size) + for (int i = 0; i < mem.width; i++) + if (enable[i] == State::S1 && mdb.data.bits.at(index*mem.width+i) != data[i]) { + mdb.data.bits.at(index*mem.width+i) = data[i]; + dirty_memories.insert(mem.memid); did_something = true; } } @@ -502,13 +491,15 @@ struct SimInstance for (auto &it : mem_database) { - Cell *cell = it.first; mem_state_t &mem = it.second; - mem.past_wr_clk = get_state(cell->getPort(ID::WR_CLK)); - mem.past_wr_en = get_state(cell->getPort(ID::WR_EN)); - mem.past_wr_addr = get_state(cell->getPort(ID::WR_ADDR)); - mem.past_wr_data = get_state(cell->getPort(ID::WR_DATA)); + for (int i = 0; i < GetSize(mem.mem->wr_ports); i++) { + auto &port = mem.mem->wr_ports[i]; + mem.past_wr_clk[i] = get_state(port.clk); + mem.past_wr_en[i] = get_state(port.en); + mem.past_wr_addr[i] = get_state(port.addr); + mem.past_wr_data[i] = get_state(port.data); + } } for (auto cell : formal_database) @@ -563,17 +554,13 @@ struct SimInstance for (auto &it : mem_database) { - Cell *cell = it.first; mem_state_t &mem = it.second; - Const initval = mem.data; - - while (GetSize(initval) >= 2) { - if (initval[GetSize(initval)-1] != State::Sx) break; - if (initval[GetSize(initval)-2] != State::Sx) break; - initval.bits.pop_back(); - } - - cell->setParam(ID::INIT, initval); + mem.mem->clear_inits(); + MemInit minit; + minit.addr = mem.mem->start_offset; + minit.data = mem.data; + mem.mem->inits.push_back(minit); + mem.mem->emit(); } for (auto it : children) diff --git a/techlibs/nexus/Makefile.inc b/techlibs/nexus/Makefile.inc new file mode 100644 index 000000000..e0ff40e15 --- /dev/null +++ b/techlibs/nexus/Makefile.inc @@ -0,0 +1,14 @@ +OBJS += techlibs/nexus/synth_nexus.o + +$(eval $(call add_share_file,share/nexus,techlibs/nexus/cells_map.v)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/cells_sim.v)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/parse_init.vh)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/cells_xtra.v)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/lutrams_map.v)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/lutrams.txt)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/brams_init.vh)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/brams_map.v)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/brams.txt)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/arith_map.v)) +$(eval $(call add_share_file,share/nexus,techlibs/nexus/latches_map.v)) + diff --git a/techlibs/nexus/arith_map.v b/techlibs/nexus/arith_map.v new file mode 100644 index 000000000..fd9d61be3 --- /dev/null +++ b/techlibs/nexus/arith_map.v @@ -0,0 +1,99 @@ +/* + * yosys -- Yosys Open SYnthesis Suite + * + * Copyright (C) 2012 Claire Xen <claire@symbioticeda.com> + * Copyright (C) 2018 David Shah <dave@ds0.me> + * + * 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. + * + */ + +(* techmap_celltype = "$alu" *) +module _80_nexus_alu (A, B, CI, BI, X, Y, CO); + parameter A_SIGNED = 0; + parameter B_SIGNED = 0; + parameter A_WIDTH = 1; + parameter B_WIDTH = 1; + parameter Y_WIDTH = 1; + + (* force_downto *) + input [A_WIDTH-1:0] A; + (* force_downto *) + input [B_WIDTH-1:0] B; + (* force_downto *) + output [Y_WIDTH-1:0] X, Y; + + input CI, BI; + (* force_downto *) + output [Y_WIDTH-1:0] CO; + + wire _TECHMAP_FAIL_ = Y_WIDTH <= 4; + + (* force_downto *) + wire [Y_WIDTH-1:0] A_buf, B_buf; + \$pos #(.A_SIGNED(A_SIGNED), .A_WIDTH(A_WIDTH), .Y_WIDTH(Y_WIDTH)) A_conv (.A(A), .Y(A_buf)); + \$pos #(.A_SIGNED(B_SIGNED), .A_WIDTH(B_WIDTH), .Y_WIDTH(Y_WIDTH)) B_conv (.A(B), .Y(B_buf)); + + function integer round_up2; + input integer N; + begin + round_up2 = ((N + 1) / 2) * 2; + end + endfunction + + localparam Y_WIDTH2 = round_up2(Y_WIDTH); + + (* force_downto *) + wire [Y_WIDTH2-1:0] AA = A_buf; + (* force_downto *) + wire [Y_WIDTH2-1:0] BB = BI ? ~B_buf : B_buf; + (* force_downto *) + wire [Y_WIDTH2-1:0] BX = B_buf; + (* force_downto *) + wire [Y_WIDTH2+1:0] FCO, Y1; + + genvar i; + + // Carry feed-in + CCU2 #( + .INIT0("0xFFFF"), + .INIT1("0x00AA"), + .INJECT("NO") + ) ccu2c_i ( + .A0(1'b1), .B0(1'b1), .C0(1'b1), .D0(1'b1), + .A1(CI), .B1(1'b1), .C1(1'b1), .D1(1'b1), + .COUT(FCO[0]) + ); + + generate for (i = 0; i < Y_WIDTH2; i = i + 2) begin:slice + CCU2 #( + .INIT0("0x96AA"), + .INIT1("0x96AA"), + .INJECT("NO") + ) ccu2c_i ( + .CIN(FCO[i]), + .A0(AA[i]), .B0(BX[i]), .C0(BI), .D0(1'b1), + .A1(AA[i+1]), .B1(BX[i+1]), .C1(BI), .D1(1'b1), + .S0(Y[i]), .S1(Y1[i]), + .COUT(FCO[i+2]) + ); + + assign CO[i] = (AA[i] && BB[i]) || (((i == 0) ? CI : CO[i-1]) && (AA[i] || BB[i])); + if (i+1 < Y_WIDTH) begin + assign CO[i+1] = (AA[i+1] && BB[i+1]) || (CO[i] && (AA[i+1] || BB[i+1])); + assign Y[i+1] = Y1[i]; + end + end endgenerate + + assign X = AA ^ BB; +endmodule diff --git a/techlibs/nexus/brams.txt b/techlibs/nexus/brams.txt new file mode 100644 index 000000000..f7f49b9f0 --- /dev/null +++ b/techlibs/nexus/brams.txt @@ -0,0 +1,60 @@ +bram $__NX_PDP16K + init 1 + + abits 9 @a9d36 + dbits 36 @a9d36 + abits 10 @a10d18 + dbits 18 @a10d18 + abits 11 @a11d9 + dbits 9 @a11d9 + abits 12 @a12d4 + dbits 4 @a12d4 + abits 13 @a13d2 + dbits 2 @a13d2 + abits 14 @a14d1 + dbits 1 @a14d1 + + groups 2 + ports 1 1 + wrmode 1 0 + enable 4 1 @a9d36 + enable 2 1 @a10d18 + enable 1 1 @a11d9 @a12d4 @a13d2 @a14d1 + transp 0 0 + clocks 2 3 + clkpol 2 3 +endbram + +match $__NX_PDP16K + # implicitly requested RAM or ROM + attribute !syn_ramstyle syn_ramstyle=auto + attribute !syn_romstyle syn_romstyle=auto + attribute !ram_block + attribute !rom_block + attribute !logic_block + min bits 2048 + min efficiency 5 + shuffle_enable A + or_next_if_better +endmatch + +match $__NX_PDP16K + # explicitly requested RAM + attribute syn_ramstyle=block_ram ram_block + attribute !syn_romstyle + attribute !rom_block + attribute !logic_block + min wports 1 + shuffle_enable A + or_next_if_better +endmatch + +match $__NX_PDP16K + # explicitly requested ROM + attribute syn_romstyle=ebr rom_block + attribute !syn_ramstyle + attribute !ram_block + attribute !logic_block + max wports 0 + shuffle_enable A +endmatch diff --git a/techlibs/nexus/brams_init.vh b/techlibs/nexus/brams_init.vh new file mode 100644 index 000000000..5b1d0188a --- /dev/null +++ b/techlibs/nexus/brams_init.vh @@ -0,0 +1,64 @@ +.INITVAL_00($sformatf("0x%080x", permute_init(INIT[0 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_01($sformatf("0x%080x", permute_init(INIT[1 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_02($sformatf("0x%080x", permute_init(INIT[2 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_03($sformatf("0x%080x", permute_init(INIT[3 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_04($sformatf("0x%080x", permute_init(INIT[4 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_05($sformatf("0x%080x", permute_init(INIT[5 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_06($sformatf("0x%080x", permute_init(INIT[6 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_07($sformatf("0x%080x", permute_init(INIT[7 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_08($sformatf("0x%080x", permute_init(INIT[8 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_09($sformatf("0x%080x", permute_init(INIT[9 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_0A($sformatf("0x%080x", permute_init(INIT[10 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_0B($sformatf("0x%080x", permute_init(INIT[11 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_0C($sformatf("0x%080x", permute_init(INIT[12 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_0D($sformatf("0x%080x", permute_init(INIT[13 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_0E($sformatf("0x%080x", permute_init(INIT[14 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_0F($sformatf("0x%080x", permute_init(INIT[15 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_10($sformatf("0x%080x", permute_init(INIT[16 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_11($sformatf("0x%080x", permute_init(INIT[17 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_12($sformatf("0x%080x", permute_init(INIT[18 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_13($sformatf("0x%080x", permute_init(INIT[19 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_14($sformatf("0x%080x", permute_init(INIT[20 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_15($sformatf("0x%080x", permute_init(INIT[21 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_16($sformatf("0x%080x", permute_init(INIT[22 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_17($sformatf("0x%080x", permute_init(INIT[23 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_18($sformatf("0x%080x", permute_init(INIT[24 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_19($sformatf("0x%080x", permute_init(INIT[25 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_1A($sformatf("0x%080x", permute_init(INIT[26 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_1B($sformatf("0x%080x", permute_init(INIT[27 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_1C($sformatf("0x%080x", permute_init(INIT[28 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_1D($sformatf("0x%080x", permute_init(INIT[29 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_1E($sformatf("0x%080x", permute_init(INIT[30 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_1F($sformatf("0x%080x", permute_init(INIT[31 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_20($sformatf("0x%080x", permute_init(INIT[32 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_21($sformatf("0x%080x", permute_init(INIT[33 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_22($sformatf("0x%080x", permute_init(INIT[34 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_23($sformatf("0x%080x", permute_init(INIT[35 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_24($sformatf("0x%080x", permute_init(INIT[36 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_25($sformatf("0x%080x", permute_init(INIT[37 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_26($sformatf("0x%080x", permute_init(INIT[38 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_27($sformatf("0x%080x", permute_init(INIT[39 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_28($sformatf("0x%080x", permute_init(INIT[40 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_29($sformatf("0x%080x", permute_init(INIT[41 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_2A($sformatf("0x%080x", permute_init(INIT[42 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_2B($sformatf("0x%080x", permute_init(INIT[43 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_2C($sformatf("0x%080x", permute_init(INIT[44 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_2D($sformatf("0x%080x", permute_init(INIT[45 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_2E($sformatf("0x%080x", permute_init(INIT[46 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_2F($sformatf("0x%080x", permute_init(INIT[47 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_30($sformatf("0x%080x", permute_init(INIT[48 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_31($sformatf("0x%080x", permute_init(INIT[49 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_32($sformatf("0x%080x", permute_init(INIT[50 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_33($sformatf("0x%080x", permute_init(INIT[51 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_34($sformatf("0x%080x", permute_init(INIT[52 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_35($sformatf("0x%080x", permute_init(INIT[53 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_36($sformatf("0x%080x", permute_init(INIT[54 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_37($sformatf("0x%080x", permute_init(INIT[55 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_38($sformatf("0x%080x", permute_init(INIT[56 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_39($sformatf("0x%080x", permute_init(INIT[57 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_3A($sformatf("0x%080x", permute_init(INIT[58 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_3B($sformatf("0x%080x", permute_init(INIT[59 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_3C($sformatf("0x%080x", permute_init(INIT[60 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_3D($sformatf("0x%080x", permute_init(INIT[61 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_3E($sformatf("0x%080x", permute_init(INIT[62 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))), +.INITVAL_3F($sformatf("0x%080x", permute_init(INIT[63 * INIT_CHUNK_SIZE +: INIT_CHUNK_SIZE]))) diff --git a/techlibs/nexus/brams_map.v b/techlibs/nexus/brams_map.v new file mode 100644 index 000000000..214da4326 --- /dev/null +++ b/techlibs/nexus/brams_map.v @@ -0,0 +1,115 @@ +module \$__NX_PDP16K (CLK2, CLK3, A1ADDR, A1DATA, A1EN, B1ADDR, B1DATA, B1EN); + parameter CFG_ABITS = 9; + parameter CFG_DBITS = 36; + parameter CFG_ENABLE_A = 4; + + parameter CLKPOL2 = 1; + parameter CLKPOL3 = 1; + parameter [18431:0] INIT = 18432'b0; + + parameter _TECHMAP_BITS_CONNMAP_ = 8; + parameter [_TECHMAP_BITS_CONNMAP_-1:0] _TECHMAP_CONNMAP_CLK2_ = 0; + parameter [_TECHMAP_BITS_CONNMAP_-1:0] _TECHMAP_CONNMAP_CLK3_ = 0; + + input CLK2; + input CLK3; + + input [CFG_ABITS-1:0] A1ADDR; + input [CFG_DBITS-1:0] A1DATA; + input [CFG_ENABLE_A-1:0] A1EN; + + input [CFG_ABITS-1:0] B1ADDR; + output [CFG_DBITS-1:0] B1DATA; + input B1EN; + + // Address is left justified, in x18 and above lower bits are byte enables + localparam A_SHIFT = + (CFG_DBITS == 36) ? 5 : + (CFG_DBITS == 18) ? 4 : + (CFG_DBITS == 9) ? 3 : + (CFG_DBITS == 4) ? 2 : + (CFG_DBITS == 2) ? 1 : + 0; + + // Different primitives needed for single vs dual clock case + localparam SINGLE_CLOCK = (_TECHMAP_CONNMAP_CLK2_ == _TECHMAP_CONNMAP_CLK3_); + + localparam WIDTH = $sformatf("X%d", CFG_DBITS); + + wire [13:0] ra, wa; + wire [35:0] rd, wd; + + assign ra = {B1ADDR, {A_SHIFT{1'b1}}}; + + generate + if (CFG_ENABLE_A > 1) + assign wa = {A1ADDR, {(A_SHIFT-CFG_ENABLE_A){1'b1}}, A1EN}; + else + assign wa = {A1ADDR, {A_SHIFT{1'b1}}}; + endgenerate + + assign wd = A1DATA; + assign B1DATA = rd[CFG_DBITS-1:0]; + + wire wck, rck; + + generate + if (CLKPOL2) + assign wck = CLK2; + else + INV wck_inv_i (.A(CLK2), .Z(wck)); + if (CLKPOL3) + assign rck = CLK3; + else + INV wck_inv_i (.A(CLK3), .Z(rck)); + endgenerate + + wire we = |A1EN; + + localparam INIT_CHUNK_SIZE = (CFG_DBITS <= 4) ? 256 : 288; + + function [319:0] permute_init; + input [INIT_CHUNK_SIZE-1:0] chunk; + integer i; + begin + if (CFG_DBITS <= 4) begin + for (i = 0; i < 32; i = i + 1'b1) + permute_init[i * 10 +: 10] = {2'b00, chunk[i * 8 +: 8]}; + end else begin + for (i = 0; i < 32; i = i + 1'b1) + permute_init[i * 10 +: 10] = {1'b0, chunk[i * 9 +: 9]}; + end + end + endfunction + + generate + if (SINGLE_CLOCK) begin + PDPSC16K #( + .DATA_WIDTH_W(WIDTH), + .DATA_WIDTH_R(WIDTH), + .OUTREG("BYPASSED"), + .ECC("DISABLED"), + .GSR("DISABLED"), +`include "brams_init.vh" + ) _TECHMAP_REPLACE_ ( + .CLK(wck), .RST(1'b0), + .DI(wd), .ADW(wa), .CEW(we), .CSW(3'b111), + .ADR(ra), .DO(rd), .CER(B1EN), .CSR(3'b111) + ); + end else begin + PDP16K #( + .DATA_WIDTH_W(WIDTH), + .DATA_WIDTH_R(WIDTH), + .OUTREG("BYPASSED"), + .ECC("DISABLED"), + .GSR("DISABLED"), +`include "brams_init.vh" + ) _TECHMAP_REPLACE_ ( + .CLKW(wck), .CLKR(rck), .RST(1'b0), + .DI(wd), .ADW(wa), .CEW(we), .CSW(3'b111), + .ADR(ra), .DO(rd), .CER(B1EN), .CSR(3'b111) + ); + end + endgenerate + +endmodule diff --git a/techlibs/nexus/cells_map.v b/techlibs/nexus/cells_map.v new file mode 100644 index 000000000..86911d7a0 --- /dev/null +++ b/techlibs/nexus/cells_map.v @@ -0,0 +1,106 @@ +// Flipflop intermediate map level +module \$__FF_NOLSR (input D, C, E, output Q); + parameter _TECHMAP_WIREINIT_Q_ = 1'bx; + wire _TECHMAP_REMOVEINIT_Q_ = 1'b1; + generate + if (_TECHMAP_WIREINIT_Q_ === 1'b1) + FD1P3JX #(.GSR("DISABLED")) _TECHMAP_REPLACE_ (.D(D), .CK(C), .SP(E), .PD(1'b0), .Q(Q)); + else + FD1P3IX #(.GSR("DISABLED")) _TECHMAP_REPLACE_ (.D(D), .CK(C), .SP(E), .CD(1'b0), .Q(Q)); + endgenerate +endmodule + +module \$__FF_SYNCLSR (input D, C, E, R, output Q); + parameter SR_VAL = 1'b0; + parameter _TECHMAP_WIREINIT_Q_ = 1'bx; + wire _TECHMAP_REMOVEINIT_Q_ = 1'b1; + wire Ci, Ei, Ri, Rg, Dd; + generate + if (SR_VAL) + FD1P3JX #(.GSR("DISABLED")) _TECHMAP_REPLACE_ (.D(D), .CK(C), .SP(E), .PD(R), .Q(Q)); + else + FD1P3IX #(.GSR("DISABLED")) _TECHMAP_REPLACE_ (.D(D), .CK(C), .SP(E), .CD(R), .Q(Q)); + endgenerate +endmodule + +module \$__FF_ASYNCLSR (input D, C, E, R, output Q); + parameter SR_VAL = 1'b0; + parameter _TECHMAP_WIREINIT_Q_ = 1'bx; + wire _TECHMAP_REMOVEINIT_Q_ = (_TECHMAP_WIREINIT_Q_ === 1'bx || _TECHMAP_WIREINIT_Q_ === SR_VAL); + wire Ci, Ei, Ri, Rg, Dd; + generate + if (SR_VAL) + FD1P3BX #(.GSR("DISABLED")) _TECHMAP_REPLACE_ (.D(D), .CK(C), .SP(E), .PD(R), .Q(Q)); + else + FD1P3DX #(.GSR("DISABLED")) _TECHMAP_REPLACE_ (.D(D), .CK(C), .SP(E), .CD(R), .Q(Q)); + endgenerate +endmodule + + +module \$_DFF_P_ (input D, C, output Q); \$__FF_NOLSR _TECHMAP_REPLACE_ (.D(D), .C(C), .E(1'b1), .Q(Q)); endmodule + +module \$_DFFE_PP_ (input D, C, E, output Q); \$__FF_NOLSR _TECHMAP_REPLACE_ (.D(D), .C(C), .E(E), .Q(Q)); endmodule + +module \$_DFF_PP0_ (input D, C, R, output Q); \$__FF_ASYNCLSR #(0) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(1'b1), .Q(Q)); endmodule +module \$_DFF_PP1_ (input D, C, R, output Q); \$__FF_ASYNCLSR #(1) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(1'b1), .Q(Q)); endmodule + +module \$_SDFF_PP0_ (input D, C, R, output Q); \$__FF_SYNCLSR #(0) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(1'b1), .Q(Q)); endmodule +module \$_SDFF_PP1_ (input D, C, R, output Q); \$__FF_SYNCLSR #(1) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(1'b1), .Q(Q)); endmodule + +module \$_DFFE_PP0P_ (input D, C, E, R, output Q); \$__FF_ASYNCLSR #(0) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(E), .Q(Q)); endmodule +module \$_DFFE_PP1P_ (input D, C, E, R, output Q); \$__FF_ASYNCLSR #(1) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(E), .Q(Q)); endmodule + +module \$_SDFFE_PP0P_ (input D, C, E, R, output Q); \$__FF_SYNCLSR #(0) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(E), .Q(Q)); endmodule +module \$_SDFFE_PP1P_ (input D, C, E, R, output Q); \$__FF_SYNCLSR #(1) _TECHMAP_REPLACE_ (.D(D), .C(C), .R(R), .E(E), .Q(Q)); endmodule + +module \$__NX_TINOUTPAD (input I, OE, output O, inout B); + BB _TECHMAP_REPLACE_ (.I(I), .O(O), .T(~OE), .B(B)); +endmodule + +module \$__NX_TOUTPAD (input I, OE, output O); + OBZ _TECHMAP_REPLACE_ (.I(I), .O(), .T(~OE), .O(O)); +endmodule + +`ifndef NO_LUT +module \$lut (A, Y); + parameter WIDTH = 0; + parameter LUT = 0; + + input [WIDTH-1:0] A; + output Y; + + generate + if (WIDTH == 1) begin + if (LUT == 2'b01) + INV _TECHMAP_REPLACE_ (.A(A[0]), .Z(Y)); + else + LUT4 #(.INIT($sformatf("0x%04x", {{8{LUT[1]}}, {8{LUT[0]}}}))) _TECHMAP_REPLACE_ (.Z(Y), + .D(A[0])); + end else + if (WIDTH == 2) begin + localparam [15:0] INIT = {{4{LUT[3]}}, {4{LUT[2]}}, {4{LUT[1]}}, {4{LUT[0]}}}; + LUT4 #(.INIT($sformatf("0x%04x", INIT))) _TECHMAP_REPLACE_ (.Z(Y), + .C(A[0]), .D(A[1])); + end else + if (WIDTH == 3) begin + localparam [15:0] INIT = {{2{LUT[7]}}, {2{LUT[6]}}, {2{LUT[5]}}, {2{LUT[4]}}, {2{LUT[3]}}, {2{LUT[2]}}, {2{LUT[1]}}, {2{LUT[0]}}}; + LUT4 #(.INIT($sformatf("0x%04x", INIT))) _TECHMAP_REPLACE_ (.Z(Y), + .B(A[0]), .C(A[1]), .D(A[2])); + end else + if (WIDTH == 4) begin + LUT4 #(.INIT($sformatf("0x%04x", LUT))) _TECHMAP_REPLACE_ (.Z(Y), + .A(A[0]), .B(A[1]), .C(A[2]), .D(A[3])); + end else + if (WIDTH == 5) begin + WIDEFN9 #( + .INIT0($sformatf("0x%04x", LUT[15:0 ])), + .INIT1($sformatf("0x%04x", LUT[31:16])), + ) _TECHMAP_REPLACE_ ( + .A0(A[0]), .B0(A[1]), .C0(A[2]), .D0(A[3]), + .A1(A[0]), .B1(A[1]), .C1(A[2]), .D1(A[3]), + .SEL(A[4]), .Z(Y) + ); + end + endgenerate +endmodule +`endif diff --git a/techlibs/nexus/cells_sim.v b/techlibs/nexus/cells_sim.v new file mode 100644 index 000000000..41c8a3c73 --- /dev/null +++ b/techlibs/nexus/cells_sim.v @@ -0,0 +1,379 @@ +(* abc9_lut=1, lib_whitebox *) +module LUT4(input A, B, C, D, output Z); + parameter INIT = "0x0000"; +`include "parse_init.vh" + localparam initp = parse_init(INIT); + wire [7:0] s3 = D ? initp[15:8] : initp[7:0]; + wire [3:0] s2 = C ? s3[ 7:4] : s3[3:0]; + wire [1:0] s1 = B ? s2[ 3:2] : s2[1:0]; + assign Z = A ? s1[1] : s1[0]; + + // Per-input delay differences are considered 'interconnect' + // so not known yet + specify + (A => Z) = 233; + (B => Z) = 233; + (C => Z) = 233; + (D => Z) = 233; + endspecify + +endmodule + +// This is a placeholder for ABC9 to extract the area/delay +// cost of 5-input LUTs and is not intended to be instantiated +(* abc9_lut=2 *) +module \$__ABC9_LUT5 (input SEL, D, C, B, A, output Z); + specify + (SEL => Z) = 171; + (D => Z) = 303; + (C => Z) = 311; + (B => Z) = 309; + (A => Z) = 306; + endspecify +endmodule + +// Two LUT4s and MUX2 +module WIDEFN9(input A0, B0, C0, D0, A1, B1, C1, D1, SEL, output Z); + parameter INIT0 = "0x0000"; + parameter INIT1 = "0x0000"; + wire z0, z1; + LUT4 #(.INIT(INIT0)) lut4_0 (.A(A0), .B(B0), .C(C0), .D(D0), .Z(z0)); + LUT4 #(.INIT(INIT1)) lut4_1 (.A(A1), .B(B1), .C(C1), .D(D1), .Z(z1)); + assign Z = SEL ? z1 : z0; +endmodule + +(* abc9_box, lib_whitebox *) +module INV(input A, output Z); + assign Z = !A; + + specify + (A => Z) = 10; + endspecify +endmodule + +// Bidirectional IO buffer +module BB(input T, I, output O, + (* iopad_external_pin *) inout B); + assign B = T ? 1'bz : O; + assign I = B; +endmodule + +// Input buffer +module IB( + (* iopad_external_pin *) input I, + output O); + assign O = I; +endmodule + +// Output buffer +module OB(input I, + (* iopad_external_pin *) output O); + assign O = I; +endmodule + +// Output buffer with tristate +module OBZ(input I, T, + (* iopad_external_pin *) output O); + assign O = T ? 1'bz : I; +endmodule + +// Constants +module VLO(output Z); + assign Z = 1'b0; +endmodule + +module VHI(output Z); + assign Z = 1'b1; +endmodule + +// Vendor flipflops +// (all have active high clock, enable and set/reset - use INV to invert) + +// Async preset +(* abc9_box, lib_whitebox *) +module FD1P3BX(input D, CK, SP, PD, output reg Q); + parameter GSR = "DISABLED"; + initial Q = 1'b1; + always @(posedge CK or posedge PD) + if (PD) + Q <= 1'b1; + else if (SP) + Q <= D; + specify + $setup(D, posedge CK, 0); + $setup(SP, posedge CK, 212); + $setup(PD, posedge CK, 224); +`ifndef YOSYS + if (PD) (posedge CLK => (Q : 1)) = 0; +`else + if (PD) (PD => Q) = 0; // Technically, this should be an edge sensitive path + // but for facilitating a bypass box, let's pretend it's + // a simple path +`endif + if (!PD && SP) (posedge CK => (Q : D)) = 336; + endspecify +endmodule + +// Async clear +(* abc9_box, lib_whitebox *) +module FD1P3DX(input D, CK, SP, CD, output reg Q); + parameter GSR = "DISABLED"; + initial Q = 1'b0; + always @(posedge CK or posedge CD) + if (CD) + Q <= 1'b0; + else if (SP) + Q <= D; + specify + $setup(D, posedge CK, 0); + $setup(SP, posedge CK, 212); + $setup(CD, posedge CK, 224); +`ifndef YOSYS + if (CD) (posedge CLK => (Q : 0)) = 0; +`else + if (CD) (CD => Q) = 0; // Technically, this should be an edge sensitive path + // but for facilitating a bypass box, let's pretend it's + // a simple path +`endif + if (!CD && SP) (posedge CK => (Q : D)) = 336; + endspecify +endmodule + +// Sync clear +(* abc9_flop, lib_whitebox *) +module FD1P3IX(input D, CK, SP, CD, output reg Q); + parameter GSR = "DISABLED"; + initial Q = 1'b0; + always @(posedge CK) + if (CD) + Q <= 1'b0; + else if (SP) + Q <= D; + specify + $setup(D, posedge CK, 0); + $setup(SP, posedge CK, 212); + $setup(CD, posedge CK, 224); + if (!CD && SP) (posedge CK => (Q : D)) = 336; + endspecify +endmodule + +// Sync preset +(* abc9_flop, lib_whitebox *) +module FD1P3JX(input D, CK, SP, PD, output reg Q); + parameter GSR = "DISABLED"; + initial Q = 1'b1; + always @(posedge CK) + if (PD) + Q <= 1'b1; + else if (SP) + Q <= D; + specify + $setup(D, posedge CK, 0); + $setup(SP, posedge CK, 212); + $setup(PD, posedge CK, 224); + if (!PD && SP) (posedge CK => (Q : D)) = 336; + endspecify +endmodule + +// LUT4 with LUT3 tap for CCU2 use only +(* lib_whitebox *) +module LUT4_3(input A, B, C, D, output Z, Z3); + parameter INIT = "0x0000"; +`include "parse_init.vh" + localparam initp = parse_init(INIT); + wire [7:0] s3 = D ? initp[15:8] : initp[7:0]; + wire [3:0] s2 = C ? s3[ 7:4] : s3[3:0]; + wire [1:0] s1 = B ? s2[ 3:2] : s2[1:0]; + assign Z = A ? s1[1] : s1[0]; + + wire [3:0] s2_3 = C ? initp[ 7:4] : initp[3:0]; + wire [1:0] s1_3 = B ? s2_3[ 3:2] : s2_3[1:0]; + assign Z3 = A ? s1_3[1] : s1_3[0]; + +endmodule + +// Carry primitive (incoporating two LUTs) +(* abc9_box, lib_whitebox *) +module CCU2( + (* abc9_carry *) input CIN, + input A1, B1, C1, D1, A0, B0, C0, D0, + output S1, S0, + (* abc9_carry *) output COUT); + parameter INJECT = "YES"; + parameter INIT0 = "0x0000"; + parameter INIT1 = "0x1111"; + + localparam inject_p = (INJECT == "YES") ? 1'b1 : 1'b0; + + wire LUT3_0, LUT4_0, LUT3_1, LUT4_1, carry_0; + LUT4_3 #(.INIT(INIT0)) lut0 (.A(A0), .B(B0), .C(C0), .D(D0), .Z(LUT4_0), .Z3(LUT3_0)); + LUT4_3 #(.INIT(INIT1)) lut1 (.A(A1), .B(B1), .C(C1), .D(D1), .Z(LUT4_1), .Z3(LUT3_1)); + + assign S0 = LUT4_0 ^ (CIN & ~inject_p); + assign carry_0 = LUT4_0 ? CIN : (LUT3_0 & ~inject_p); + assign S1 = LUT4_1 ^ (carry_0 & ~inject_p); + assign COUT = LUT4_1 ? carry_0 : (LUT3_1 & ~inject_p); + + specify + (A0 => S0) = 233; + (B0 => S0) = 233; + (C0 => S0) = 233; + (D0 => S0) = 233; + (CIN => S0) = 228; + (A0 => S1) = 481; + (B0 => S1) = 481; + (C0 => S1) = 481; + (D0 => S1) = 481; + (A1 => S1) = 233; + (B1 => S1) = 233; + (C1 => S1) = 233; + (D1 => S1) = 233; + (CIN => S1) = 307; + (A0 => COUT) = 347; + (B0 => COUT) = 347; + (C0 => COUT) = 347; + (D0 => COUT) = 347; + (A1 => COUT) = 347; + (B1 => COUT) = 347; + (C1 => COUT) = 347; + (D1 => COUT) = 347; + (CIN => COUT) = 59; + endspecify + +endmodule + +// Packed flipflop +module OXIDE_FF(input CLK, LSR, CE, DI, M, output reg Q); + parameter GSR = "ENABLED"; + parameter [127:0] CEMUX = "1"; + parameter CLKMUX = "CLK"; + parameter LSRMUX = "LSR"; + parameter REGDDR = "DISABLED"; + parameter SRMODE = "LSR_OVER_CE"; + parameter REGSET = "RESET"; + parameter [127:0] LSRMODE = "LSR"; + + wire muxce; + generate + case (CEMUX) + "1": assign muxce = 1'b1; + "0": assign muxce = 1'b0; + "INV": assign muxce = ~CE; + default: assign muxce = CE; + endcase + endgenerate + + wire muxlsr = (LSRMUX == "INV") ? ~LSR : LSR; + wire muxclk = (CLKMUX == "INV") ? ~CLK : CLK; + wire srval; + generate + if (LSRMODE == "PRLD") + assign srval = M; + else + assign srval = (REGSET == "SET") ? 1'b1 : 1'b0; + endgenerate + + initial Q = srval; + + generate + if (REGDDR == "ENABLED") begin + if (SRMODE == "ASYNC") begin + always @(posedge muxclk, negedge muxclk, posedge muxlsr) + if (muxlsr) + Q <= srval; + else if (muxce) + Q <= DI; + end else begin + always @(posedge muxclk, negedge muxclk) + if (muxlsr) + Q <= srval; + else if (muxce) + Q <= DI; + end + end else begin + if (SRMODE == "ASYNC") begin + always @(posedge muxclk, posedge muxlsr) + if (muxlsr) + Q <= srval; + else if (muxce) + Q <= DI; + end else begin + always @(posedge muxclk) + if (muxlsr) + Q <= srval; + else if (muxce) + Q <= DI; + end + end + endgenerate +endmodule + +// Packed combinational logic (for post-pnr sim) +module OXIDE_COMB( + input A, B, C, D, // LUT inputs + input SEL, // mux select input + input F1, // output from LUT 1 for mux + input FCI, // carry input + input WAD0, WAD1, WAD2, WAD3, // LUTRAM write address inputs + input WD, // LUTRAM write data input + input WCK, WRE, // LUTRAM write clock and enable + output F, // LUT/carry output + output OFX // mux output +); + parameter MODE = "LOGIC"; // LOGIC, CCU2, DPRAM + parameter [15:0] INIT = 16'h0000; + parameter INJECT = "YES"; + + localparam inject_p = (INJECT == "YES") ? 1'b1 : 1'b0; + + reg [15:0] lut = INIT; + + wire [7:0] s3 = D ? INIT[15:8] : INIT[7:0]; + wire [3:0] s2 = C ? s3[ 7:4] : s3[3:0]; + wire [1:0] s1 = B ? s2[ 3:2] : s2[1:0]; + wire Z = A ? s1[1] : s1[0]; + + wire [3:0] s2_3 = C ? INIT[ 7:4] : INIT[3:0]; + wire [1:0] s1_3 = B ? s2_3[ 3:2] : s2_3[1:0]; + wire Z3 = A ? s1_3[1] : s1_3[0]; + + generate + if (MODE == "DPRAM") begin + always @(posedge WCK) + if (WRE) + lut[{WAD3, WAD2, WAD1, WAD0}] <= WD; + end + if (MODE == "CCU2") begin + assign F = Z ^ (FCI & ~inject_p); + assign FCO = Z ? FCI : (Z3 & ~inject_p); + end else begin + assign F = Z; + end + endgenerate + + assign OFX = SEL ? F1 : F; + +endmodule + +// LUTRAM +module DPR16X4( + input [3:0] RAD, DI, WAD, + input WRE, WCK, + output [3:0] DO +); + parameter INITVAL = "0x0000000000000000"; +`include "parse_init.vh" + localparam [63:0] parsed_init = parse_init_64(INITVAL); + + reg [3:0] mem[0:15]; + integer i; + initial begin + for (i = 0; i < 15; i++) + mem[i] = parsed_init[i * 4 +: 4]; + end + + always @(posedge WCK) + if (WRE) + mem[WAD] <= DI; + assign DO = mem[RAD]; +endmodule diff --git a/techlibs/nexus/cells_xtra.py b/techlibs/nexus/cells_xtra.py new file mode 100644 index 000000000..dc462c29a --- /dev/null +++ b/techlibs/nexus/cells_xtra.py @@ -0,0 +1,286 @@ +#!/usr/bin/env python3 + +# Based on Xilinx cells_xtra.py; modified for Radiant's structure + +from argparse import ArgumentParser +from io import StringIO +from enum import Enum, auto +import os.path +import sys +import re + + +class Cell: + def __init__(self, name, keep=False, port_attrs={}): + self.name = name + self.keep = keep + self.port_attrs = port_attrs + self.found = False + +class State(Enum): + OUTSIDE = auto() + IN_MODULE = auto() + IN_OTHER_MODULE = auto() + IN_FUNCTION = auto() + IN_TASK = auto() + +devices = [ + ("lifcl", [ + Cell("ACC54"), + Cell("ADC"), + Cell("ALUREG"), + Cell("BB_ADC", keep=True), + Cell("BB_CDR", keep=True), + Cell("BB_I3C_A", keep=True), + Cell("BFD1P3KX"), + Cell("BFD1P3LX"), + Cell("BNKREF18", keep=True), + Cell("CONFIG_LMMI", keep=True), + Cell("DCC"), + Cell("DCS"), + Cell("DDRDLL"), + Cell("DELAYA"), + Cell("DELAYB"), + Cell("DIFFIO18", keep=True), + Cell("DLLDEL"), + Cell("DP16K_MODE"), + Cell("DP16K"), + Cell("DPHY", keep=True), + Cell("DPSC512K"), + Cell("DQSBUF"), + Cell("EBR_CORE"), + Cell("EBR"), + Cell("ECLKDIV"), + Cell("ECLKSYNC"), + Cell("FBMUX"), + Cell("FIFO16K_MODE"), + Cell("FIFO16K"), + Cell("GSR"), + Cell("HSE"), + Cell("I2CFIFO"), + Cell("IDDR71"), + Cell("IDDRX1"), + Cell("IDDRX2DQ"), + Cell("IDDRX2"), + Cell("IDDRX4DQ"), + Cell("IDDRX4"), + Cell("IDDRX5"), + Cell("IFD1P3BX"), + Cell("IFD1P3DX"), + Cell("IFD1P3IX"), + Cell("IFD1P3JX"), + Cell("JTAG", keep=True), + Cell("LRAM"), + Cell("M18X36"), + Cell("MIPI"), + Cell("MULT18"), + Cell("MULT18X18"), + Cell("MULT18X36"), + Cell("MULT36"), + Cell("MULT36X36"), + Cell("MULT9"), + Cell("MULT9X9"), + Cell("MULTADDSUB18X18"), + Cell("MULTADDSUB18X18WIDE"), + Cell("MULTADDSUB18X36"), + Cell("MULTADDSUB36X36"), + Cell("MULTADDSUB9X9WIDE"), + Cell("MULTIBOOT", keep=True), + Cell("MULTPREADD18X18"), + Cell("MULTPREADD9X9"), + Cell("ODDR71"), + Cell("ODDRX1"), + Cell("ODDRX2DQS"), + Cell("ODDRX2DQ"), + Cell("ODDRX2"), + Cell("ODDRX4DQS"), + Cell("ODDRX4DQ"), + Cell("ODDRX4"), + Cell("ODDRX5"), + Cell("OFD1P3BX"), + Cell("OFD1P3DX"), + Cell("OFD1P3IX"), + Cell("OFD1P3JX"), + Cell("OSC"), + Cell("OSCA"), + Cell("OSHX2"), + Cell("OSHX4"), + Cell("PCIE"), + Cell("PCLKDIV"), + Cell("PCLKDIVSP"), + Cell("PDP16K_MODE"), + Cell("PDP16K"), + Cell("PDPSC16K_MODE"), + Cell("PDPSC16K"), + Cell("PDPSC512K"), + Cell("PLL"), + Cell("PREADD9"), + Cell("PUR", keep=True), + Cell("REFMUX"), + Cell("REG18"), + Cell("SEDC", keep=True), + Cell("SEIO18"), + Cell("SEIO33"), + Cell("SGMIICDR"), + Cell("SP16K_MODE"), + Cell("SP16K"), + Cell("SP512K"), + Cell("TSALLA"), + Cell("TSHX2DQS"), + Cell("TSHX2DQ"), + Cell("TSHX4DQS"), + Cell("TSHX4DQ"), + Cell("WDT", keep=True), + + Cell("ACC54_CORE"), + Cell("ADC_CORE"), + Cell("ALUREG_CORE"), + Cell("BNKREF18_CORE"), + Cell("BNKREF33_CORE"), + Cell("DIFFIO18_CORE"), + Cell("CONFIG_CLKRST_CORE", keep=True), + Cell("CONFIG_HSE_CORE", keep=True), + Cell("CONFIG_IP_CORE", keep=True), + Cell("CONFIG_JTAG_CORE", keep=True), + Cell("CONFIG_LMMI_CORE", keep=True), + Cell("CONFIG_MULTIBOOT_CORE", keep=True), + Cell("CONFIG_SEDC_CORE", keep=True), + Cell("CONFIG_WDT_CORE", keep=True), + Cell("DDRDLL_CORE"), + Cell("DLLDEL_CORE"), + Cell("DPHY_CORE"), + Cell("DQSBUF_CORE"), + Cell("ECLKDIV_CORE"), + Cell("ECLKSYNC_CORE"), + Cell("FBMUX_CORE"), + Cell("GSR_CORE"), + Cell("I2CFIFO_CORE"), + Cell("LRAM_CORE"), + Cell("MULT18_CORE"), + Cell("MULT18X36_CORE"), + Cell("MULT36_CORE"), + Cell("MULT9_CORE"), + Cell("OSC_CORE"), + Cell("PCIE_CORE"), + Cell("PLL_CORE"), + Cell("PREADD9_CORE"), + Cell("REFMUX_CORE"), + Cell("REG18_CORE"), + Cell("SEIO18_CORE"), + Cell("SEIO33_CORE"), + Cell("SGMIICDR_CORE"), + ]) +] + +def xtract_cells_decl(device, cells, dirs, outf): + fname = os.path.join(dir, device + '.v') + with open(fname) as f: + state = State.OUTSIDE + # Probably the most horrible Verilog "parser" ever written. + cell = None + for l in f: + l, _, comment = l.partition('//') + l = l.strip() + if l.startswith("module "): + cell_name = l[7:l.find('(')].strip() + cell = None + module_ports = [] + iopad_pin = set() + if state != State.OUTSIDE: + print('Nested modules in {}.'.format(fname)) + sys.exit(1) + for c in cells: + if c.name != cell_name: + continue + cell = c + state = State.IN_MODULE + if cell.keep: + outf.write('(* keep *)\n') + outf.write('module {} (...);\n'.format(cell.name)) + cell.found = True + + m = re.search(r'synthesis .*black_box_pad_pin="([^"]*)"', comment) + if m: + iopad_pin = set(m.group(1).split(",")) + + if cell is None: + state = State.IN_OTHER_MODULE + elif l.startswith('task '): + if state == State.IN_MODULE: + state = State.IN_TASK + elif l.startswith('function '): + if state == State.IN_MODULE: + state = State.IN_FUNCTION + elif l == 'endtask': + if state == State.IN_TASK: + state = State.IN_MODULE + elif l == 'endfunction': + if state == State.IN_FUNCTION: + state = State.IN_MODULE + elif l == 'endmodule': + if state == State.IN_MODULE: + for kind, rng, port in module_ports: + for attr in cell.port_attrs.get(port, []): + outf.write(' (* {} *)\n'.format(attr)) + if port in iopad_pin: + outf.write(' (* iopad_external_pin *)\n') + if rng is None: + outf.write(' {} {};\n'.format(kind, port)) + else: + outf.write(' {} {} {};\n'.format(kind, rng, port)) + outf.write(l + '\n') + outf.write('\n') + elif state != State.IN_OTHER_MODULE: + print('endmodule in weird place in {}.'.format(cell.name, fname)) + sys.exit(1) + state = State.OUTSIDE + elif l.startswith(('input ', 'output ', 'inout ')) and state == State.IN_MODULE: + if l.endswith((';', ',')): + l = l[:-1] + if ';' in l: + print('Weird port line in {} [{}].'.format(fname, l)) + sys.exit(1) + kind, _, ports = l.partition(' ') + for port in ports.split(','): + port = port.strip() + if port.startswith('['): + rng, port = port.split() + else: + rng = None + module_ports.append((kind, rng, port)) + elif l.startswith('parameter ') and state == State.IN_MODULE: + if l.endswith((';', ',')): + l = l[:-1] + while ' ' in l: + l = l.replace(' ', ' ') + if ';' in l: + print('Weird parameter line in {} [{}].'.format(fname, l)) + sys.exit(1) + outf.write(' {};\n'.format(l)) + + if state != State.OUTSIDE: + print('endmodule not found in {}.'.format(fname)) + sys.exit(1) + for cell in cells: + if not cell.found: + print('cell {} not found in {}.'.format(cell.name, fname)) +if __name__ == '__main__': + parser = ArgumentParser(description='Extract Lattice blackbox cell definitions from Radiant.') + parser.add_argument('radiant_dir', nargs='?', default='/opt/lscc/radiant/2.0/') + args = parser.parse_args() + + dirs = [ + os.path.join(args.radiant_dir, 'cae_library/synthesis/verilog/'), + ] + for dir in dirs: + if not os.path.isdir(dir): + print('{} is not a directory'.format(dir)) + + out = StringIO() + for device, cells in devices: + xtract_cells_decl(device, cells, dirs, out) + + with open('cells_xtra.v', 'w') as f: + f.write('// Created by cells_xtra.py from Lattice models\n') + f.write('\n') + f.write(out.getvalue()) diff --git a/techlibs/nexus/cells_xtra.v b/techlibs/nexus/cells_xtra.v new file mode 100644 index 000000000..b275e610a --- /dev/null +++ b/techlibs/nexus/cells_xtra.v @@ -0,0 +1,10630 @@ +// Created by cells_xtra.py from Lattice models + +module ACC54 (...); + parameter SIGN = "DISABLED"; + parameter M9ADDSUB_CTRL = "ADDITION"; + parameter ADDSUB_CTRL = "ADD_ADD_CTRL_54_BIT_ADDER"; + parameter STATICOPCODE_EN = "DISABLED"; + parameter OUTREGBYPS = "REGISTER"; + parameter GSR = "ENABLED"; + parameter PROGCONST = "0b000000000000000000000000000000000000000000000000000000"; + parameter CONSTSEL = "BYPASS"; + parameter DSPCASCADE = "DISABLED"; + parameter ACC108CASCADE = "BYPASSCASCADE"; + parameter ACCUMODE = "MODE0"; + parameter ACCUBYPS = "USED"; + parameter CREGBYPS1 = "REGISTER"; + parameter CREGBYPS2 = "REGISTER"; + parameter CREGBYPS3 = "REGISTER"; + parameter CINREGBYPS1 = "REGISTER"; + parameter CINREGBYPS2 = "REGISTER"; + parameter CINREGBYPS3 = "REGISTER"; + parameter LOADREGBYPS1 = "REGISTER"; + parameter LOADREGBYPS2 = "REGISTER"; + parameter LOADREGBYPS3 = "REGISTER"; + parameter M9ADDSUBREGBYPS1 = "REGISTER"; + parameter M9ADDSUBREGBYPS2 = "REGISTER"; + parameter M9ADDSUBREGBYPS3 = "REGISTER"; + parameter ADDSUBSIGNREGBYPS1 = "REGISTER"; + parameter ADDSUBSIGNREGBYPS2 = "REGISTER"; + parameter ADDSUBSIGNREGBYPS3 = "REGISTER"; + parameter ROUNDHALFUP = "DISABLED"; + parameter ROUNDRTZI = "ROUND_TO_ZERO"; + parameter ROUNDBIT = "ROUND_TO_BIT0"; + parameter CASCOUTREGBYPS = "REGISTER"; + parameter SFTEN = "DISABLED"; + parameter RESET = "SYNC"; + input [3:0] SFTCTRL; + input [53:0] DSPIN; + input [71:0] PP; + input [53:0] CINPUT; + input LOAD; + input [1:0] M9ADDSUB; + input [1:0] ADDSUB; + input CIN; + input [1:0] CASIN; + input CEO; + input RSTO; + input CEC; + input RSTC; + input CLK; + input SIGNEDI; + output [35:0] SUM1; + output [35:0] SUM0; + output [53:0] DSPOUT; + output [1:0] CASCOUT; + input ROUNDEN; + input CECIN; + input CECTRL; + input RSTCIN; + input RSTCTRL; +endmodule + +module ADC (...); + parameter ADC_ENP = "ENABLED"; + parameter CLK_DIV = "2"; + parameter CTLCOMPSW1 = "DISABLED"; + parameter CTLCOMPSW2 = "DISABLED"; + parameter CTLCOMPSW3 = "DISABLED"; + parameter DF = "STRAIGHT_BINARY"; + parameter EN_COMP1 = "ENABLED"; + parameter EN_COMP2 = "ENABLED"; + parameter EN_COMP3 = "ENABLED"; + parameter OMA = "BIPOLAR"; + parameter OMB = "BIPOLAR"; + parameter REFBUFAEN = "ENABLED"; + parameter REFBUFBEN = "ENABLED"; + parameter SLEEP = "DISABLED"; + parameter VREFACFG = "1P0_TO_1P2"; + parameter VREFASEL = "INTERNAL"; + parameter VREFBCFG = "1P0_TO_1P2"; + parameter VREFBSEL = "INTERNAL"; + (* iopad_external_pin *) + input DN0; + (* iopad_external_pin *) + input DN1; + (* iopad_external_pin *) + input DP0; + (* iopad_external_pin *) + input DP1; + input ADCEN; + input CAL; + output CALRDY; + input CHAEN; + input [3:0] CHASEL; + input CHBEN; + input [3:0] CHBSEL; + input CLKDCLK; + input CLKFAB; + output COG; + input COMP1IN; + input COMP1IP; + output COMP1OL; + input COMP2IN; + input COMP2IP; + output COMP2OL; + input COMP3IN; + input COMP3IP; + output COMP3OL; + input CONVSTOP; + output [11:0] DA; + output [11:0] DB; + output EOC; + input [15:0] GPION; + input [15:0] GPIOP; + input RESETN; + input RSTN; + input SOC; + output COMP1O; + output COMP2O; + output COMP3O; +endmodule + +module ALUREG (...); + parameter ALURST_ACTIVELOW = "DISABLE"; + parameter GSR = "ENABLED"; + parameter INREG = "DISABLE"; + parameter MULFXP_ROUND = "ENABLE"; + parameter OUTREG = "DISABLE"; + parameter REGRST_ACTIVELOW = "DISABLE"; + parameter RETAIN = "ENABLE"; + parameter RFASYNC_RD = "SYNC_RD"; + parameter RFR0_RO = "R0READONLY"; + parameter RFUNALIA_WR = "DISABLE"; + parameter RFWCLK_INV = "SIG"; + input ALUCLK; + output ALUFLAGC; + output ALUFLAGV; + output ALUFLAGZ; + input ALUFORWARDA; + input ALUFORWARDB; + input ALUIREGEN; + input ALUOREGEN; + input ALURST; + input [31:0] DATAA; + input [31:0] DATAB; + input [4:0] DATAC; + input [6:0] OPC; + input OPCCUSTOM; + input [4:0] RADDRA; + input [4:0] RADDRB; + output [31:0] RDATAA; + output [31:0] RDATAB; + input REGCLK; + input REGCLKEN; + input REGRST; + output [31:0] RESULT; + input [4:0] WADDR; + input [1:0] WDROTATE; + input WDSIGNEXT; + input [1:0] WDSIZE; + input [31:0] WDATA; + input WREN; +endmodule + +(* keep *) +module BB_ADC (...); + (* iopad_external_pin *) + inout IOPAD; + output INADC; +endmodule + +(* keep *) +module BB_CDR (...); + (* iopad_external_pin *) + inout IOPAD; + output INADC; +endmodule + +(* keep *) +module BB_I3C_A (...); + (* iopad_external_pin *) + inout IOPAD; + output PADDI; + input PADDO; + input PADDT; + input I3CRESEN; + input I3CWKPU; +endmodule + +module BFD1P3KX (...); + parameter GSR = "ENABLED"; + parameter OUTSET = "RESET"; + parameter INSET = "RESET"; + parameter TSSET = "RESET"; + input DOUT; + input DIN; + input DT; + input CEOUT; + input CLKOUT; + input SROUT; + input CEIN; + input CLKIN; + input SRIN; + output QOUT; + output QIN; + output QT; +endmodule + +module BFD1P3LX (...); + parameter GSR = "ENABLED"; + parameter OUTSET = "RESET"; + parameter INSET = "RESET"; + parameter TSSET = "RESET"; + input DOUT; + input DIN; + input DT; + input CEOUT; + input CLKOUT; + input SROUT; + input CEIN; + input CLKIN; + input SRIN; + output QOUT; + output QIN; + output QT; +endmodule + +(* keep *) +module BNKREF18 (...); + parameter BANK = "0b0000"; + parameter STANDBY_DIFFIO = "DISABLED"; + parameter STANDBY_INR = "DISABLED"; + input STDBYINR; + input STDBYDIF; + output [6:0] PVTCODE; +endmodule + +(* keep *) +module CONFIG_LMMI (...); + parameter LMMI_EN = "DIS"; + input LMMICLK; + input LMMIREQUEST; + input LMMIWRRD_N; + input [7:0] LMMIOFFSET; + input [7:0] LMMIWDATA; + output [7:0] LMMIRDATA; + output LMMIREADY; + output LMMIRDATAVALID; + input LMMIRESETN; + input RSTSMCLK; + input SMCLK; +endmodule + +module DDRDLL (...); + parameter GSR = "ENABLED"; + parameter ENA_ROUNDOFF = "ENABLED"; + parameter FORCE_MAX_DELAY = "CODE_OR_LOCK_FROM_DLL_LOOP"; + output [8:0] CODE; + input FREEZE; + output LOCK; + input CLKIN; + input RST; + output [8:0] DCNTL; + input UDDCNTL_N; +endmodule + +module DELAYA (...); + parameter DEL_MODE = "USER_DEFINED"; + parameter DEL_VALUE = "0"; + parameter COARSE_DELAY_MODE = "STATIC"; + parameter COARSE_DELAY = "0NS"; + parameter EDGE_MONITOR = "DISABLED"; + parameter WAIT_FOR_EDGE = "DISABLED"; + input A; + input LOAD_N; + input MOVE; + input DIRECTION; + input COARSE0; + input COARSE1; + input RANKSELECT; + input RANKENABLE; + input RANK0UPDATE; + input RANK1UPDATE; + output Z; + output EDETERR; + output CFLAG; +endmodule + +module DELAYB (...); + parameter DEL_VALUE = "0"; + parameter COARSE_DELAY = "0NS"; + parameter DEL_MODE = "USER_DEFINED"; + input A; + output Z; +endmodule + +(* keep *) +module DIFFIO18 (...); + parameter PULLMODE = "DOWN"; + parameter ENADC_IN = "DISABLED"; + parameter MIPI = "DISABLED"; + input PADDO; + input DOLP; + (* iopad_external_pin *) + inout IOPAD; + output PADDI; + output INLP; + input PADDT; + output INADC; + input HSRXEN; + input HSTXEN; +endmodule + +module DLLDEL (...); + parameter ADJUST = "0"; + parameter DEL_ADJUST = "PLUS"; + parameter ENABLE = "ENABLED"; + input CLKIN; + output CLKOUT; + input [8:0] CODE; + output COUT; + input DIR; + input LOAD_N; + input MOVE; +endmodule + +module DP16K_MODE (...); + parameter DATA_WIDTH_A = "X18"; + parameter DATA_WIDTH_B = "X18"; + parameter OUTREG_A = "BYPASSED"; + parameter OUTREG_B = "BYPASSED"; + parameter GSR = "ENABLED"; + parameter RESETMODE_A = "SYNC"; + parameter RESETMODE_B = "SYNC"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE_A = "000"; + parameter CSDECODE_B = "000"; + parameter ASYNC_RST_RELEASE_A = "SYNC"; + parameter ASYNC_RST_RELEASE_B = "SYNC"; + parameter INIT_DATA = "STATIC"; + input DIA0; + input DIA1; + input DIA2; + input DIA3; + input DIA4; + input DIA5; + input DIA6; + input DIA7; + input DIA8; + input DIA9; + input DIA10; + input DIA11; + input DIA12; + input DIA13; + input DIA14; + input DIA15; + input DIA16; + input DIA17; + input DIB0; + input DIB1; + input DIB2; + input DIB3; + input DIB4; + input DIB5; + input DIB6; + input DIB7; + input DIB8; + input DIB9; + input DIB10; + input DIB11; + input DIB12; + input DIB13; + input DIB14; + input DIB15; + input DIB16; + input DIB17; + input ADA0; + input ADA1; + input ADA2; + input ADA3; + input ADA4; + input ADA5; + input ADA6; + input ADA7; + input ADA8; + input ADA9; + input ADA10; + input ADA11; + input ADA12; + input ADA13; + input ADB0; + input ADB1; + input ADB2; + input ADB3; + input ADB4; + input ADB5; + input ADB6; + input ADB7; + input ADB8; + input ADB9; + input ADB10; + input ADB11; + input ADB12; + input ADB13; + input CLKA; + input CLKB; + input CEA; + input CEB; + input WEA; + input WEB; + input CSA0; + input CSA1; + input CSA2; + input CSB0; + input CSB1; + input CSB2; + input RSTA; + input RSTB; + output DOA0; + output DOA1; + output DOA2; + output DOA3; + output DOA4; + output DOA5; + output DOA6; + output DOA7; + output DOA8; + output DOA9; + output DOA10; + output DOA11; + output DOA12; + output DOA13; + output DOA14; + output DOA15; + output DOA16; + output DOA17; + output DOB0; + output DOB1; + output DOB2; + output DOB3; + output DOB4; + output DOB5; + output DOB6; + output DOB7; + output DOB8; + output DOB9; + output DOB10; + output DOB11; + output DOB12; + output DOB13; + output DOB14; + output DOB15; + output DOB16; + output DOB17; +endmodule + +module DP16K (...); + parameter DATA_WIDTH_A = "X18"; + parameter DATA_WIDTH_B = "X18"; + parameter OUTREG_A = "BYPASSED"; + parameter OUTREG_B = "BYPASSED"; + parameter GSR = "ENABLED"; + parameter RESETMODE_A = "SYNC"; + parameter RESETMODE_B = "SYNC"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE_A = "000"; + parameter CSDECODE_B = "000"; + parameter ASYNC_RST_RELEASE_A = "SYNC"; + parameter ASYNC_RST_RELEASE_B = "SYNC"; + parameter INIT_DATA = "STATIC"; + input [17:0] DIA; + input [17:0] DIB; + input [13:0] ADA; + input [13:0] ADB; + input CLKA; + input CLKB; + input CEA; + input CEB; + input WEA; + input WEB; + input [2:0] CSA; + input [2:0] CSB; + input RSTA; + input RSTB; + output [17:0] DOA; + output [17:0] DOB; +endmodule + +(* keep *) +module DPHY (...); + parameter GSR = "ENABLED"; + parameter AUTO_PD_EN = "POWERED_UP"; + parameter CFG_NUM_LANES = "ONE_LANE"; + parameter CM = "0b00000000"; + parameter CN = "0b00000"; + parameter CO = "0b000"; + parameter CONT_CLK_MODE = "DISABLED"; + parameter DESKEW_EN = "DISABLED"; + parameter DSI_CSI = "CSI2_APP"; + parameter EN_CIL = "CIL_ENABLED"; + parameter HSEL = "DISABLED"; + parameter LANE0_SEL = "LANE_0"; + parameter LOCK_BYP = "GATE_TXBYTECLKHS"; + parameter MASTER_SLAVE = "SLAVE"; + parameter PLLCLKBYPASS = "REGISTERED"; + parameter RSEL = "0b00"; + parameter RXCDRP = "0b00"; + parameter RXDATAWIDTHHS = "0b00"; + parameter RXLPRP = "0b000"; + parameter TEST_ENBL = "0b000000"; + parameter TEST_PATTERN = "0b00000000000000000000000000000000"; + parameter TST = "0b1001"; + parameter TXDATAWIDTHHS = "0b00"; + parameter U_PRG_HS_PREPARE = "0b00"; + parameter U_PRG_HS_TRAIL = "0b000000"; + parameter U_PRG_HS_ZERO = "0b000000"; + parameter U_PRG_RXHS_SETTLE = "0b000000"; + parameter UC_PRG_HS_PREPARE = "1P0_TXCLKESC"; + parameter UC_PRG_HS_TRAIL = "0b00000"; + parameter UC_PRG_HS_ZERO = "0b0000000"; + parameter UC_PRG_RXHS_SETTLE = "0b000000"; + input LMMICLK; + input LMMIRESET_N; + input LMMIREQUEST; + input LMMIWRRD_N; + input [4:0] LMMIOFFSET; + input [3:0] LMMIWDATA; + output [3:0] LMMIRDATA; + output LMMIRDATAVALID; + output LMMIREADY; + input BITCKEXT; + (* iopad_external_pin *) + inout CKN; + (* iopad_external_pin *) + inout CKP; + input CLKREF; + output [1:0] D0ACTIVE; + output [9:0] D0BYTCNT; + output [9:0] D0ERRCNT; + output [1:0] D0PASS; + output [1:0] D0VALID; + output [1:0] D1ACTIVE; + output [9:0] D1BYTCNT; + output [9:0] D1ERRCNT; + output [1:0] D1PASS; + output [1:0] D1VALID; + output [1:0] D2ACTIVE; + output [9:0] D2BYTCNT; + output [9:0] D2ERRCNT; + output [1:0] D2PASS; + output [1:0] D2VALID; + output [1:0] D3ACTIVE; + output [9:0] D3BYTCNT; + output [9:0] D3ERRCNT; + output [1:0] D3PASS; + output [1:0] D3VALID; + output [9:0] DCTSTOUT; + (* iopad_external_pin *) + inout DN0; + (* iopad_external_pin *) + inout DN1; + (* iopad_external_pin *) + inout DN2; + (* iopad_external_pin *) + inout DN3; + (* iopad_external_pin *) + inout DP0; + (* iopad_external_pin *) + inout DP1; + (* iopad_external_pin *) + inout DP2; + (* iopad_external_pin *) + inout DP3; + output LOCK; + input PDDPHY; + input PDPLL; + input SCCLKIN; + output UDIR; + input UED0THEN; + output UERCLP0; + output UERCLP1; + output UERCTRL; + output UERE; + output UERSTHS; + output UERSSHS; + output UERSE; + input UFRXMODE; + input UTXMDTX; + output URXACTHS; + output URXCKE; + input URXCKINE; + output [7:0] URXDE; + output [15:0] URXDHS; + output URXLPDTE; + output URXSKCHS; + output URXDRX; + output [3:0] URXSHS; + output URE0D3DP; + output URE1D3DN; + output URE2CKDP; + output URE3CKDN; + output URXULPSE; + output URXVDE; + output [3:0] URXVDHS; + output USSTT; + input UTDIS; + input UTXCKE; + input UDE0D0TN; + input UDE1D1TN; + input UDE2D2TN; + input UDE3D3TN; + input UDE4CKTN; + input UDE5D0RN; + input UDE6D1RN; + input UDE7D2RN; + input [31:0] UTXDHS; + input UTXENER; + output UTXRRS; + output UTXRYP; + output UTXRYSK; + input UTXRD0EN; + input UTRD0SEN; + input UTXSKD0N; + input UTXTGE0; + input UTXTGE1; + input UTXTGE2; + input UTXTGE3; + input UTXULPSE; + input UTXUPSEX; + input UTXVDE; + input [3:0] UTXWVDHS; + output UUSAN; + output U1DIR; + input U1ENTHEN; + output U1ERCLP0; + output U1ERCLP1; + output U1ERCTRL; + output U1ERE; + output U1ERSTHS; + output U1ERSSHS; + output U1ERSE; + input U1FRXMD; + input U1FTXST; + output U1RXATHS; + output U1RXCKE; + output [7:0] U1RXDE; + output [15:0] U1RXDHS; + output U1RXDTE; + output U1RXSKS; + output U1RXSK; + output [3:0] U1RXSHS; + output U1RE0D; + output U1RE1CN; + output U1RE2D; + output U1RE3N; + output U1RXUPSE; + output U1RXVDE; + output [3:0] U1RXVDHS; + output U1SSTT; + input U1TDIS; + input U1TREQ; + input U1TDE0D3; + input U1TDE1CK; + input U1TDE2D0; + input U1TDE3D1; + input U1TDE4D2; + input U1TDE5D3; + input U1TDE6; + input U1TDE7; + input [31:0] U1TXDHS; + input U1TXLPD; + output U1TXRYE; + output U1TXRY; + output U1TXRYSK; + input U1TXREQ; + input U1TXREQH; + input U1TXSK; + input U1TXTGE0; + input U1TXTGE1; + input U1TXTGE2; + input U1TXTGE3; + input U1TXUPSE; + input U1TXUPSX; + input U1TXVDE; + input [3:0] U1TXWVHS; + output U1USAN; + output U2DIR; + input U2END2; + output U2ERCLP0; + output U2ERCLP1; + output U2ERCTRL; + output U2ERE; + output U2ERSTHS; + output U2ERSSHS; + output U2ERSE; + input U2FRXMD; + input U2FTXST; + output U2RXACHS; + output U2RXCKE; + output [7:0] U2RXDE; + output [15:0] U2RXDHS; + output U2RPDTE; + output U2RXSK; + output U2RXSKC; + output [3:0] U2RXSHS; + output U2RE0D2; + output U2RE1D2; + output U2RE2D3; + output U2RE3D3; + output U2RXUPSE; + output U2RXVDE; + output [3:0] U2RXVDHS; + output U2SSTT; + input U2TDIS; + input U2TREQ; + input U2TDE0D0; + input U2TDE1D1; + input U2TDE2D2; + input U2TDE3D3; + input U2TDE4CK; + input U2TDE5D0; + input U2TDE6D1; + input U2TDE7D2; + input [31:0] U2TXDHS; + input U2TPDTE; + output U2TXRYE; + output U2TXRYH; + output U2TXRYSK; + input U2TXREQ; + input U2TXREQH; + input U2TXSKC; + input U2TXTGE0; + input U2TXTGE1; + input U2TXTGE2; + input U2TXTGE3; + input U2TXUPSE; + input U2TXUPSX; + input U2TXVDE; + input [3:0] U2TXWVHS; + output U2USAN; + output U3DIR; + input U3END3; + output U3ERCLP0; + output U3ERCLP1; + output U3ERCTRL; + output U3ERE; + output U3ERSTHS; + output U3ERSSHS; + output U3ERSE; + input U3FRXMD; + input U3FTXST; + output U3RXATHS; + output U3RXCKE; + output [7:0] U3RXDE; + output [15:0] U3RXDHS; + output U3RPDTE; + output U3RXSK; + output U3RXSKC; + output [3:0] U3RXSHS; + output U3RE0CK; + output U3RE1CK; + output U3RE2; + output U3RE3; + output U3RXUPSE; + output U3RXVDE; + output [3:0] U3RXVDHS; + output U3SSTT; + input U3TDISD2; + input U3TREQD2; + input U3TDE0D3; + input U3TDE1D0; + input U3TDE2D1; + input U3TDE3D2; + input U3TDE4D3; + input U3TDE5CK; + input U3TDE6; + input U3TDE7; + input [31:0] U3TXDHS; + input U3TXLPDT; + output U3TXRY; + output U3TXRYHS; + output U3TXRYSK; + input U3TXREQ; + input U3TXREQH; + input U3TXSKC; + input U3TXTGE0; + input U3TXTGE1; + input U3TXTGE2; + input U3TXTGE3; + input U3TXULPS; + input U3TXUPSX; + input U3TXVD3; + input [3:0] U3TXWVHS; + output U3USAN; + input UCENCK; + output UCRXCKAT; + output UCRXUCKN; + output UCSSTT; + input UCTXREQH; + input UCTXUPSC; + input UCTXUPSX; + output UCUSAN; + input LTSTEN; + input [1:0] LTSTLANE; + output URWDCKHS; + input UTRNREQ; + output UTWDCKHS; + output UCRXWCHS; + output CLKLBACT; +endmodule + +module DPSC512K (...); + parameter OUTREG_A = "NO_REG"; + parameter OUTREG_B = "NO_REG"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_40 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_41 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_42 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_43 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_44 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_45 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_46 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_47 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_48 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_49 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_50 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_51 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_52 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_53 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_54 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_55 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_56 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_57 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_58 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_59 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_60 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_61 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_62 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_63 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_64 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_65 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_66 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_67 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_68 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_69 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_70 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_71 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_72 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_73 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_74 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_75 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_76 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_77 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_78 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_79 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ASYNC_RESET_RELEASE = "SYNC"; + parameter ECC_BYTE_SEL = "ECC_EN"; + input [31:0] DIA; + input [31:0] DIB; + input [13:0] ADA; + input [13:0] ADB; + input CLK; + input CEA; + input CEB; + input WEA; + input WEB; + input CSA; + input CSB; + input RSTA; + input RSTB; + input [3:0] BENA_N; + input [3:0] BENB_N; + input CEOUTA; + input CEOUTB; + output [31:0] DOA; + output [31:0] DOB; + output [1:0] ERRDECA; + output [1:0] ERRDECB; +endmodule + +module DQSBUF (...); + parameter GSR = "ENABLED"; + parameter ENABLE_FIFO = "DISABLED"; + parameter FORCE_READ = "DISABLED"; + parameter FREE_WHEEL = "DDR"; + parameter MODX = "NOT_USED"; + parameter MT_EN_READ = "DISABLED"; + parameter MT_EN_WRITE = "DISABLED"; + parameter MT_EN_WRITE_LEVELING = "DISABLED"; + parameter RD_PNTR = "0b000"; + parameter READ_ENABLE = "DISABLED"; + parameter RX_CENTERED = "ENABLED"; + parameter S_READ = "0"; + parameter S_WRITE = "0"; + parameter SIGN_READ = "POSITIVE"; + parameter SIGN_WRITE = "POSITIVE"; + parameter UPDATE_QU = "UP1_AND_UP0_SAME"; + parameter WRITE_ENABLE = "DISABLED"; + parameter SEL_READ_BIT_ENABLE_CYCLES = "NORMAL"; + parameter BYPASS_WR_LEVEL_SMTH_LATCH = "SMOOTHING_PATH"; + parameter BYPASS_WR_SMTH_LATCH = "SMOOTHING_PATH"; + parameter BYPASS_READ_SMTH_LATCH = "SMOOTHING_PATH"; + output BTDETECT; + output BURSTDETECT; + output DATAVALID; + input DQSI; + output DQSW; + output DQSWRD; + input PAUSE; + input [3:0] RDCLKSEL; + input RDDIR; + input RDLOADN; + output [2:0] RDPNTR; + input [3:0] READ; + output READCOUT; + input READMOVE; + input RST; + input SCLK; + input SELCLK; + output DQSR90; + output DQSW270; + output WRCOUT; + input WRDIR; + input WRLOAD_N; + output WRLVCOUT; + input WRLVDIR; + input WRLVLOAD_N; + input WRLVMOVE; + input WRMOVE; + output [2:0] WRPNTR; + input ECLKIN; + input RSTSMCNT; + input [8:0] DLLCODE; +endmodule + +module EBR_CORE (...); + parameter INIT_DATA = "STATIC"; + parameter DATA_WIDTH_A = "X36"; + parameter DATA_WIDTH_B = "X36"; + parameter REGMODE_A = "BYPASSED"; + parameter REGMODE_B = "BYPASSED"; + parameter GSR = "ENABLED"; + parameter CSDECODE_A = "000"; + parameter CSDECODE_B = "000"; + parameter WID = "0b00000000000"; + parameter RESETMODE_A = "SYNC"; + parameter ASYNC_RESET_RELEASE_A = "SYNC"; + parameter RESETMODE_B = "SYNC"; + parameter ASYNC_RESET_RELEASE_B = "SYNC"; + parameter ECC = "DISABLED"; + parameter EBR_MODE = "DP"; + parameter FULL = "0b11111111100000"; + parameter ALMOST_FULL = "0b00000000000000"; + parameter EMPTY = "0b11111"; + parameter ALMOST_EMPTY = "0b00000000000000"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + input DIA0; + input DIA1; + input DIA2; + input DIA3; + input DIA4; + input DIA5; + input DIA6; + input DIA7; + input DIA8; + input DIA9; + input DIA10; + input DIA11; + input DIA12; + input DIA13; + input DIA14; + input DIA15; + input DIA16; + input DIA17; + input DIB0; + input DIB1; + input DIB2; + input DIB3; + input DIB4; + input DIB5; + input DIB6; + input DIB7; + input DIB8; + input DIB9; + input DIB10; + input DIB11; + input DIB12; + input DIB13; + input DIB14; + input DIB15; + input DIB16; + input DIB17; + input ADA0; + input ADA1; + input ADA2; + input ADA3; + input ADA4; + input ADA5; + input ADA6; + input ADA7; + input ADA8; + input ADA9; + input ADA10; + input ADA11; + input ADA12; + input ADA13; + input ADB0; + input ADB1; + input ADB2; + input ADB3; + input ADB4; + input ADB5; + input ADB6; + input ADB7; + input ADB8; + input ADB9; + input ADB10; + input ADB11; + input ADB12; + input ADB13; + input CLKA; + input CLKB; + input WEA; + input WEB; + input CEA; + input CEB; + input RSTA; + input RSTB; + input CSA0; + input CSA1; + input CSA2; + input CSB0; + input CSB1; + input CSB2; + output FULLF; + output AFULL; + output EMPTYF; + output AEMPTY; + output DOA0; + output DOA1; + output DOA2; + output DOA3; + output DOA4; + output DOA5; + output DOA6; + output DOA7; + output DOA8; + output DOA9; + output DOA10; + output DOA11; + output DOA12; + output DOA13; + output DOA14; + output DOA15; + output DOA16; + output DOA17; + output DOB0; + output DOB1; + output DOB2; + output DOB3; + output DOB4; + output DOB5; + output DOB6; + output DOB7; + output DOB8; + output DOB9; + output DOB10; + output DOB11; + output DOB12; + output DOB13; + output DOB14; + output DOB15; + output DOB16; + output DOB17; + output ONEERR; + output TWOERR; +endmodule + +module EBR (...); + parameter INIT_DATA = "STATIC"; + parameter DATA_WIDTH_A = "X36"; + parameter DATA_WIDTH_B = "X36"; + parameter REGMODE_A = "BYPASSED"; + parameter REGMODE_B = "BYPASSED"; + parameter GSR = "ENABLED"; + parameter CSDECODE_A = "000"; + parameter CSDECODE_B = "000"; + parameter WID = "0b00000000000"; + parameter RESETMODE_A = "SYNC"; + parameter ASYNC_RESET_RELEASE_A = "SYNC"; + parameter RESETMODE_B = "SYNC"; + parameter ASYNC_RESET_RELEASE_B = "SYNC"; + parameter ECC = "DISABLED"; + parameter EBR_MODE = "DP"; + parameter FULL = "0b11111111100000"; + parameter ALMOST_FULL = "0b00000000000000"; + parameter ALMOST_EMPTY = "0b00000000000000"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + input [17:0] DIA; + input [17:0] DIB; + input [13:0] ADA; + input [13:0] ADB; + input CLKA; + input CLKB; + input WEA; + input WEB; + input CEA; + input CEB; + input RSTA; + input RSTB; + input [2:0] CSA; + input [2:0] CSB; + output FULLF; + output AFULL; + output EMPTYF; + output AEMPTY; + output [17:0] DOA; + output [17:0] DOB; + output ONEERR; + output TWOERR; +endmodule + +module ECLKDIV (...); + parameter ECLK_DIV = "DISABLE"; + parameter GSR = "ENABLED"; + output DIVOUT; + input DIVRST; + input ECLKIN; + input SLIP; +endmodule + +module ECLKSYNC (...); + parameter STOP_EN = "DISABLE"; + input ECLKIN; + output ECLKOUT; + input STOP; +endmodule + +module FBMUX (...); + parameter INTFB = "IGNORED"; + parameter SEL_FBK = "DIVA"; + parameter CLKMUX_FB = "CMUX_CLKOP"; + parameter INTFBKDEL_SEL = "DISABLED"; + output ENEXT; + output FBKCK; + input LGYRDYN; + input INTLOCK; + input WKUPSYNC; + input [15:0] FBKCLK; +endmodule + +module FIFO16K_MODE (...); + parameter DATA_WIDTH_A = "X18"; + parameter DATA_WIDTH_B = "X18"; + parameter OUTREG_A = "BYPASSED"; + parameter OUTREG_B = "BYPASSED"; + parameter GSR = "ENABLED"; + parameter RESETMODE_A = "SYNC"; + parameter RESETMODE_B = "SYNC"; + parameter ASYNC_RST_RELEASE_A = "SYNC"; + parameter ASYNC_RST_RELEASE_B = "SYNC"; + parameter ALMOST_FULL = "0b00000000000000"; + parameter ALMOST_EMPTY = "0b00000000000000"; + parameter ECC = "DISABLED"; + parameter FULLBITS = "0b11111111100000"; + input DIA0; + input DIA1; + input DIA2; + input DIA3; + input DIA4; + input DIA5; + input DIA6; + input DIA7; + input DIA8; + input DIA9; + input DIA10; + input DIA11; + input DIA12; + input DIA13; + input DIA14; + input DIA15; + input DIA16; + input DIA17; + input DIB0; + input DIB1; + input DIB2; + input DIB3; + input DIB4; + input DIB5; + input DIB6; + input DIB7; + input DIB8; + input DIB9; + input DIB10; + input DIB11; + input DIB12; + input DIB13; + input DIB14; + input DIB15; + input DIB16; + input DIB17; + input CKA; + input CKB; + input CEA; + input CEB; + input CSA0; + input CSA1; + input CSA2; + input CSB0; + input CSB1; + input CSB2; + input RSTA; + input RSTB; + output DOA0; + output DOA1; + output DOA2; + output DOA3; + output DOA4; + output DOA5; + output DOA6; + output DOA7; + output DOA8; + output DOA9; + output DOA10; + output DOA11; + output DOA12; + output DOA13; + output DOA14; + output DOA15; + output DOA16; + output DOA17; + output DOB0; + output DOB1; + output DOB2; + output DOB3; + output DOB4; + output DOB5; + output DOB6; + output DOB7; + output DOB8; + output DOB9; + output DOB10; + output DOB11; + output DOB12; + output DOB13; + output DOB14; + output DOB15; + output DOB16; + output DOB17; + output ALMOSTFULL; + output FULL; + output ALMOSTEMPTY; + output EMPTY; + output ONEBITERR; + output TWOBITERR; +endmodule + +module FIFO16K (...); + parameter DATA_WIDTH_A = "X18"; + parameter DATA_WIDTH_B = "X18"; + parameter OUTREG_A = "BYPASSED"; + parameter OUTREG_B = "BYPASSED"; + parameter GSR = "ENABLED"; + parameter RESETMODE_A = "SYNC"; + parameter RESETMODE_B = "SYNC"; + parameter ASYNC_RST_RELEASE_A = "SYNC"; + parameter ASYNC_RST_RELEASE_B = "SYNC"; + parameter ALMOST_FULL = "0b00000000000000"; + parameter ALMOST_EMPTY = "0b00000000000000"; + parameter ECC = "DISABLED"; + parameter FULLBITS = "0b11111111100000"; + input [17:0] DIA; + input [17:0] DIB; + input CKA; + input CKB; + input CEA; + input CEB; + input [2:0] CSA; + input [2:0] CSB; + input RSTA; + input RSTB; + output [17:0] DOA; + output [17:0] DOB; + output ALMOSTFULL; + output FULL; + output ALMOSTEMPTY; + output EMPTY; + output ONEBITERR; + output TWOBITERR; +endmodule + +module HSE (...); + parameter MCGLBGSRNDIS = "EN"; + parameter MCHSEDISABLE = "EN"; + parameter MCHSEOTPEN = "DIS"; + input LMMICLK; + input LMMIRESET_N; + input LMMIREQUEST; + input LMMIWRRD_N; + input [17:0] LMMIOFFSET; + input [31:0] LMMIWDATA; + output [31:0] LMMIRDATA; + output LMMIRDATAVALID; + output LMMIREADY; + input ASFCLKI; + output ASFEMPTYO; + output ASFFULLO; + input ASFRDI; + input ASFRESETI; + input ASFWRI; + input CFG_CLK; + input HSE_CLK; + input HSELRSTN; +endmodule + +module I2CFIFO (...); + parameter BRNBASEDELAY = "0b0000"; + parameter CR1CKDIS = "EN"; + parameter CR1FIFOMODE = "REG"; + parameter CR1GCEN = "DIS"; + parameter CR1I2CEN = "DIS"; + parameter CR1SDADELSEL = "NDLY0"; + parameter CR1SLPCLKEN = "DIS"; + parameter CR2CORERSTN = "DIS"; + parameter CR2HARDTIE = "TIE"; + parameter CR2INTCLREN = "DIS"; + parameter CR2MRDCMPLWKUP = "DIS"; + parameter CR2RXFIFOAFWKUP = "DIS"; + parameter CR2SLVADDRWKUP = "DIS"; + parameter GSR = "ENABLED"; + parameter I2CRXFIFOAFVAL = "0b00000"; + parameter I2CSLVADDRA = "0b0000000000"; + parameter I2CTXFIFOAEVAL = "0b0000"; + parameter INTARBLIE = "DIS"; + parameter INTBUSFREEIE = "DIS"; + parameter INTHGCIE = "DIS"; + parameter INTMRDCMPLIE = "DIS"; + parameter INTRNACKIEORRSVD = "DIS"; + parameter INTRSVDORTROEIE = "DIS"; + parameter INTRSVDORTRRDYIE = "DIS"; + parameter INTRXOVERFIEORRSVD = "DIS"; + parameter INTRXUNDERFIE = "DIS"; + parameter INTTXOVERFIE = "DIS"; + parameter INTTXSERRIEORRSVD = "DIS"; + parameter LMMI_EXTRA_ONE = "DIS"; + parameter LMMI_EXTRA_TWO = "DIS"; + parameter NCRALTIOEN = "FABRIC"; + parameter NCRFILTERDIS = "EN"; + parameter NCRSDAINDLYEN = "DIS"; + parameter NCRSDAOUTDLYEN = "DIS"; + parameter NONUSRTESTSOFTTRIMEN = "DIS"; + parameter NONUSRTSTSOFTTRIMVALUE = "0b000"; + parameter REGI2CBR = "0b0000000000"; + parameter TSPTIMERVALUE = "0b10010010111"; + input LMMICLK; + input LMMIRESET_N; + input LMMIREQUEST; + input LMMIWRRD_N; + input [5:0] LMMIOFFSET; + input [7:0] LMMIWDATA; + output [7:0] LMMIRDATA; + output LMMIRDATAVALID; + output LMMIREADY; + input ALTSCLIN; + output ALTSCLOEN; + output ALTSCLOUT; + input ALTSDAIN; + output ALTSDAOEN; + output ALTSDAOUT; + output BUSBUSY; + input FIFORESET; + input I2CLSRRSTN; + output INSLEEP; + output IRQ; + output MRDCMPL; + output RXFIFOAF; + output RXFIFOE; + output RXFIFOF; + input SCLIN; + output SCLOE; + output SCLOEN; + output SCLOUT; + input SDAIN; + output SDAOE; + output SDAOEN; + output SDAOUT; + output SLVADDRMATCH; + output SLVADDRMATCHSCL; + output SRDWR; + output TXFIFOAE; + output TXFIFOE; + output TXFIFOF; +endmodule + +module IDDR71 (...); + parameter GSR = "ENABLED"; + input D; + input SCLK; + input RST; + input ECLK; + input ALIGNWD; + output Q0; + output Q1; + output Q2; + output Q3; + output Q4; + output Q5; + output Q6; +endmodule + +module IDDRX1 (...); + parameter GSR = "ENABLED"; + input D; + input SCLK; + input RST; + output Q0; + output Q1; +endmodule + +module IDDRX2DQ (...); + parameter GSR = "ENABLED"; + input D; + input DQSR90; + input ECLK; + input SCLK; + input RST; + input RDPNTR0; + input RDPNTR1; + input RDPNTR2; + input WRPNTR0; + input WRPNTR1; + input WRPNTR2; + output Q0; + output Q1; + output Q2; + output Q3; +endmodule + +module IDDRX2 (...); + parameter GSR = "ENABLED"; + input D; + input SCLK; + input RST; + input ECLK; + input ALIGNWD; + output Q0; + output Q1; + output Q2; + output Q3; +endmodule + +module IDDRX4DQ (...); + parameter GSR = "ENABLED"; + input D; + input DQSR90; + input ECLK; + input SCLK; + input RST; + input RDPNTR0; + input RDPNTR1; + input RDPNTR2; + input WRPNTR0; + input WRPNTR1; + input WRPNTR2; + output Q0; + output Q1; + output Q2; + output Q3; + output Q4; + output Q5; + output Q6; + output Q7; +endmodule + +module IDDRX4 (...); + parameter GSR = "ENABLED"; + input D; + input SCLK; + input RST; + input ECLK; + input ALIGNWD; + output Q0; + output Q1; + output Q2; + output Q3; + output Q4; + output Q5; + output Q6; + output Q7; +endmodule + +module IDDRX5 (...); + parameter GSR = "ENABLED"; + input D; + input SCLK; + input RST; + input ECLK; + input ALIGNWD; + output Q0; + output Q1; + output Q2; + output Q3; + output Q4; + output Q5; + output Q6; + output Q7; + output Q8; + output Q9; +endmodule + +module IFD1P3BX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input PD; + output Q; +endmodule + +module IFD1P3DX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input CD; + output Q; +endmodule + +module IFD1P3IX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input CD; + output Q; +endmodule + +module IFD1P3JX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input PD; + output Q; +endmodule + +(* keep *) +module JTAG (...); + parameter MCER1EXIST = "NEXIST"; + parameter MCER2EXIST = "NEXIST"; + output JCE1; + output JCE2; + output JRSTN; + output JRTI1; + output JRTI2; + output JSHIFT; + output JTDI; + output JUPDATE; + input JTDO1; + input JTDO2; + input SMCLK; + input TCK; + output JTCK; + input TDI; + output TDO_OEN; + output TDO; + input TMS; +endmodule + +module LRAM (...); + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_40 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_41 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_42 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_43 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_44 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_45 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_46 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_47 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_48 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_49 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_50 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_51 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_52 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_53 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_54 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_55 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_56 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_57 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_58 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_59 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_60 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_61 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_62 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_63 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_64 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_65 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_66 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_67 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_68 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_69 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_70 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_71 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_72 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_73 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_74 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_75 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_76 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_77 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_78 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_79 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter CFG_INIT_ID = "0b00000000000"; + parameter DATA_PRESERVE = "DISABLE"; + parameter EBR_SP_EN = "DISABLE"; + parameter ECC_BYTE_SEL = "ECC_EN"; + parameter GSR = "ENABLED"; + parameter OUT_REGMODE_A = "NO_REG"; + parameter OUT_REGMODE_B = "NO_REG"; + parameter RESETMODE = "SYNC"; + parameter RST_AB_EN = "RESET_AB_DISABLE"; + parameter SP_EN = "DISABLE"; + parameter UNALIGNED_READ = "DISABLE"; + input [13:0] ADA; + input [13:0] ADB; + input [3:0] BENA_N; + input [3:0] BENB_N; + input CEA; + input CEB; + input CLK; + input CSA; + input CSB; + input [31:0] DIA; + input [31:0] DIB; + output [31:0] DOA; + output [31:0] DOB; + input DPS; + output [1:0] ERRDECA; + output [1:0] ERRDECB; + input OCEA; + input OCEB; + output OEA; + output OEB; + input RSTA; + input RSTB; + input WEA; + input WEB; + output ERRDET; + output LRAMREADY; +endmodule + +module M18X36 (...); + parameter SFTEN = "DISABLED"; + parameter MULT18X36 = "ENABLED"; + parameter MULT36 = "DISABLED"; + parameter MULT36X36H = "USED_AS_LOWER_BIT_GENERATION"; + parameter ROUNDHALFUP = "DISABLED"; + parameter ROUNDRTZI = "ROUND_TO_ZERO"; + parameter ROUNDBIT = "ROUND_TO_BIT0"; + input [3:0] SFTCTRL; + input [37:0] PH36; + input [37:0] PL36; + input SGNED18H; + input SGNED18L; + output [72:0] P72; + input ROUNDEN; +endmodule + +module MULT18 (...); + parameter SFTEN = "DISABLED"; + parameter MULT18X18 = "ENABLED"; + parameter ROUNDHALFUP = "DISABLED"; + parameter ROUNDRTZI = "ROUND_TO_ZERO"; + parameter ROUNDBIT = "ROUND_TO_BIT0"; + input [3:0] SFTCTRL; + input ARHSIGN; + input BRHSIGN; + input [8:0] ARH; + input [8:0] BRH; + input [8:0] ARL; + input [8:0] BRL; + input [19:0] PL18; + input [19:0] PH18; + output SIGNED18; + output [37:0] P36; + input ROUNDEN; +endmodule + +module MULT18X18 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [17:0] A; + input [17:0] B; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input SIGNEDA; + input SIGNEDB; + input RSTOUT; + input CEOUT; + output [35:0] Z; +endmodule + +module MULT18X36 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [17:0] A; + input [35:0] B; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input SIGNEDA; + input SIGNEDB; + input RSTOUT; + input CEOUT; + output [53:0] Z; +endmodule + +module MULT36 (...); + parameter MULT36X36 = "ENABLED"; + input [72:0] PH72; + input [72:0] PL72; + output [71:0] PML72; + output [71:0] PMH72; +endmodule + +module MULT36X36 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [35:0] A; + input [35:0] B; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input SIGNEDA; + input SIGNEDB; + input RSTOUT; + input CEOUT; + output [71:0] Z; +endmodule + +module MULT9 (...); + parameter SIGNEDSTATIC_EN = "DISABLED"; + parameter ASIGNED_OPERAND_EN = "DISABLED"; + parameter BYPASS_MULT9 = "USED"; + parameter REGBYPSB = "REGISTER"; + parameter REGBYPSA1 = "REGISTER"; + parameter REGBYPSA2 = "REGISTER"; + parameter SHIFTA = "DISABLED"; + parameter SR_18BITSHIFT_EN = "DISABLED"; + parameter GSR = "ENABLED"; + parameter RESET = "SYNC"; + input [8:0] A; + input ASIGNED; + input [8:0] BR; + input [8:0] AS1; + input [8:0] AS2; + input ASSIGNED1; + input ASSIGNED2; + input BRSIGNED; + input CLK; + input CEA; + input RSTA; + output [8:0] AO; + output [8:0] BO; + output AOSIGNED; + output BOSIGNED; + output [8:0] AR; + output ARSIGNED; + output [19:0] P18; + input CEP; + input RSTP; +endmodule + +module MULT9X9 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [8:0] A; + input [8:0] B; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input SIGNEDA; + input SIGNEDB; + input RSTOUT; + input CEOUT; + output [17:0] Z; +endmodule + +module MULTADDSUB18X18 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGADDSUB = "REGISTER"; + parameter REGLOADC = "REGISTER"; + parameter REGLOADC2 = "REGISTER"; + parameter REGCIN = "REGISTER"; + parameter REGPIPELINE = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [17:0] A; + input [17:0] B; + input [53:0] C; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input CEC; + input RSTC; + input SIGNED; + input RSTPIPE; + input CEPIPE; + input RSTCTRL; + input CECTRL; + input RSTCIN; + input CECIN; + input LOADC; + input ADDSUB; + output [53:0] Z; + input RSTOUT; + input CEOUT; + input CIN; +endmodule + +module MULTADDSUB18X18WIDE (...); + parameter REGINPUTAB0 = "REGISTER"; + parameter REGINPUTAB1 = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGADDSUB = "REGISTER"; + parameter REGLOADC = "REGISTER"; + parameter REGLOADC2 = "REGISTER"; + parameter REGPIPELINE = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [17:0] A0; + input [17:0] B0; + input [17:0] A1; + input [17:0] B1; + input [53:0] C; + input CLK; + input CEA0; + input CEA1; + input RSTA0; + input RSTA1; + input CEB0; + input CEB1; + input RSTB0; + input RSTB1; + input CEC; + input RSTC; + input RSTCTRL; + input CECTRL; + input SIGNED; + input RSTPIPE; + input CEPIPE; + output [53:0] Z; + input RSTOUT; + input CEOUT; + input LOADC; + input [1:0] ADDSUB; +endmodule + +module MULTADDSUB18X36 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGADDSUB = "REGISTER"; + parameter REGLOADC = "REGISTER"; + parameter REGLOADC2 = "REGISTER"; + parameter REGCIN = "REGISTER"; + parameter REGPIPELINE = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [17:0] A; + input [35:0] B; + input [53:0] C; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input CEC; + input RSTC; + input RSTCTRL; + input CECTRL; + input RSTCIN; + input CECIN; + input SIGNED; + input RSTPIPE; + input CEPIPE; + input RSTOUT; + input CEOUT; + output [53:0] Z; + input LOADC; + input ADDSUB; + input CIN; +endmodule + +module MULTADDSUB36X36 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGADDSUB = "REGISTER"; + parameter REGLOADC = "REGISTER"; + parameter REGLOADC2 = "REGISTER"; + parameter REGCIN = "REGISTER"; + parameter REGPIPELINE = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [35:0] A; + input [35:0] B; + input [107:0] C; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input CEC; + input RSTC; + input RSTCTRL; + input CECTRL; + input RSTCIN; + input CECIN; + input SIGNED; + input RSTPIPE; + input CEPIPE; + input RSTOUT; + input CEOUT; + output [107:0] Z; + input LOADC; + input ADDSUB; + input CIN; +endmodule + +module MULTADDSUB9X9WIDE (...); + parameter REGINPUTAB0 = "REGISTER"; + parameter REGINPUTAB1 = "REGISTER"; + parameter REGINPUTAB2 = "REGISTER"; + parameter REGINPUTAB3 = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGADDSUB = "REGISTER"; + parameter REGLOADC = "REGISTER"; + parameter REGLOADC2 = "REGISTER"; + parameter REGPIPELINE = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [8:0] A0; + input [8:0] B0; + input [8:0] A1; + input [8:0] B1; + input [8:0] A2; + input [8:0] B2; + input [8:0] A3; + input [8:0] B3; + input [53:0] C; + input CLK; + input CEA0A1; + input CEA2A3; + input RSTA0A1; + input RSTA2A3; + input CEB0B1; + input CEB2B3; + input RSTB0B1; + input RSTB2B3; + input CEC; + input RSTC; + input RSTCTRL; + input CECTRL; + input SIGNED; + input RSTPIPE; + input CEPIPE; + input RSTOUT; + input CEOUT; + input LOADC; + input [3:0] ADDSUB; + output [53:0] Z; +endmodule + +(* keep *) +module MULTIBOOT (...); + parameter MSPIADDR = "0b00000000000000000000000000000000"; + parameter SOURCESEL = "DIS"; + input AUTOREBOOT; + input [31:0] MSPIMADDR; +endmodule + +module MULTPREADD18X18 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [17:0] A; + input [17:0] B; + input [17:0] C; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input CEC; + input RSTC; + input SIGNEDA; + input SIGNEDB; + input SIGNEDC; + input RSTOUT; + input CEOUT; + output [35:0] Z; +endmodule + +module MULTPREADD9X9 (...); + parameter REGINPUTA = "REGISTER"; + parameter REGINPUTB = "REGISTER"; + parameter REGINPUTC = "REGISTER"; + parameter REGOUTPUT = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + input [8:0] A; + input [8:0] B; + input [8:0] C; + input CLK; + input CEA; + input RSTA; + input CEB; + input RSTB; + input CEC; + input RSTC; + input SIGNEDA; + input SIGNEDB; + input SIGNEDC; + input RSTOUT; + input CEOUT; + output [17:0] Z; +endmodule + +module ODDR71 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input D4; + input D5; + input D6; + input SCLK; + input RST; + input ECLK; + output Q; +endmodule + +module ODDRX1 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input SCLK; + input RST; + output Q; +endmodule + +module ODDRX2DQS (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input DQSW; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module ODDRX2DQ (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input DQSW270; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module ODDRX2 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input SCLK; + input RST; + input ECLK; + output Q; +endmodule + +module ODDRX4DQS (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input D4; + input D5; + input D6; + input D7; + input DQSW; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module ODDRX4DQ (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input D4; + input D5; + input D6; + input D7; + input DQSW270; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module ODDRX4 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input D4; + input D5; + input D6; + input D7; + input SCLK; + input RST; + input ECLK; + output Q; +endmodule + +module ODDRX5 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input D4; + input D5; + input D6; + input D7; + input D8; + input D9; + input SCLK; + input RST; + input ECLK; + output Q; +endmodule + +module OFD1P3BX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input PD; + output Q; +endmodule + +module OFD1P3DX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input CD; + output Q; +endmodule + +module OFD1P3IX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input CD; + output Q; +endmodule + +module OFD1P3JX (...); + parameter GSR = "ENABLED"; + input D; + input SP; + input CK; + input PD; + output Q; +endmodule + +module OSHX2 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module OSHX4 (...); + parameter GSR = "ENABLED"; + input D0; + input D1; + input D2; + input D3; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module PCIE (...); + parameter ENABLE_USER_CFG = "DISABLED"; + parameter PWDN_N = "DISABLED"; + parameter GSR = "ENABLED"; + parameter IDDQ_PCS = "DISABLED"; + parameter PHY_MODE = "0b0000"; + parameter ALT_CLK_SEL_VCC = "PAD"; + parameter L0S_ADJ = "0b00000110000000"; + parameter L0S_EXIT_LATENCY = "MORE_4_US"; + parameter L1_EXIT_LATENCY = "MORE_64_US"; + parameter CALIB_3DB = "ENABLED"; + parameter DB_UPSTREAM = "6DB"; + parameter ERR_REC_ENTRY_SEL = "RCVRY_AFTER"; + parameter A_CHNGD_MAX = "0b100"; + parameter A0_FORCE = "DISABLED"; + parameter A0_FREEZE = "DISABLED"; + parameter A0_INIT = "0b000000"; + parameter A0DIR_VAL = "DISABLED"; + parameter A1_FORCE = "DISABLED"; + parameter A1_FREEZE = "DISABLED"; + parameter A1_INIT = "0b000000"; + parameter A1DIR_VAL = "DISABLED"; + parameter A2_FORCE = "DISABLED"; + parameter A2_FREEZE = "DISABLED"; + parameter A2_INIT = "0b000000"; + parameter A2GAIN_CALIB = "0b100110"; + parameter ACJTAG_REG = "0b00"; + parameter ADDR_LIMIT_PRE_MTHD_CTRL = "0b0100"; + parameter ADDR_LIMIT_TABLE_MTHD_CTRL = "0b00101"; + parameter ADIR_OVR = "DISABLED"; + parameter ADV_CH_CD_SEL = "IMPLEMENT_CH"; + parameter ADV_TARGET_LINK_SPEED_USPORT_A = "DISABLED"; + parameter ADV_TARGET_LINK_SPEED_USPORT_B = "DISABLED"; + parameter ADV_TARGET_LINK_SPEED_USPORT_C = "DISABLED"; + parameter ADV_TARGET_LINK_SPEED_USPORT_D = "DISABLED"; + parameter ADVANCE = "DISABLED"; + parameter ALERT_ENABLE = "0b000"; + parameter ALMOST_EMPTY_10B = "0b001110"; + parameter MID_VALUE_10B = "0b011110"; + parameter ALMOST_EMPTY_20B = "0b001111"; + parameter ALMOST_EMPTY_GEN3 = "0b001100"; + parameter ALMOST_FULL_10B = "0b110000"; + parameter ALMOST_FULL_20B = "0b011000"; + parameter ALMOST_FULL_GEN3 = "0b010110"; + parameter ARRAY_DA = "0b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ARRAY_MT = "0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000011100000000000010000000000000001001000000000000011000000000000001010000000000000100"; + parameter ARXCDRICP_RATE0 = "0b011"; + parameter ARXCDRICP_RATE1 = "0b011"; + parameter ARXCDRICP_RATE2 = "0b011"; + parameter ARXDMPWRDWN = "DISABLED"; + parameter ARXDPPWRDN = "DISABLED"; + parameter ARXEOM_PWRDN = "POWERED_DOWN"; + parameter ARXICP_RATE0 = "0b011"; + parameter ARXICP_RATE1 = "0b011"; + parameter ARXICP_RATE2 = "0b011"; + parameter ARXOVR_OUT = "DISABLED"; + parameter ARXRSACTAT = "0b0001"; + parameter ARXRSAPTAT = "0b1000"; + parameter ARXRSVCTL = "0b00000000"; + parameter ARXSEL_OUT = "DISABLED"; + parameter ASPM_L1_1_SUPPORTED = "SUPPORTED"; + parameter ASPM_L1_2_SUPPORTED = "SUPPORTED"; + parameter ASPM_SUPPORT = "L0S_AND_L1_SUPPORTED"; + parameter ATTENTION_BUTTON_PRESENT = "NOT_SUPPORTED"; + parameter ATTENTION_INDICATOR_PRESENT = "NOT_SUPPORTED"; + parameter ATXICP_RATE0 = "0b101"; + parameter ATXICP_RATE1 = "0b101"; + parameter AUTO_SHIFT = "ENABLED"; + parameter AUX_CURRENT = "SELF_POWERED"; + parameter AUXCLK1US_MAX = "0b00001001"; + parameter AUXIDL_MAX = "0b00000100"; + parameter BAR_INDEX_CFG0_A = "0b000"; + parameter BAR_INDEX_CFG0_B = "0b000"; + parameter BAR_INDEX_CFG0_C = "0b000"; + parameter BAR_INDEX_CFG0_D = "0b000"; + parameter BAR_INDEX_CFG1_A = "0b001"; + parameter BAR_INDEX_CFG1_B = "0b001"; + parameter BAR_INDEX_CFG1_C = "0b001"; + parameter BAR_INDEX_CFG1_D = "0b001"; + parameter BAR_INDEX_CFG2_A = "0b010"; + parameter BAR_INDEX_CFG2_B = "0b010"; + parameter BAR_INDEX_CFG2_C = "0b010"; + parameter BAR_INDEX_CFG2_D = "0b010"; + parameter BAR_INDEX_CFG3_A = "0b011"; + parameter BAR_INDEX_CFG3_B = "0b011"; + parameter BAR_INDEX_CFG3_C = "0b011"; + parameter BAR_INDEX_CFG3_D = "0b011"; + parameter BAR_INDEX_CFG4_A = "0b100"; + parameter BAR_INDEX_CFG4_B = "0b100"; + parameter BAR_INDEX_CFG4_C = "0b100"; + parameter BAR_INDEX_CFG4_D = "0b100"; + parameter BAR_INDEX_CFG5_A = "0b101"; + parameter BAR_INDEX_CFG5_B = "0b101"; + parameter BAR_INDEX_CFG5_C = "0b101"; + parameter BAR_INDEX_CFG5_D = "0b101"; + parameter BIR_MSIX_PBA_A = "BAR0"; + parameter BIR_MSIX_PBA_B = "BAR0"; + parameter BIR_MSIX_PBA_C = "BAR0"; + parameter BIR_MSIX_PBA_D = "BAR0"; + parameter BIR_MSIX_TABLE_A = "BAR0"; + parameter BIR_MSIX_TABLE_B = "BAR0"; + parameter BIR_MSIX_TABLE_C = "BAR0"; + parameter BIR_MSIX_TABLE_D = "BAR0"; + parameter BYP_AVG = "USED"; + parameter BYPASS = "PERFORM_RECEIVER_DETECTION"; + parameter BYPASS_ADDR_DEC = "NORMAL"; + parameter CALIB_SETTLE_MAX = "0b001"; + parameter CALIB_STABLE_MAX = "0b11000"; + parameter CAPABILITY_VERSION = "0b0010"; + parameter CDR_ERR = "DISABLED"; + parameter CDR_P1 = "CDR_PLL_RESET"; + parameter CDR_PLL_DELTA = "0P4_PERCENT"; + parameter CDR_REFERENCE = "0b00"; + parameter CDRPLL_CMP_MAX = "0b00010100"; + parameter CDRPLL_CNT_MAX = "0b00000100"; + parameter CDRPLL_PRE_RXEQ_COARSE_TIMER = "0b01010000"; + parameter CDRPLL_PRE_RXEQ_FINE_TIMER = "0b10110100"; + parameter CDRPLL_PST_RXEQ_COARSE_TIMER = "0b01000000"; + parameter CDRPLL_PST_RXEQ_FINE_TIMER = "0b01000010"; + parameter CFG_A_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_A_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_A_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_A_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_A_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_A_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_B_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_B_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_B_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_B_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_B_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_B_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_C_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_C_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_C_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_C_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_C_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_C_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_D_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_D_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_D_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_D_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_D_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_D_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_EXP_ROM_A = "0b00000000000000000000000000000000"; + parameter CFG_EXP_ROM_B = "0b00000000000000000000000000000000"; + parameter CFG_EXP_ROM_C = "0b00000000000000000000000000000000"; + parameter CFG_EXP_ROM_D = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_A = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_B = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_C = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_D = "0b00000000000000000000000000000000"; + parameter CLASS_CODE_ID3A = "0b000100011000000000000000"; + parameter CLASS_CODE_ID3B = "0b000100011000000000000000"; + parameter CLASS_CODE_ID3C = "0b000100011000000000000000"; + parameter CLASS_CODE_ID3D = "0b000100011000000000000000"; + parameter CM_RESTORE_TIME = "0b00000000"; + parameter CNT250NS_MAX = "0b001111100"; + parameter COARSE_GAIN = "DISABLED"; + parameter COEF_EN_LPBK_MASTER = "OTHERWISE"; + parameter COEF_EN_LPBK_SLAVE = "OTHERWISE"; + parameter COEF_ENABLE = "DETERMINE_LOCAL_PHY"; + parameter COEF_EQTX_FORCE = "0b000000000000000000"; + parameter COEF_LPBK_MASTER = "0b000000000000000000"; + parameter COEF_LPBK_SLAVE = "0b000000000000000000"; + parameter COEF0_POST = "0b000101"; + parameter COEF0_POST_CURSOR = "0b000000"; + parameter COEF0_PRE = "0b000000"; + parameter COEF0_PRE_CURSOR = "0b000000"; + parameter COEF1_POST = "0b000011"; + parameter COEF1_POST_CURSOR = "0b000000"; + parameter COEF1_PRE = "0b000000"; + parameter COEF1_PRE_CURSOR = "0b000000"; + parameter COEF10_POST = "0b000111"; + parameter COEF10_PRE = "0b000000"; + parameter COEF2_POST = "0b000100"; + parameter COEF2_POST_CURSOR = "0b000000"; + parameter COEF2_PRE = "0b000000"; + parameter COEF2_PRE_CURSOR = "0b000000"; + parameter COEF3_POST = "0b000010"; + parameter COEF3_POST_CURSOR = "0b000000"; + parameter COEF3_PRE = "0b000000"; + parameter COEF3_PRE_CURSOR = "0b000000"; + parameter COEF4_POST = "0b000000"; + parameter COEF4_PRE = "0b000000"; + parameter COEF5_POST = "0b000000"; + parameter COEF5_PRE = "0b000001"; + parameter COEF6_POST = "0b000000"; + parameter COEF6_PRE = "0b000010"; + parameter COEF7_POST = "0b000100"; + parameter COEF7_PRE = "0b000011"; + parameter COEF8_POST = "0b000011"; + parameter COEF8_PRE = "0b000010"; + parameter COEF9_POST = "0b000000"; + parameter COEF9_PRE = "0b000011"; + parameter COMP_128_SUPPORTED = "ENABLED"; + parameter COMP_32_SUPPORTED = "ENABLED"; + parameter COMP_64_SUPPORTED = "ENABLED"; + parameter COMPLETE = "DISABLED"; + parameter CONV_METHOD = "COMPUTE_PCIE_SPEC"; + parameter CORE_BYPASS = "NORMAL"; + parameter CORE_EN = "ENABLED"; + parameter COUNT_ACK_TO_NAK = "0b00000000"; + parameter CPL_TIMEOUT_DISABLE_SUPPORTED = "SUPPORTED"; + parameter CPL_TIMEOUT_RANGES_SUPPORTED = "NOT_SUPPORTED"; + parameter CRS_ENABLE = "DISABLED"; + parameter CSTAT_DATA_SCALE = "UNKNOWN_SCALE"; + parameter CSTAT_DATA_SELECT = "D0_POWER_CONSUMED"; + parameter CTLE_SETTLE = "0b100"; + parameter CTLEBIAS_1 = "0b1000"; + parameter ATXICP_RATE2 = "0b100"; + parameter CTLEBYPASS = "DISABLED"; + parameter CUR_FOM = "NUMBER_OF_CLOCK"; + parameter CUR_FOM_AVG = "0b101"; + parameter CUST_AUTO = "DISABLED"; + parameter CUST_CHK = "SET"; + parameter CUST_SEL = "DISABLED"; + parameter CUST_SKIP = "DISABLED"; + parameter CUST_TYP = "0b000"; + parameter CUSTOM_PATTERN = "0b00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter D1_SUPPORT = "SUPPORTED"; + parameter D2_SUPPORT = "SUPPORTED"; + parameter DATA_INJECT = "0b00000000000000000000000000000000"; + parameter DATA_PM = "0b00000000"; + parameter DEEMPH_5G_3_5DB_6DB_N = "6DB"; + parameter DEEMPH_5G_ENABLE = "DISABLED"; + parameter DEEMPH_LPBK_MASTER = "6P0DB"; + parameter DEEMPH_LPBK_SLAVE = "6P0DB"; + parameter DEVICE_ID_ID1A = "0b1110000000000100"; + parameter DEVICE_ID_ID1B = "0b1110000000000100"; + parameter DEVICE_ID_ID1C = "0b1110000000000100"; + parameter DEVICE_ID_ID1D = "0b1110000000000100"; + parameter DEVICE_PORT_TYPE = "PCIE_ENDPOINT"; + parameter DFE_BIAS = "0b0001"; + parameter DFE_PWDN = "DISABLED"; + parameter DIR_PRE_GAIN = "0b00"; + parameter DIR_PST_GAIN = "0b01"; + parameter DIS_ARI_CAP = "ENABLED"; + parameter DIS_CSR_RST = "DISABLED"; + parameter DIS_INTERRUPT = "ENABLED"; + parameter DIS_INTERRUPT_B = "ENABLED"; + parameter DIS_INTERRUPT_C = "ENABLED"; + parameter DIS_INTERRUPT_D = "ENABLED"; + parameter DIS_MSI_CAP = "ENABLED"; + parameter DIS_MSI_CAP_B = "ENABLED"; + parameter DIS_MSI_CAP_C = "ENABLED"; + parameter DIS_MSI_CAP_D = "ENABLED"; + parameter DIS_MSIX_CAP = "ENABLED"; + parameter DIS_MSIX_CAP_B = "ENABLED"; + parameter DIS_MSIX_CAP_C = "ENABLED"; + parameter DIS_MSIX_CAP_D = "ENABLED"; + parameter DISABLE_FLR_CAPABILITY = "ENABLED"; + parameter DLLP_CRC_ERR_ENABLE = "DISABLED"; + parameter DLLP_CRC_ERR_RATE = "0b000000000000"; + parameter DLLP_INJECT_ENABLE = "DISABLED"; + parameter DOUBLE_TX_DATA_VALID = "ONE_CLK_EVERY_64_CLKS"; + parameter DOWNSTREAM_EQ_SKIP_PHASE_2_3 = "NORMAL_OPERATION"; + parameter DS_DRIVE_CLKREQ = "ENABLED"; + parameter DS_PORT_RX_PRESET_HINT = "0b001"; + parameter DS_PORT_TX_PRESET = "0b0011"; + parameter DS_US_N_PORTTYPE = "UPSTREAM"; + parameter DSI = "NO_DSI_NECESSARY"; + parameter DSP_DIR = "ANALYSIS_OF_DATA_BY_DSP"; + parameter DSPDIR_PRESGN = "0b11110000"; + parameter DSPDIR_PREVAL = "0b00011000"; + parameter DSPDIR_PSTSGN0 = "0b11111111"; + parameter DSPDIR_PSTSGN1 = "0b00000000"; + parameter DSPDIR_PSTVAL0 = "0b00000010"; + parameter DSPDIR_PSTVAL1 = "0b01000000"; + parameter EARLY_RX_EVAL = "RX_SIGNAL_AFTER_TS1"; + parameter ECRC_GEN_CHK_CAPABLE = "SUPPORTED"; + parameter EFF_LPBK = "PASSED"; + parameter EI4 = "EI_IV"; + parameter EM_INTERLOCK_PRESENT = "NOT_SUPPORTED"; + parameter EN = "DISABLED"; + parameter EN_ACK_TO_DIV = "ACK_SPEC"; + parameter EN_ACK_TO_NAK = "DO_NOTHING"; + parameter EN_ACS_VIOLATION = "DISABLED"; + parameter EN_ASPM_L0S = "ENABLED"; + parameter EN_ASPM_L1 = "ENABLED"; + parameter EN_ATOMIC_OP_CAP = "ENABLED"; + parameter EN_ATOMICOP_EGRESS_BLOCKED = "DISABLED"; + parameter EN_ATS_CAP = "ENABLED"; + parameter EN_BDGT_CAP = "DISABLED"; + parameter EN_CAP = "ENABLED"; + parameter EN_CAP_B = "ENABLED"; + parameter EN_CAP_C = "ENABLED"; + parameter EN_CAP_D = "ENABLED"; + parameter EN_COMPLETER_ABORT = "DISABLED"; + parameter EN_COMPLETION_TIMEOUT = "ENABLED"; + parameter EN_CORR_INTERNAL_ERROR = "DISABLED"; + parameter EN_DPA_CAP = "DISABLED"; + parameter EN_DRCT_SCR_OFF = "OTHERWISE"; + parameter EN_DRCT_TO_LPBK = "OTHERWISE"; + parameter EN_EQTX_OVERRIDE = "PIPE_LOCAL_FS_AND_PIPE_LOCAL_LF"; + parameter EN_FORCE_SCR_OFF_FAST = "OTHERWISE"; + parameter EN_L1 = "ENABLED"; + parameter EN_L1PMSS_CAP = "ENABLED"; + parameter EN_L2 = "ENABLED"; + parameter EN_LPBK_ERR_RST = "MASTER_LPBK_INCREMENT"; + parameter EN_LTR_CAP = "ENABLED"; + parameter EN_MC_BLOCKED_TLP = "DISABLED"; + parameter EN_NWL_VSEC_CAP = "ENABLED"; + parameter EN_PORT_DIS = "DISABLED"; + parameter EN_PORT_INTLEG = "ENABLED"; + parameter EN_RBAR_CAP_A = "ENABLED"; + parameter EN_RBAR_CAP_B = "ENABLED"; + parameter EN_RBAR_CAP_C = "ENABLED"; + parameter EN_RBAR_CAP_D = "ENABLED"; + parameter EN_RECEIVER_OVERFLOW = "DISABLED"; + parameter EN_SELF_XLINK = "OTHERWISE"; + parameter EN_SURPRISE_DOWN_ERROR = "DISABLED"; + parameter EN_TLP_PREFIX_BLOCKED = "DISABLED"; + parameter EN_UCORR_INTERNAL_ERROR = "DISABLED"; + parameter EN_USER_WRITE = "READ_WRITE_ACCESS"; + parameter END_END_PREFIXES_SUPPORTED = "NOT_SUPPORTED"; + parameter END_ON_HOLD = "YES_EXIT_ON_HOLD"; + parameter ENDCALIB_MAX = "0b10000100"; + parameter ENDPOINT_L0S_ACCEPTABLE_LATENCY = "MAX_64_NS"; + parameter ENDPOINT_L1_ACCEPTABLE_LATENCY = "MAX_1_US"; + parameter ENTRY_TIME_ASPM_L0S = "0b0000000000000000"; + parameter ENTRY_TIME_ASPM_L1 = "0b0000000000000000"; + parameter EOM_TIME = "0b0000000000000000"; + parameter EOM0DIR = "SELECT_DIR_1"; + parameter EOM1DIR = "SELECT_DIR_0"; + parameter EOMCTRL0_LOW = "DISABLED"; + parameter EOMDIVDIS = "DISABLED"; + parameter EOMMODE = "0b00"; + parameter EOMRDSEL = "DISABLED"; + parameter EOMSTART = "DISABLED"; + parameter EOMX = "0b000000"; + parameter EOMX_UPDATE_CNT_VALUE = "0b0011111"; + parameter EOMY = "0b00000000"; + parameter ERRCNT_DEC = "0b00100000"; + parameter ERRCNT_THR = "0b1000"; + parameter ES_PWDN = "DISABLED"; + parameter EVAL_RST = "DISABLED"; + parameter EXCLUDE_L0 = "INCLUDE"; + parameter EXCLUDE_CFG_COMPLETE = "INCLUDE"; + parameter EXCLUDE_CFG_IDLE = "INCLUDE"; + parameter EXCLUDE_LOOPBACK_MASTER = "INCLUDE"; + parameter EXCLUDE_REC_IDLE = "INCLUDE"; + parameter EXCLUDE_REC_RCVR_CFG = "INCLUDE"; + parameter EXIT_DIRECT_TO_DETECT = "DO_NOT_EXIT_TO_DETECT"; + parameter EXT_CONTROL = "DISABLED"; + parameter EXTENDED_TAG_FIELD_EN_DEFAULT = "EIGHT_BIT"; + parameter EXTENDED_TAG_FIELD_SUPPORTED = "EIGHT_BIT"; + parameter F_ARXCTLEDIR = "IGNORED"; + parameter F_ARXCTLENULL = "0b0000"; + parameter F_ARXDMDIR = "DISABLED"; + parameter F_ARXDMNULL = "0b00000"; + parameter F_ARXEOMDIR = "IGNORED"; + parameter F_ARXEOMNULL = "0b00000"; + parameter F_ARXESDIR = "IGNORED"; + parameter F_ARXESNULL = "0b00000"; + parameter F_ARXTDIR = "IGNORED"; + parameter F_ARXTNULL = "0b00000"; + parameter F_ASCHCAL = "IGNORED"; + parameter F_ASCHDIR = "IGNORED"; + parameter F_ASCHNULL = "0b0000"; + parameter FAIL_LIMIT_ERR = "RXEQ_NOT_FAIL"; + parameter FAST = "L0"; + parameter FC_UPDATE_TIMER_DISABLE = "ENABLED"; + parameter FC_UPDATE_TIMER_DIV = "PCIE_REC_VALUES"; + parameter FILTER = "0b1001"; + parameter FINE_GAIN = "DISABLED"; + parameter FOM_COMPARE = "0b00000000"; + parameter FOM_HIRES = "DISABLED"; + parameter FOM_ITERCNT = "0b101"; + parameter FOM_THR = "0b0100"; + parameter FORCE_ATXDRA = "0b000000000000000000000"; + parameter FORCE_ATXDRP = "0b000000000000000000000"; + parameter FORCE_ATXDRR = "0b000000000000000000000"; + parameter FORCE_ATXDRT = "0b000000000000000000000"; + parameter FORCE_DIR_RSLT = "0b000000"; + parameter FORCE_FOM_RSLT = "0b00000000"; + parameter FORCE_IDLE = "DISABLED"; + parameter FORCE_RX_DETECT = "DISABLED"; + parameter FORCE_SIGNAL = "DISABLED"; + parameter FREQ_LOCK = "DISABLED"; + parameter FS = "0b110000"; + parameter GAIN_TIMER1 = "0b0101"; + parameter GEN12_ENA_POST_A0 = "DISABLED"; + parameter GEN12_ENA_POST_A1A2 = "DISABLED"; + parameter GEN12_ENA_PREA0 = "DISABLED"; + parameter GEN3_ENA_POST_A0 = "ENABLED"; + parameter GEN3_ENA_POST_A1A2 = "ENABLED"; + parameter GEN3_ENA_PREA0 = "ENABLED"; + parameter GLOBAL_INVAL_SUPPORT = "ENABLED"; + parameter HINT = "0b000"; + parameter HINT0_3DB = "ENABLED"; + parameter HINT0_A0GAIN = "0b111"; + parameter HINT0_A2GAIN = "0b111"; + parameter HINT1_3DB = "ENABLED"; + parameter HINT1_A0GAIN = "0b011"; + parameter HINT1_A2GAIN = "0b101"; + parameter HINT2_3DB = "ENABLED"; + parameter HINT2_A0GAIN = "0b011"; + parameter HINT2_A2GAIN = "0b111"; + parameter HINT3_3DB = "ENABLED"; + parameter HINT3_A0GAIN = "0b000"; + parameter HINT3_A2GAIN = "0b111"; + parameter HINT4_3DB = "DISABLED"; + parameter HINT4_A0GAIN = "0b111"; + parameter HINT4_A2GAIN = "0b111"; + parameter HINT5_3DB = "DISABLED"; + parameter HINT5_A0GAIN = "0b011"; + parameter HINT5_A2GAIN = "0b101"; + parameter HINT6_3DB = "DISABLED"; + parameter HINT6_A0GAIN = "0b011"; + parameter HINT6_A2GAIN = "0b111"; + parameter HINT7_3DB = "DISABLED"; + parameter HINT7_A0GAIN = "0b000"; + parameter HINT7_A2GAIN = "0b111"; + parameter HINT7_OVR = "DISABLED"; + parameter HLD_RST = "WRITE_1"; + parameter HOT_PLUG_CAPABLE = "NOT_SUPPORTED"; + parameter HOT_PLUG_SURPRISE = "NOT_POSSIBLE"; + parameter ID_DS_PORT = "0b0000000000000000"; + parameter ID_NWL_VSEC_CAP = "0b0000000000000001"; + parameter IGNORE_ECRC = "DISABLED"; + parameter IGNORE_POISON = "ENABLED"; + parameter INDICATOR = "0b00000000000000000000000000000000"; + parameter INHIBIT = "PERFORM_RECEIVER_DETECTION"; + parameter INJECT_DATA_ERROR_0 = "DISABLED"; + parameter INJECT_DATA_ERROR_1 = "DISABLED"; + parameter INJECT_DATA_ERROR_2 = "DISABLED"; + parameter INJECT_DATA_ERROR_3 = "DISABLED"; + parameter INJECT_DATA_ERROR_EN = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_0 = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_1 = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_2 = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_3 = "DISABLED"; + parameter INJECT_RX_1BIT_DATA_ERR = "DISABLED"; + parameter INJECT_RX_2BIT_DATA_ERR = "DISABLED"; + parameter INJECT_RX_SKP_ERR = "DISABLED"; + parameter INJECT_RX_VALID_ERR = "DISABLED"; + parameter INT_CLR = "DISABLED"; + parameter INT_EN = "DISABLED"; + parameter INTERRUPT_MESSAGE_NUMBER = "0b00000"; + parameter INVAL_Q_DEPTH = "0b00000"; + parameter ITERATION_MAX = "0b000000"; + parameter L1_ENTER_PLL_RESET_TIME = "0b100"; + parameter L1_EXIT_PLL_LOCK_TIME = "0b01110"; + parameter L1PM_SUPPORTED = "SUPPORTED"; + parameter L2_D3HOT_ENABLE = "DISABLED"; + parameter LANE_SELECT = "0b0000"; + parameter LF = "0b001000"; + parameter LF_PHY = "0b001010"; + parameter LINK_LANE = "ENABLED"; + parameter LPBK_EN = "DISABLED"; + parameter LW_START_UPDN_ACK_EN = "DISABLED"; + parameter LW_START_UPDN_COUNT = "0b000011111010"; + parameter LW_START_UPDN_EIE_EN = "DISABLED"; + parameter LW_START_UPDN_EN_DIR_DS = "DO_NOT_ASSERT"; + parameter LW_START_UPDN_END_DELAY = "0b1001"; + parameter LW_START_UPDN_RATE_EN_16G = "DISABLED"; + parameter LW_START_UPDN_RATE_EN_2P5G = "ENABLED"; + parameter LW_START_UPDN_RATE_EN_5G = "ENABLED"; + parameter LW_START_UPDN_RATE_EN_8G = "ENABLED"; + parameter LW_START_UPDN_START_DELAY = "0b1000"; + parameter LW_START_UPDN_TIMER_EN = "DISABLED"; + parameter MARGIN_ENABLE = "PCIE_SPEC"; + parameter MARGIN_VALUE = "0b000"; + parameter MASK_0 = "SKIP_RCVR_DETECTION"; + parameter MASK_1 = "SKIP_RCVR_DETECTION"; + parameter MASK_2 = "SKIP_RCVR_DETECTION"; + parameter MASK_3 = "SKIP_RCVR_DETECTION"; + parameter MAX_LINK_WIDTH = "1_LANE"; + parameter MAX_SPEED = "8G"; + parameter MAX_VAR = "0b00100"; + parameter MERGE_LMMI_RDATA = "DISABLED"; + parameter METHOD_FMERIT_CTRL = "STEP_PCIE_TX_PRESETS"; + parameter METHOD_TX_CRED_CLEANUP = "HEADER"; + parameter MGMT_INTLEG = "0b0000"; + parameter MGMT_LTSSM_DIS = "DISABLED"; + parameter MID_VALUE_20B = "0b010100"; + parameter MID_VALUE_GEN3 = "0b001110"; + parameter MIN_SPEED = "2P5G"; + parameter MIN_TIME = "0_MS"; + parameter MIN_TIME_CFG = "4US"; + parameter MIX_DIR = "DISABLED"; + parameter MODE_BFF = "RESTART"; + parameter MRL_SENSOR_PRESENT = "NOT_SUPPORTED"; + parameter MULT_ENABLE = "RECOMMENDED_VALUES"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_A = "EIGHT"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_B = "EIGHT"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_C = "EIGHT"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_D = "EIGHT"; + parameter NFTS = "0b11111111"; + parameter NO_COMMAND_COMPLETED_SUPPORT = "SW_NOTIF_PROVIDED"; + parameter NO_FCMP = "DISABLED"; + parameter NO_REMOTE_CHANGE = "DISABLED"; + parameter NO_TX_IDLE_DELAY = "DATA_VALID_GAP"; + parameter NUM_LANES = "1_LANE"; + parameter NUMBER_DSLINK = "0b00000"; + parameter NUMHI_A = "0b00000000000000000000000000000000"; + parameter NUMHI_B = "0b00000000000000000000000000000000"; + parameter NUMHI_C = "0b00000000000000000000000000000000"; + parameter NUMHI_D = "0b00000000000000000000000000000000"; + parameter NUMHOLD = "SINGLE_HOLD_RESPONSE"; + parameter NUMLO_A = "0b00000000000000000000000000000000"; + parameter NUMLO_B = "0b00000000000000000000000000000000"; + parameter NUMLO_C = "0b00000000000000000000000000000000"; + parameter NUMLO_D = "0b00000000000000000000000000000000"; + parameter OBFF_SUPPORTED = "NOT_SUPPORTED"; + parameter OFFSET_MSIX_PBA_A = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_PBA_B = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_PBA_C = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_PBA_D = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_TABLE_A = "0b00000000000000000110000000000"; + parameter OFFSET_MSIX_TABLE_B = "0b00000000000000000110000000000"; + parameter OFFSET_MSIX_TABLE_C = "0b00000000000000000110000000000"; + parameter OFFSET_MSIX_TABLE_D = "0b00000000000000000110000000000"; + parameter OVER_CTLE = "DISABLED"; + parameter OVER_RX = "DISABLED"; + parameter OVER_RXDM = "DISABLED"; + parameter OVER_RXDP = "DISABLED"; + parameter OVER_RXES = "DISABLED"; + parameter OVER_RXT = "DISABLED"; + parameter OVER_SCH = "DISABLED"; + parameter OVER_TX = "DISABLED"; + parameter OVERRIDE = "DISABLED"; + parameter OVR_CDR = "DISABLED"; + parameter OVR_DIR = "DISABLED"; + parameter OVR_FOM = "DISABLED"; + parameter OVR_GAIN3DB = "ENABLED"; + parameter OVR_HINT3DB = "ENABLED"; + parameter P_CLK_PERIOD = "0b0000111110100000"; + parameter PAR_LPBK = "DISABLED"; + parameter PAS = "10X"; + parameter PATTERN_0 = "UNSCRAMBLED"; + parameter PATTERN_1 = "UNSCRAMBLED"; + parameter PATTERN_2 = "UNSCRAMBLED"; + parameter PCIPM_L1_1_SUPPORTED = "SUPPORTED"; + parameter PCIPM_L1_2_SUPPORTED = "SUPPORTED"; + parameter PERIOD_SRIS_128B130B = "0b000000"; + parameter PERIOD_SRIS_8B10B = "0b00000000"; + parameter PERIOD_SRNS_128B130B = "0b00000000"; + parameter PERIOD_SRNS_8B10B = "0b00000000"; + parameter PHANTOM_FUNCTIONS_SUPPORTED = "NO_FUNCTION_BITS"; + parameter PHYSICAL_SLOT_NUMBER = "0b0000000000001"; + parameter PIN_INTERRUPT_A = "INTA"; + parameter PIN_INTERRUPT_B = "INTA"; + parameter PIN_INTERRUPT_C = "INTA"; + parameter PIN_INTERRUPT_D = "INTA"; + parameter PIPE_TX_SWING = "FULL_SWING"; + parameter PLESIO_LPBK = "DISABLED"; + parameter PM_REDUCE_TIMEOUTS = "DISABLED"; + parameter PMA_DRIVEN_MODE = "PCS_DRIVEN"; + parameter PMCSR_B2_B3_SUPPORT = "DISABLED"; + parameter PMCSR_BUS_P_C_EN = "DISABLED"; + parameter PME_CLOCK = "DISABLED"; + parameter PME_SUPPORT = "0b11111"; + parameter PMFF_ALL = "DISABLED"; + parameter PORT_CM_RESTORE_TIME = "0b00000000"; + parameter PORT_NUMBER = "0b00000000"; + parameter PORT_TPOWER_ON_SCALE = "2_US"; + parameter PORT_TPOWER_ON_VALUE = "0b00000"; + parameter POST = "0b000000"; + parameter POST_A0COEF = "0b001"; + parameter POST_A1COEF = "0b001"; + parameter POST_A2COEF = "0b001"; + parameter POST_CURSOR_LIMIT = "0b100000"; + parameter POST_CURSOR_STEP_SIZE = "0b001000"; + parameter POST_ITERCNT = "0b100"; + parameter POST_STEP = "STEP_SIZE_4"; + parameter POWER_CONTROLLER_PRESENT = "NOT_SUPPORTED"; + parameter POWER_INDICATOR_PRESENT = "NOT_SUPPORTED"; + parameter POWER_REQUIRED = "AUX_POWER_NOT_REQUIRED"; + parameter PRBS_CHK = "DISABLED"; + parameter PRBS_GEN = "DISABLED"; + parameter PRBS_TYP = "PRBS7"; + parameter PRE = "0b000000"; + parameter PRE_A0COEF = "0b101"; + parameter PRE_A1COEF = "0b101"; + parameter PRE_A2COEF = "0b101"; + parameter PRE_CURSOR_LIMIT = "0b010000"; + parameter PRE_CURSOR_STEP_SIZE = "0b000100"; + parameter PRE_FOM = "ENABLED"; + parameter PRE_FOM_AVG = "0b100"; + parameter PRE_ITERCNT = "0b100"; + parameter PRE_RXEQ_TIMER = "0b00010100"; + parameter PRE_STEP = "STEP_SIZE_2"; + parameter PRESET_COUNT_INI = "0b0000"; + parameter PRESET_EN_LPBK_MASTER = "OTHERWISE"; + parameter PRESET_EN_LPBK_SLAVE = "OTHERWISE"; + parameter PRESET_ENABLE = "NORMAL_OP"; + parameter PRESET_EQTX_FORCE = "0b0000"; + parameter PRESET_LPBK_MASTER = "0b0000"; + parameter PRESET_LPBK_SLAVE_0 = "OTHERWISE"; + parameter PRESET_LPBK_SLAVE_1 = "OTHERWISE"; + parameter PRESET_LPBK_SLAVE_2 = "OTHERWISE"; + parameter PRESET_LPBK_SLAVE_3 = "OTHERWISE"; + parameter PRESET_REJECT = "0b00000000000"; + parameter PRESET0_POSTCURSOR = "0b1000"; + parameter PRESET0_PRECURSOR = "0b0000"; + parameter PRESET1_POSTCURSOR = "0b0101"; + parameter PRESET1_PRECURSOR = "0b0000"; + parameter PRESET10_POSTCURSOR = "0b1010"; + parameter PRESET10_PRECURSOR = "0b0000"; + parameter PRESET2_POSTCURSOR = "0b0110"; + parameter PRESET2_PRECURSOR = "0b0000"; + parameter PRESET3_POSTCURSOR = "0b0100"; + parameter PRESET3_PRECURSOR = "0b0000"; + parameter PRESET4_POSTCURSOR = "0b0000"; + parameter PRESET4_PRECURSOR = "0b0000"; + parameter PRESET5_POSTCURSOR = "0b0000"; + parameter PRESET5_PRECURSOR = "0b0011"; + parameter PRESET6_POSTCURSOR = "0b0000"; + parameter PRESET6_PRECURSOR = "0b0100"; + parameter PRESET7_POSTCURSOR = "0b0110"; + parameter PRESET7_PRECURSOR = "0b0011"; + parameter PRESET8_POSTCURSOR = "0b0100"; + parameter PRESET8_PRECURSOR = "0b0100"; + parameter PRESET9_POSTCURSOR = "0b0000"; + parameter PRESET9_PRECURSOR = "0b0101"; + parameter PS_REENTRY_TIME = "0b00000000"; + parameter RATE = "2P5G"; + parameter RATE_ENABLE = "INITIAL_SPEED_CHANGES"; + parameter RCB = "DISABLED"; + parameter REC_SPD_INFER_EQ_PH0123 = "EXCLUDE_TIME_SPENT"; + parameter REC_SPD_INFER_RCVR_CFG = "EXCLUDE_TIME_SPENT"; + parameter REC_SPD_INFER_RCVR_LOCK = "EXCLUDE_TIME_SPENT"; + parameter DIS_FUNC_B = "ENABLED"; + parameter DIS_FUNC_C = "ENABLED"; + parameter DIS_FUNC_D = "ENABLED"; + parameter REDUCE_TIMEOUTS_LTSSMSIM = "DISABLED"; + parameter REDUCE_TIMEOUTS_SIM = "DISABLED"; + parameter REDUCE_TS1 = "DISABLED"; + parameter REENTRY_DISABLE = "ENABLED"; + parameter REENTRY_TIME = "0b00000000000000"; + parameter REQ_FEEDBACK = "0b00000000"; + parameter RESET_EIEOS_INTERVAL_COUNT = "DISABLED"; + parameter REVISION_ID_ID3A = "0b00000100"; + parameter REVISION_ID_ID3B = "0b00000100"; + parameter REVISION_ID_ID3C = "0b00000100"; + parameter REVISION_ID_ID3D = "0b00000100"; + parameter RL1 = "0b0011"; + parameter RL2 = "0b0101"; + parameter RL3 = "0b0011"; + parameter ROUTING_SUPPORTED = "DISABLED"; + parameter RP_COMPLETER_EN = "DISABLED"; + parameter RSTCDR_ERR = "ENABLED"; + parameter RSTCDR_FRQ = "ENABLED"; + parameter RSTCDR_IDL = "DISABLED"; + parameter RX_BYPASS_DECODE_EN = "ENABLED"; + parameter RX_BYPASS_MSG_DEC = "NORMAL_OPERATION"; + parameter RX_CONVERT_UR_TO_CA = "NORMAL_OPERATION"; + parameter RX_D_ALLOC_C = "0b0000000001100000"; + parameter RX_D_ALLOC_N = "0b0000000000000110"; + parameter RX_D_ALLOC_P = "0b0000000001101100"; + parameter RX_DIV_MODE1 = "0b10"; + parameter RX_DIV_MODE0 = "DIV_2"; + parameter RX_DIV_MODE2 = "0b00"; + parameter RX_DL_ACTIVE_DISABLE = "BLOCK_RECEPTION_TLP"; + parameter RX_EARLY_FORWARD_DISABLE = "FWD_RX_DATA_LL"; + parameter RX_ERR_COR = "DISABLED"; + parameter RX_ERR_UCOR = "DISABLED"; + parameter RX_FORCE_RO = "DISABLED"; + parameter RX_H_ALLOC_C = "0b000000100000"; + parameter RX_H_ALLOC_N = "0b000000001000"; + parameter RX_H_ALLOC_P = "0b000000010000"; + parameter RX_HIZ = "IGNORED"; + parameter RX_IMPED_RATIO = "0b10000000"; + parameter RX_INHIBIT_ACK_NAK = "PROCESS_RCVD_ACK"; + parameter RX_INHIBIT_TLP = "PROCESS_RCVD_TLP"; + parameter RX_LCRC_INJECT_EN = "DO_NOT_INJECT_ERROR"; + parameter RX_MALF_INJECT_EN = "DO_NOT_INJECT_ERROR"; + parameter RX_POLINV = "NORMAL"; + parameter RX_PRIORITY = "DISABLED"; + parameter RX_PRIORITY_N_STARVE_THRESH = "0b00010000"; + parameter RX_PRIORITY_P_STARVE_THRESH = "0b00010000"; + parameter RX_PWRDN = "IGNORED"; + parameter RX_TLP_VALID = "DISABLED"; + parameter RXEQ_ALGO = "0b111"; + parameter RXEQ_ENABLE = "0b100"; + parameter RXEQ_EVAL_MAX = "0b11111111"; + parameter RXEQ_MANUAL = "DISABLED"; + parameter RXEQ_STATE = "0b0000"; + parameter RXF_A = "0b0100"; + parameter RXF_B = "0b0100"; + parameter RXF_C = "0b0100"; + parameter RXHF_CLKDN = "ENABLED"; + parameter RXIDLE_MAX = "0b1111"; + parameter RXIDLE_MAX2 = "0b0000010000000000"; + parameter RXIDLE_MSB = "0b11"; + parameter RXM_A = "0b10"; + parameter RXM_B = "0b01"; + parameter RXM_C = "0b00"; + parameter RXN_A = "0b00100"; + parameter RXN_B = "0b01001"; + parameter RXN_C = "0b01111"; + parameter RXOFF_SETTLE_MAX = "0b011"; + parameter RXOFF_STABLE_MAX = "0b10000"; + parameter RXPLLINIT = "DISABLED"; + parameter RXPLLRST = "SET"; + parameter SELECT_DIR_FOM_N = "FME_METHOD"; + parameter SELECTABLE_DEEMPHASIS = "6P0DB"; + parameter SEQ_NUM = "0b000000000000"; + parameter SIGNAL_DETECT_THRESHOLD = "125_MV"; + parameter SIZE_CFG0_A = "0b00000"; + parameter SIZE_CFG0_B = "0b00000"; + parameter SIZE_CFG0_C = "0b00000"; + parameter SIZE_CFG0_D = "0b00000"; + parameter SIZE_CFG1_A = "0b00000"; + parameter SIZE_CFG1_B = "0b00000"; + parameter SIZE_CFG1_C = "0b00000"; + parameter SIZE_CFG1_D = "0b00000"; + parameter SIZE_CFG2_A = "0b00000"; + parameter SIZE_CFG2_B = "0b00000"; + parameter SIZE_CFG2_C = "0b00000"; + parameter SIZE_CFG2_D = "0b00000"; + parameter SIZE_CFG3_A = "0b00000"; + parameter SIZE_CFG3_B = "0b00000"; + parameter SIZE_CFG3_C = "0b00000"; + parameter SIZE_CFG3_D = "0b00000"; + parameter SIZE_CFG4_A = "0b00000"; + parameter SIZE_CFG4_B = "0b00000"; + parameter SIZE_CFG4_C = "0b00000"; + parameter SIZE_CFG4_D = "0b00000"; + parameter SIZE_CFG5_A = "0b00000"; + parameter SIZE_CFG5_B = "0b00000"; + parameter SIZE_CFG5_C = "0b00000"; + parameter SIZE_CFG5_D = "0b00000"; + parameter SKIP_FINAL_COEF_CHECK = "DISABLED"; + parameter SLOT_CLOCK_CONFIGURATION = "REFCLK_BY_SLOT"; + parameter SLOT_IMPLEMENTED = "UNCONNECTED"; + parameter SLOT_POWER_LIMIT_SCALE = "0b00"; + parameter SLOT_POWER_LIMIT_VALUE = "0b00001010"; + parameter SPEED_LPBK_CTRL = "2P5G"; + parameter START_PRESET = "PRESET_VALUE"; + parameter START_REMOTE_ADV = "OTHERWISE"; + parameter STATE_DATA_N = "USE_RX_DATA_OBSERVATION"; + parameter STEP_SELECT = "0b00000"; + parameter STP_OVERRIDE_EN = "DISABLED"; + parameter STP_OVERRIDE_LEN = "0b00000000000"; + parameter STP_OVERRIDE_NEW_LEN = "0b00000000000"; + parameter SUBSTATE_MAX = "0b00000"; + parameter SUBSYSTEM_ID_ID2A = "0b1110000000000100"; + parameter SUBSYSTEM_ID_ID2B = "0b1110000000000100"; + parameter SUBSYSTEM_ID_ID2C = "0b1110000000000100"; + parameter SUBSYSTEM_ID_ID2D = "0b1110000000000100"; + parameter SUBSYSTEM_VENDOR_ID_ID2A = "0b0001100110101010"; + parameter SUBSYSTEM_VENDOR_ID_ID2B = "0b0001100110101010"; + parameter SUBSYSTEM_VENDOR_ID_ID2C = "0b0001100110101010"; + parameter SUBSYSTEM_VENDOR_ID_ID2D = "0b0001100110101010"; + parameter SUPP_SIZE_CFG0_A = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG0_B = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG0_C = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG0_D = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG1_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG1_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG1_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG1_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_D = "0b00000000000000000000"; + parameter SYS_ALLOC = "PWR_BUDGET_CAP_VALUES"; + parameter T0_RX_BYPASS_MSG_DEC = "NORMAL_OPERATION"; + parameter TABLE_SIZE_MSIXCAP_A = "0b00000000111"; + parameter TABLE_SIZE_MSIXCAP_B = "0b00000000111"; + parameter TABLE_SIZE_MSIXCAP_C = "0b00000000111"; + parameter TABLE_SIZE_MSIXCAP_D = "0b00000000111"; + parameter TARGET_LINK_SPEED = "8G"; + parameter TARGET_ONLY = "DISABLED"; + parameter TD1_MEANS_ADD_HAS_N = "ECRC_CONTAINED"; + parameter TIMEOUT_THRESHOLD_PME = "0b000000000000"; + parameter TIMEOUT_THRESHOLD_PME_TO_ACK_DS = "0b00000000"; + parameter TIMER = "0b00000000"; + parameter TLP_LCRC_ERR_ENABLE = "DISABLED"; + parameter TLP_LCRC_ERR_RATE = "0b000"; + parameter TLP_SEQ_ERR_ENABLE = "DISABLED"; + parameter TLUNIT = "1_MS"; + parameter TO_EXTEND = "0b01111111"; + parameter TRNG_A0COEF = "0b101"; + parameter TRNG_A1COEF = "0b101"; + parameter TRNG_A2COEF = "0b101"; + parameter TRNG_FAST = "DISABLED"; + parameter TRNG_ITERCNT = "0b100"; + parameter TRNG_RXEQ_TIMER = "0b00100000"; + parameter TS1_ACK_BLOCK_USE_PRESET = "FORCED_TO_ZERO"; + parameter TS1_ACK_DELAY = "0b00011111"; + parameter TS1_ACK_MASK_USE_PRESET = "IGNORES_USE_PRESET"; + parameter TX_AMP_RATIO_MARGIN0_FULL = "0b10000000"; + parameter TX_AMP_RATIO_MARGIN0_HALF = "0b01010000"; + parameter TX_AMP_RATIO_MARGIN1_FULL = "0b01111000"; + parameter TX_AMP_RATIO_MARGIN1_HALF = "0b01011000"; + parameter TX_AMP_RATIO_MARGIN2_FULL = "0b01101000"; + parameter TX_AMP_RATIO_MARGIN2_HALF = "0b01001000"; + parameter TX_AMP_RATIO_MARGIN3_FULL = "0b01100000"; + parameter TX_AMP_RATIO_MARGIN3_HALF = "0b01000000"; + parameter TX_AMP_RATIO_MARGIN4_FULL = "0b01011000"; + parameter TX_AMP_RATIO_MARGIN4_HALF = "0b00111000"; + parameter TX_AMP_RATIO_MARGIN5_FULL = "0b01010000"; + parameter TX_AMP_RATIO_MARGIN5_HALF = "0b00110000"; + parameter TX_AMP_RATIO_MARGIN6_FULL = "0b01001000"; + parameter TX_AMP_RATIO_MARGIN6_HALF = "0b00101000"; + parameter TX_AMP_RATIO_MARGIN7_FULL = "0b01000000"; + parameter TX_AMP_RATIO_MARGIN7_HALF = "0b00100000"; + parameter TX_BYPASS_DECODE_EN = "ENABLED"; + parameter TX_BYPASS_MSG_DEC = "NORMAL_OPERATION"; + parameter TX_COMP_RECEIVE = "DOES_NOT_ASSERT"; + parameter TX_CONVERT_UR_TO_CA = "NORMAL_OPERATION"; + parameter TX_D_ALLOC_C = "0b0000000001100000"; + parameter TX_D_ALLOC_N = "0b0000000000000110"; + parameter TX_D_ALLOC_P = "0b0000000001101100"; + parameter TX_DIV_MODE0 = "0b10"; + parameter TX_DIV_MODE1 = "0b10"; + parameter TX_DIV_MODE2 = "0b10"; + parameter TX_EQ_EVAL_CNT_SEL = "WAIT_8_CLKS"; + parameter TX_ERR_COR = "DISABLED"; + parameter TX_ERR_UCOR = "DISABLED"; + parameter TX_FORCE_RO = "DISABLED"; + parameter TX_GAP_INJECT_EN = "DO_NOT_INJECT_GAP"; + parameter TX_H_ALLOC_C = "0b000000100000"; + parameter TX_H_ALLOC_N = "0b000000001000"; + parameter TX_H_ALLOC_P = "0b000000010000"; + parameter TX_HIZ = "IGNORED"; + parameter TX_IMPED_RATIO = "0b10000000"; + parameter TX_PAR1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_PAR2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_PAR2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_PAR2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_POLINV = "NORMAL"; + parameter TX_PRE_RATIO = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP0_FULL = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP0_HALF = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP1_FULL = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP1_HALF = "0b00000000"; + parameter TX_PRIORITY = "DISABLED"; + parameter TX_PRIORITY_N_STARVE_THRESH = "0b00010000"; + parameter TX_PRIORITY_P_STARVE_THRESH = "0b00010000"; + parameter TX_PST_RATIO = "0b00010101"; + parameter TX_PST_RATIO_DEEMP0_FULL = "0b00100000"; + parameter TX_PST_RATIO_DEEMP0_HALF = "0b00100000"; + parameter TX_PST_RATIO_DEEMP1_FULL = "0b00010101"; + parameter TX_PST_RATIO_DEEMP1_HALF = "0b00010101"; + parameter TX_QUIESCE = "DISABLED"; + parameter TX_REPLAY_ECC1_HANDLE_DISABLE = "ENABLE_CORRECTION"; + parameter TX_REPLAY_ECC1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_REPLAY_ECC1_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_REPLAY_ECC2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_REPLAY_ECC2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_REPLAY_ECC2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_REQ_EQ = "DISABLED"; + parameter TX_SELECT_RX_FEEDBACK = "REFCLK"; + parameter TX_TLP_VALID = "DISABLED"; + parameter TXF_A = "0b0100"; + parameter TXF_B = "0b0100"; + parameter TXF_C = "0b0100"; + parameter TXHF_CLKDN = "ENABLED"; + parameter TXM_A = "0b10"; + parameter TXM_B = "0b01"; + parameter TXM_C = "0b00"; + parameter TXN_A = "0b00100"; + parameter TXN_B = "0b01001"; + parameter TXN_C = "0b01111"; + parameter TXPLL_INIT = "DISABLED"; + parameter TXPLLRST = "DISABLED"; + parameter TYPE1_TYPE0_N = "ENDPOINT"; + parameter U_CLK_PERIOD = "0b0001111101000000"; + parameter US_PORT_PS_ENTRY_TIME = "0b0000000000000000"; + parameter US_PORT_RX_PRESET_HINT = "0b010"; + parameter US_PORT_TX_PRESET = "0b0100"; + parameter USE_COEF_PRE_MTHD_CTRL = "PRESET_VALUE"; + parameter USE_COEF_UPDN_CTRL = "PRESET_VALUE"; + parameter USER_AUTO_N = "AUTOMATIC_ON_RECEPTION"; + parameter VEC_MASK_CAPABLE_MSICAP_A = "ENABLED"; + parameter VEC_MASK_CAPABLE_MSICAP_B = "ENABLED"; + parameter VEC_MASK_CAPABLE_MSICAP_C = "ENABLED"; + parameter VEC_MASK_CAPABLE_MSICAP_D = "ENABLED"; + parameter VENDOR_ID_ID1A = "0b0001100110101010"; + parameter VENDOR_ID_ID1B = "0b0001100110101010"; + parameter VENDOR_ID_ID1C = "0b0001100110101010"; + parameter VENDOR_ID_ID1D = "0b0001100110101010"; + parameter VENDOR0_UR = "REPORT"; + parameter VERSION_AER_CAP = "VER_0X2"; + parameter VERSION_PM_CAP = "0b011"; + parameter XLCY0 = "0b00000000"; + parameter XLCY1 = "0b00000000"; + parameter RX_ESP_RESP_WAIT = "0b01000000"; + parameter SEL_PCLK_DIV2 = "PCLK_DIV2"; + parameter COMPLIANCE = "ENABLED"; + parameter LOOPBACK = "ENABLED"; + parameter HOT_RESET = "ENABLED"; + parameter DIS_PREVENT = "ENABLED"; + parameter MPS_VIOLATION_RX = "DISABLED"; + parameter MPS_VIOLATION_TX = "DISABLED"; + parameter EN_RX_ALLOC_SEL = "HW"; + parameter EN_TX_ALLOC_SEL = "HW"; + parameter AUX_CLK_PERIOD = "0b1111010000100100"; + parameter EN_PIPE_IF_CTRL = "DISABLED"; + parameter PIPE_PWRDN = "P1"; + parameter TX_CM_DIS = "DEASSERTED"; + parameter RX_EI_DIS = "DEASSERTED"; + parameter PCLKREQ_N = "DEASSERTED"; + parameter STS_PHY_STATUS = "DEASSERTED"; + parameter STS_PIPE_RSTN = "DEASSERTED"; + parameter LEGACY_MODE = "MATCH_TS"; + parameter OVERFLOW = "DISABLED"; + parameter DIR = "RECEIVE"; + parameter SPEED = "8G"; + parameter LANE = "0"; + parameter COEF_ENABLE_8G = "DISABLED"; + parameter PRESET_ENABLE_8G = "DISABLED"; + parameter VALUE_8G_PRE = "0b000000"; + parameter VALUE_8G_POST = "0b000000"; + parameter REQ_EQ_MAX_COUNT = "0b10"; + parameter MESO_LPBK = "DISABLED"; + parameter TX_REPLAY_ECC2_INJECT_M_1_N = "INJECT_1_ERR"; + parameter TX_REPLAY_ECC1_INJECT_M_1_N = "INJECT_1_ERR"; + parameter REDO = "DISABLED"; + parameter RX_PAR_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter RX_PAR_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter RX_ECC2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter RX_ECC2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter RX_ECC2_INJECT_M_1_N = "INJECT_1_ERR"; + parameter RX_ECC2_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter RX_ECC2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter RX_ECC1_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter RX_ECC1_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter RX_ECC1_INJECT_M_1_N = "INJECT_1_ERR"; + parameter RX_ECC1_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter RX_ECC1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter RX_ERR_PAR = "OTHERWISE"; + parameter RX_ERR_ECC2 = "OTHERWISE"; + parameter RX_ERR_ECC1 = "OTHERWISE"; + parameter TX_PAR_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_PAR_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_ECC2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_ECC2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_ECC2_INJECT_M_1_N = "INJECT_1_ERR"; + parameter TX_ECC2_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter TX_ECC2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_ECC1_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_ECC1_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_ECC1_INJECT_M_1_N = "INJECT_1_ERR"; + parameter TX_ECC1_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter TX_ECC1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_ERR_PAR = "OTHERWISE"; + parameter TX_ERR_ECC2 = "OTHERWISE"; + parameter TX_ERR_ECC1 = "OTHERWISE"; + parameter MAX_PAYLOAD_SIZE_SUPPORTED = "256_BYTES"; + parameter ARXCAL_OUT = "DISABLED"; + parameter F_ARXDPDIR = "IGNORED"; + parameter IDLE_INFER_REC_RCVR_CFG = "OTHERWISE"; + parameter IDLE_INFER_LPBK_SLAVE = "OTHERWISE"; + parameter IDLE_INFER_REC_SPEED2_SUCCESS = "OTHERWISE"; + parameter IDLE_INFER_REC_SPEED2_UNSUCCESS = "OTHERWISE"; + parameter IDLE_INFER_L0_TO_REC_RCVR_LOCK = "OTHERWISE"; + parameter SPEED_CHANGE_FAIL = "OTHERWISE"; + parameter DIRECT_TO_DETECT_FAST = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_CH_BOND = "OTHERWISE"; + parameter DIRECT_TO_LPBK_ENTRY = "OTHERWISE"; + parameter DIRECT_SPEED_CHANGE = "OTHERWISE"; + parameter L0_TO_REC_RCVR_LOCK_RX_TS12 = "OTHERWISE"; + parameter L0_TO_REC_RCVR_LOCK_RX_8G_EIE = "OTHERWISE"; + parameter L0_TO_REC_RCVR_LOCK_RX_INFER = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_PHY = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_FRAME = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_REPLAY = "OTHERWISE"; + parameter DIRECT_TO_HOT_RESET = "OTHERWISE"; + parameter DIRECT_TO_DISABLE = "OTHERWISE"; + parameter RX_L0S_DIRECT_TO_RCVRY = "OTHERWISE"; + parameter AUTONOMOUS_WIDTH_CHANGE = "OTHERWISE"; + parameter DIRECTED_RETRAIN_LINK = "OTHERWISE"; + parameter ERR_TX_PIPE_UNDERFLOW = "OTHERWISE"; + parameter TS2_DETECT3 = "OTHERWISE"; + parameter TS2_DETECT2 = "OTHERWISE"; + parameter TS2_DETECT1 = "OTHERWISE"; + parameter TS2_DETECT0 = "OTHERWISE"; + parameter TS1_DETECT3 = "OTHERWISE"; + parameter TS1_DETECT2 = "OTHERWISE"; + parameter TS1_DETECT1 = "OTHERWISE"; + parameter TS1_DETECT0 = "OTHERWISE"; + parameter TS2I_DETECT3 = "OTHERWISE"; + parameter TS2I_DETECT2 = "OTHERWISE"; + parameter TS2I_DETECT1 = "OTHERWISE"; + parameter TS2I_DETECT0 = "OTHERWISE"; + parameter TS1I_DETECT3 = "OTHERWISE"; + parameter TS1I_DETECT2 = "OTHERWISE"; + parameter TS1I_DETECT1 = "OTHERWISE"; + parameter TS1I_DETECT0 = "OTHERWISE"; + parameter FTS_DETECT3 = "OTHERWISE"; + parameter FTS_DETECT2 = "OTHERWISE"; + parameter FTS_DETECT1 = "OTHERWISE"; + parameter FTS_DETECT0 = "OTHERWISE"; + parameter SKP_DETECT3 = "OTHERWISE"; + parameter SKP_DETECT2 = "OTHERWISE"; + parameter SKP_DETECT1 = "OTHERWISE"; + parameter SKP_DETECT0 = "OTHERWISE"; + parameter EIE_DETECT3 = "OTHERWISE"; + parameter EIE_DETECT2 = "OTHERWISE"; + parameter EIE_DETECT1 = "OTHERWISE"; + parameter EIE_DETECT0 = "OTHERWISE"; + parameter EIOS_DETECT3 = "OTHERWISE"; + parameter EIOS_DETECT2 = "OTHERWISE"; + parameter EIOS_DETECT1 = "OTHERWISE"; + parameter EIOS_DETECT0 = "OTHERWISE"; + parameter DATA_DETECT3 = "OTHERWISE"; + parameter DATA_DETECT2 = "OTHERWISE"; + parameter DATA_DETECT1 = "OTHERWISE"; + parameter DATA_DETECT0 = "OTHERWISE"; + parameter SDS_DETECT3 = "OTHERWISE"; + parameter SDS_DETECT2 = "OTHERWISE"; + parameter SDS_DETECT1 = "OTHERWISE"; + parameter SDS_DETECT0 = "OTHERWISE"; + parameter INFO_BAD_TLP_NULL_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_PHY_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_MALF_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_ECRC_ERR = "OTHERWISE"; + parameter INFO_SCHEDULE_DUPL_ACK = "OTHERWISE"; + parameter INFO_BAD_TLP_SEQ_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_CRC_ERR = "OTHERWISE"; + parameter INFO_NAK_RECEIVED = "OTHERWISE"; + parameter INFO_DESKEW_OVERFLOW_ERROR = "OTHERWISE"; + parameter INFO_TX_DATA_UNDERFLOW = "OTHERWISE"; + parameter INFO_REPLAY_STARTED = "OTHERWISE"; + parameter ERR_AER_TX_PAR2 = "OTHERWISE"; + parameter ERR_AER_TX_REPLAY_ECC2 = "OTHERWISE"; + parameter ERR_AER_TX_REPLAY_ECC1 = "OTHERWISE"; + parameter ERR_AER_SURPRISE_DOWN = "OTHERWISE"; + parameter ERR_AER_DL_PROTOCOL_ERROR = "OTHERWISE"; + parameter ERR_AER_REPLAY_TIMER_TIMEOUT = "OTHERWISE"; + parameter ERR_AER_REPLAY_NUM_ROLLOVER = "OTHERWISE"; + parameter ERR_AER_BAD_DLLP = "OTHERWISE"; + parameter ERR_AER_BAD_TLP = "OTHERWISE"; + parameter ERR_AER_RECEIVER_ERROR = "OTHERWISE"; + parameter P_RX_LIM_H = "DISABLED"; + parameter P_RX_LIM_D = "DISABLED"; + parameter N_RX_LIM_H = "DISABLED"; + parameter N_RX_LIM_D = "DISABLED"; + parameter C_RX_LIM_H = "DISABLED"; + parameter C_RX_LIM_D = "DISABLED"; + parameter P_TX_LIM_H = "DISABLED"; + parameter P_TX_LIM_D = "DISABLED"; + parameter N_TX_LIM_H = "DISABLED"; + parameter N_TX_LIM_D = "DISABLED"; + parameter C_TX_LIM_H = "DISABLED"; + parameter C_TX_LIM_D = "DISABLED"; + parameter MAX_RSA_WAIT = "0b00101000"; + parameter F_ARXDPNULL = "0b00000"; + input LMMICLK; + input LMMIRESET_N; + input LMMIREQUEST; + input LMMIWRRD_N; + input [14:0] LMMIOFFSET; + input [31:0] LMMIWDATA; + output [31:0] LMMIRDATA; + output LMMIRDATAVALID; + output LMMIREADY; + output ACJNOUT; + output ACJPOUT; + input AUXCK; + input CKUSRI; + output CKUSRO; + input ECKIN; + input ECKIND2; + output ECKINDO; + input ERSTN; + input ERSTND2; + input ERXCKD2; + output ERXCKDO; + input ERXRSND2; + input ETXCKD2; + output ETXCKDO; + input ETXRSND2; + output [3:0] FLR; + input [3:0] FLRACK; + input [3:0] MINTLEG; + output MINTO; + input PERSTN; + output [4:0] PMCTRL; + output PMCTRLEN; + input [4:0] PMDPAST; + input PRMSGSD; + input [12:0] PRNOSNP; + input PRNSNPRE; + input [12:0] PRSNOOP; + input PRSNPRE; + input [31:0] PPBDREG; + output [7:0] PPBDSEL; + input REXTCK; + input REXTRST; + input RSTUSRN; + output UDLLKUP; + input ULTSDIS; + output UPLLKUP; + output UTLLKUP; + input [9:0] UCFGADDR; + input [2:0] UCFGF; + output [31:0] UCFGRDD; + output UCFGRDE; + output UCFGRDY; + input UCFGSERD; + input UCFGVD; + input [3:0] UCFGWRBE; + input [31:0] UCFGWRD; + input UCFGWRDN; + input USERAUPD; + input [3:0] USERTRS; + output [12:0] VRXCMDD; + input VRXCINIT; + input [11:0] VRXCNH; + input VRXCNINF; + input VRXCRRE; + output [31:0] VRXD; + output [3:0] VRXDP; + output VRXEOP; + output VRXERR; + output [1:0] VRXF; + input VRXRDY; + output [1:0] VRXSEL; + output VRXSOP; + output VRXVD; + output VXCDINIT; + output [11:0] VXCDNH; + output VTXCRRE; + input [31:0] VXD; + input [3:0] VXDP; + input VXEOP; + input VXEOPN; + output VXRDY; + input VXSOP; + input VXVD; + output [7:0] TESTOUT; + (* iopad_external_pin *) + input S0REFCKN; + (* iopad_external_pin *) + input S0REFCKP; + (* iopad_external_pin *) + input S0REFRET; + (* iopad_external_pin *) + input S0REXT; + (* iopad_external_pin *) + input S0RXN; + (* iopad_external_pin *) + input S0RXP; + (* iopad_external_pin *) + output S0TXN; + (* iopad_external_pin *) + output S0TXP; + input CLKREQI; + output CLKREQO; + output CLKREQOE; +endmodule + +module PDP16K_MODE (...); + parameter DATA_WIDTH_W = "X36"; + parameter DATA_WIDTH_R = "X36"; + parameter OUTREG = "BYPASSED"; + parameter RESETMODE = "SYNC"; + parameter GSR = "ENABLED"; + parameter ECC = "DISABLED"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE_W = "000"; + parameter CSDECODE_R = "000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter INIT_DATA = "STATIC"; + input DI0; + input DI1; + input DI2; + input DI3; + input DI4; + input DI5; + input DI6; + input DI7; + input DI8; + input DI9; + input DI10; + input DI11; + input DI12; + input DI13; + input DI14; + input DI15; + input DI16; + input DI17; + input DI18; + input DI19; + input DI20; + input DI21; + input DI22; + input DI23; + input DI24; + input DI25; + input DI26; + input DI27; + input DI28; + input DI29; + input DI30; + input DI31; + input DI32; + input DI33; + input DI34; + input DI35; + input ADW0; + input ADW1; + input ADW2; + input ADW3; + input ADW4; + input ADW5; + input ADW6; + input ADW7; + input ADW8; + input ADW9; + input ADW10; + input ADW11; + input ADW12; + input ADW13; + input ADR0; + input ADR1; + input ADR2; + input ADR3; + input ADR4; + input ADR5; + input ADR6; + input ADR7; + input ADR8; + input ADR9; + input ADR10; + input ADR11; + input ADR12; + input ADR13; + input CLKW; + input CLKR; + input CEW; + input CER; + input CSW0; + input CSW1; + input CSW2; + input CSR0; + input CSR1; + input CSR2; + input RST; + output DO0; + output DO1; + output DO2; + output DO3; + output DO4; + output DO5; + output DO6; + output DO7; + output DO8; + output DO9; + output DO10; + output DO11; + output DO12; + output DO13; + output DO14; + output DO15; + output DO16; + output DO17; + output DO18; + output DO19; + output DO20; + output DO21; + output DO22; + output DO23; + output DO24; + output DO25; + output DO26; + output DO27; + output DO28; + output DO29; + output DO30; + output DO31; + output DO32; + output DO33; + output DO34; + output DO35; + output ONEBITERR; + output TWOBITERR; +endmodule + +module PDP16K (...); + parameter DATA_WIDTH_W = "X36"; + parameter DATA_WIDTH_R = "X36"; + parameter OUTREG = "BYPASSED"; + parameter RESETMODE = "SYNC"; + parameter GSR = "ENABLED"; + parameter ECC = "DISABLED"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE_W = "000"; + parameter CSDECODE_R = "000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter INIT_DATA = "STATIC"; + input [35:0] DI; + input [13:0] ADW; + input [13:0] ADR; + input CLKW; + input CLKR; + input CEW; + input CER; + input [2:0] CSW; + input [2:0] CSR; + input RST; + output [35:0] DO; + output ONEBITERR; + output TWOBITERR; +endmodule + +module PDPSC16K_MODE (...); + parameter DATA_WIDTH_W = "X36"; + parameter DATA_WIDTH_R = "X36"; + parameter OUTREG = "BYPASSED"; + parameter RESETMODE = "SYNC"; + parameter GSR = "ENABLED"; + parameter ECC = "DISABLED"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE_W = "000"; + parameter CSDECODE_R = "000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter INIT_DATA = "STATIC"; + input DI0; + input DI1; + input DI2; + input DI3; + input DI4; + input DI5; + input DI6; + input DI7; + input DI8; + input DI9; + input DI10; + input DI11; + input DI12; + input DI13; + input DI14; + input DI15; + input DI16; + input DI17; + input DI18; + input DI19; + input DI20; + input DI21; + input DI22; + input DI23; + input DI24; + input DI25; + input DI26; + input DI27; + input DI28; + input DI29; + input DI30; + input DI31; + input DI32; + input DI33; + input DI34; + input DI35; + input ADW0; + input ADW1; + input ADW2; + input ADW3; + input ADW4; + input ADW5; + input ADW6; + input ADW7; + input ADW8; + input ADW9; + input ADW10; + input ADW11; + input ADW12; + input ADW13; + input ADR0; + input ADR1; + input ADR2; + input ADR3; + input ADR4; + input ADR5; + input ADR6; + input ADR7; + input ADR8; + input ADR9; + input ADR10; + input ADR11; + input ADR12; + input ADR13; + input CLK; + input CER; + input CEW; + input CSW0; + input CSW1; + input CSW2; + input CSR0; + input CSR1; + input CSR2; + input RST; + output DO0; + output DO1; + output DO2; + output DO3; + output DO4; + output DO5; + output DO6; + output DO7; + output DO8; + output DO9; + output DO10; + output DO11; + output DO12; + output DO13; + output DO14; + output DO15; + output DO16; + output DO17; + output DO18; + output DO19; + output DO20; + output DO21; + output DO22; + output DO23; + output DO24; + output DO25; + output DO26; + output DO27; + output DO28; + output DO29; + output DO30; + output DO31; + output DO32; + output DO33; + output DO34; + output DO35; + output ONEBITERR; + output TWOBITERR; +endmodule + +module PDPSC16K (...); + parameter DATA_WIDTH_W = "X36"; + parameter DATA_WIDTH_R = "X36"; + parameter OUTREG = "BYPASSED"; + parameter RESETMODE = "SYNC"; + parameter GSR = "ENABLED"; + parameter ECC = "DISABLED"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE_W = "000"; + parameter CSDECODE_R = "000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter INIT_DATA = "STATIC"; + input [35:0] DI; + input [13:0] ADW; + input [13:0] ADR; + input CLK; + input CER; + input CEW; + input [2:0] CSW; + input [2:0] CSR; + input RST; + output [35:0] DO; + output ONEBITERR; + output TWOBITERR; +endmodule + +module PDPSC512K (...); + parameter OUTREG = "NO_REG"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_40 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_41 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_42 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_43 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_44 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_45 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_46 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_47 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_48 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_49 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_50 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_51 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_52 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_53 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_54 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_55 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_56 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_57 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_58 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_59 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_60 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_61 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_62 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_63 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_64 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_65 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_66 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_67 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_68 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_69 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_70 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_71 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_72 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_73 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_74 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_75 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_76 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_77 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_78 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_79 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ASYNC_RESET_RELEASE = "SYNC"; + parameter ECC_BYTE_SEL = "ECC_EN"; + input [31:0] DI; + input [13:0] ADW; + input [13:0] ADR; + input CLK; + input CEW; + input CER; + input WE; + input CSW; + input CSR; + input RSTR; + input [3:0] BYTEEN_N; + output [31:0] DO; + output [1:0] ERRDECA; + output [1:0] ERRDECB; +endmodule + +module PLL (...); + parameter BW_CTL_BIAS = "0b0101"; + parameter CLKOP_TRIM = "0b0000"; + parameter CLKOS_TRIM = "0b0000"; + parameter CLKOS2_TRIM = "0b0000"; + parameter CLKOS3_TRIM = "0b0000"; + parameter CLKOS4_TRIM = "0b0000"; + parameter CLKOS5_TRIM = "0b0000"; + parameter CRIPPLE = "5P"; + parameter CSET = "40P"; + parameter DELAY_CTRL = "200PS"; + parameter DELA = "0"; + parameter DELB = "0"; + parameter DELC = "0"; + parameter DELD = "0"; + parameter DELE = "0"; + parameter DELF = "0"; + parameter DIRECTION = "DISABLED"; + parameter DIVA = "0"; + parameter DIVB = "0"; + parameter DIVC = "0"; + parameter DIVD = "0"; + parameter DIVE = "0"; + parameter DIVF = "0"; + parameter DYN_SEL = "0b000"; + parameter DYN_SOURCE = "STATIC"; + parameter ENCLK_CLKOP = "DISABLED"; + parameter ENCLK_CLKOS = "DISABLED"; + parameter ENCLK_CLKOS2 = "DISABLED"; + parameter ENCLK_CLKOS3 = "DISABLED"; + parameter ENCLK_CLKOS4 = "DISABLED"; + parameter ENCLK_CLKOS5 = "DISABLED"; + parameter ENABLE_SYNC = "DISABLED"; + parameter FAST_LOCK_EN = "ENABLED"; + parameter V2I_1V_EN = "DISABLED"; + parameter FBK_CUR_BLE = "0b00000000"; + parameter FBK_EDGE_SEL = "POSITIVE"; + parameter FBK_IF_TIMING_CTL = "0b00"; + parameter FBK_INTEGER_MODE = "DISABLED"; + parameter FBK_MASK = "0b00001000"; + parameter FBK_MMD_DIG = "8"; + parameter FBK_MMD_PULS_CTL = "0b0000"; + parameter FBK_MODE = "0b00"; + parameter FBK_PI_BYPASS = "NOT_BYPASSED"; + parameter FBK_PI_RC = "0b1100"; + parameter FBK_PR_CC = "0b0000"; + parameter FBK_PR_IC = "0b1000"; + parameter FLOAT_CP = "DISABLED"; + parameter FLOCK_CTRL = "2X"; + parameter FLOCK_EN = "ENABLED"; + parameter FLOCK_SRC_SEL = "REFCLK"; + parameter FORCE_FILTER = "DISABLED"; + parameter I_CTRL = "10UA"; + parameter IPI_CMP = "0b1000"; + parameter IPI_CMPN = "0b0011"; + parameter IPI_COMP_EN = "DISABLED"; + parameter IPP_CTRL = "0b1000"; + parameter IPP_SEL = "0b1111"; + parameter KP_VCO = "0b11001"; + parameter LDT_INT_LOCK_STICKY = "DISABLED"; + parameter LDT_LOCK = "1536CYC"; + parameter LDT_LOCK_SEL = "U_FREQ"; + parameter LEGACY_ATT = "DISABLED"; + parameter LOAD_REG = "DISABLED"; + parameter OPENLOOP_EN = "DISABLED"; + parameter PHIA = "0"; + parameter PHIB = "0"; + parameter PHIC = "0"; + parameter PHID = "0"; + parameter PHIE = "0"; + parameter PHIF = "0"; + parameter PLLPDN_EN = "DISABLED"; + parameter PLLPD_N = "UNUSED"; + parameter PLLRESET_ENA = "DISABLED"; + parameter REF_INTEGER_MODE = "DISABLED"; + parameter REF_MASK = "0b00000000"; + parameter REF_MMD_DIG = "8"; + parameter REF_MMD_IN = "0b00001000"; + parameter REF_MMD_PULS_CTL = "0b0000"; + parameter REF_TIMING_CTL = "0b00"; + parameter REFIN_RESET = "SET"; + parameter RESET_LF = "DISABLED"; + parameter ROTATE = "DISABLED"; + parameter SEL_OUTA = "DISABLED"; + parameter SEL_OUTB = "DISABLED"; + parameter SEL_OUTC = "DISABLED"; + parameter SEL_OUTD = "DISABLED"; + parameter SEL_OUTE = "DISABLED"; + parameter SEL_OUTF = "DISABLED"; + parameter SLEEP = "DISABLED"; + parameter SSC_DITHER = "DISABLED"; + parameter SSC_EN_CENTER_IN = "DOWN_TRIANGLE"; + parameter SSC_EN_SDM = "DISABLED"; + parameter SSC_EN_SSC = "DISABLED"; + parameter SSC_F_CODE = "0b000000000000000"; + parameter SSC_N_CODE = "0b000010100"; + parameter SSC_ORDER = "SDM_ORDER2"; + parameter SSC_PI_BYPASS = "NOT_BYPASSED"; + parameter SSC_REG_WEIGHTING_SEL = "0b000"; + parameter SSC_SQUARE_MODE = "DISABLED"; + parameter SSC_STEP_IN = "0b0000000"; + parameter SSC_TBASE = "0b000000000000"; + parameter STDBY_ATT = "DISABLED"; + parameter TRIMOP_BYPASS_N = "BYPASSED"; + parameter TRIMOS_BYPASS_N = "BYPASSED"; + parameter TRIMOS2_BYPASS_N = "BYPASSED"; + parameter TRIMOS3_BYPASS_N = "BYPASSED"; + parameter TRIMOS4_BYPASS_N = "BYPASSED"; + parameter TRIMOS5_BYPASS_N = "BYPASSED"; + parameter V2I_KVCO_SEL = "85"; + parameter V2I_PP_ICTRL = "0b00110"; + parameter V2I_PP_RES = "10K"; + parameter CLKMUX_FB = "CMUX_CLKOP"; + parameter SEL_FBK = "DIVA"; + parameter DIV_DEL = "0b0000001"; + parameter PHASE_SEL_DEL = "0b000"; + parameter PHASE_SEL_DEL_P1 = "0b000"; + parameter EXTERNAL_DIVIDE_FACTOR = "0"; + output INTFBKOP; + output INTFBKOS; + output INTFBKOS2; + output INTFBKOS3; + output INTFBKOS4; + output INTFBKOS5; + input DIR; + input [2:0] DIRSEL; + input LOADREG; + input DYNROTATE; + input LMMICLK; + input LMMIRESET_N; + input LMMIREQUEST; + input LMMIWRRD_N; + input [6:0] LMMIOFFSET; + input [7:0] LMMIWDATA; + output [7:0] LMMIRDATA; + output LMMIRDATAVALID; + output LMMIREADY; + input PLLPOWERDOWN_N; + input REFCK; + output CLKOP; + output CLKOS; + output CLKOS2; + output CLKOS3; + output CLKOS4; + output CLKOS5; + input ENCLKOP; + input ENCLKOS; + input ENCLKOS2; + input ENCLKOS3; + input ENCLKOS4; + input ENCLKOS5; + input FBKCK; + output INTLOCK; + input LEGACY; + output LEGRDYN; + output LOCK; + output PFDDN; + output PFDUP; + input PLLRESET; + input STDBY; + output REFMUXCK; + output REGQA; + output REGQB; + output REGQB1; + output CLKOUTDL; + input ROTDEL; + input DIRDEL; + input ROTDELP1; + input [4:0] GRAYTEST; + input [1:0] BINTEST; + input DIRDELP1; + input [4:0] GRAYACT; + input [1:0] BINACT; +endmodule + +module PREADD9 (...); + parameter SIGNEDSTATIC_EN = "DISABLED"; + parameter SUBSTRACT_EN = "SUBTRACTION"; + parameter CSIGNED = "DISABLED"; + parameter BSIGNED_OPERAND_EN = "DISABLED"; + parameter BYPASS_PREADD9 = "USED"; + parameter REGBYPSBR0 = "REGISTER"; + parameter REGBYPSBR1 = "BYPASS"; + parameter REGBYPSBL = "REGISTER"; + parameter SHIFTBR = "REGISTER"; + parameter SHIFTBL = "REGISTER"; + parameter GSR = "ENABLED"; + parameter PREADDCAS_EN = "DISABLED"; + parameter SR_18BITSHIFT_EN = "DISABLED"; + parameter OPC = "INPUT_B_AS_PREADDER_OPERAND"; + parameter RESET = "SYNC"; + input [8:0] B; + input BSIGNED; + input [9:0] C; + input [8:0] BRS1; + input [8:0] BRS2; + input [8:0] BLS1; + input [8:0] BLS2; + input BRSS1; + input BRSS2; + input BLSS1; + input BLSS2; + input PRCASIN; + input CLK; + input RSTB; + input CEB; + input RSTCL; + input CECL; + output [8:0] BRSO; + output [8:0] BLSO; + output BRSOSGND; + output BLSOSGND; + output PRCASOUT; + output [8:0] BR; + output BRSIGNED; +endmodule + +module REFMUX (...); + parameter REFSEL_ATT = "MC1"; + parameter SEL1 = "SELECT_REFCLK1"; + parameter SEL_REF2 = "REFCLK2_0"; + parameter SEL_REF1 = "REFCLK1_0"; + output REFCK; + output ZRSEL3; + input REFSEL; + input [7:0] REFCLK1; + input [7:0] REFCLK2; +endmodule + +module REG18 (...); + parameter REGBYPS = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESET = "SYNC"; + input [17:0] PM; + output [17:0] PP; + input CEP; + input RSTP; + input CLK; +endmodule + +(* keep *) +module SEDC (...); + parameter SEDCEN = "DIS"; + input SEDENABLE; + input SEDCCOF; + input SEDCENABLE; + input SEDCMODE; + input SEDCSTART; + output SEDCBUSY; + output SEDCERR; + output SEDCERRC; + output SEDCERRCRC; + output SEDCERRM; + output [15:0] SEDCFRMERRLOC; + input OSCCLKSEDC; + input RSTSEDC; + output [12:0] SEDCDSRERRLOCCIB; +endmodule + +module SEIO18 (...); + parameter PULLMODE = "DOWN"; + parameter MIPI = "DISABLED"; + parameter ENADC_IN = "DISABLED"; + input PADDO; + input DOLP; + (* iopad_external_pin *) + inout IOPAD; + output PADDI; + output INLP; + input PADDT; + output INADC; +endmodule + +module SEIO33 (...); + parameter PULLMODE = "DOWN"; + (* iopad_external_pin *) + inout IOPAD; + output PADDI; + input PADDO; + input PADDT; + input I3CRESEN; + input I3CWKPU; +endmodule + +module SGMIICDR (...); + parameter GSR = "ENABLED"; + parameter DCOITUNE4LSB = "0_PERCENT"; + parameter DCOCTLGI = "0_PERCENT"; + parameter DCOSTEP = "100_PERCENT"; + parameter DCOCALDIV = "100_PERCENT"; + parameter DCOIOSTUNE = "0_PERCENT"; + parameter DCOFLTDAC = "80MHZ"; + parameter DCOSTARTVAL = "NOMINAL"; + parameter DCONUOFLSB = "NEG_60_PERCENT"; + parameter RPWDNB = "POWER_UP"; + parameter CDR_CNT4SEL = "BYPASSED"; + parameter DCOITUNE = "100_PERCENT"; + parameter BAND_THRESHOLD = "0b000000"; + parameter AUTO_FACQ_EN = "ENABLED"; + parameter AUTO_CALIB_EN = "ENABLED"; + parameter CDR_LOL_SET = "1000_PPM"; + parameter FC2DCO_FLOOP = "DISABLED"; + parameter FC2DCO_DLOOP = "DISABLED"; + parameter CALIB_TIME_SEL = "24_CYC"; + parameter CALIB_CK_MODE = "BY_2"; + parameter BAND_CALIB_MODE = "256_FDBK_CLK_CYC"; + parameter REG_BAND_SEL = "0b00000"; + parameter REG_BAND_OFFSET = "0b0000"; + parameter REG_IDAC_SEL = "0b00000000"; + parameter LB_CTL = "DISABLED"; + parameter REG_IDAC_EN = "DISABLED"; + parameter ATDCFG = "0_PS"; + parameter ATDDLY = "0_PS"; + parameter BDAVOID_ENB = "ENABLED"; + parameter BYPASSATD = "NOT_BYPASS"; + parameter DCOIUPDNX2 = "1X"; + parameter IDAC_EN = "DISABLED"; + parameter FB_CLK_DIV = "0b010"; + parameter EN_RECALIB = "ENABLED"; + input LMMICLK; + input LMMIRESET_N; + input LMMIREQUEST; + input LMMIWRRD_N; + input [3:0] LMMIOFFSET; + input [7:0] LMMIWDATA; + output [7:0] LMMIRDATA; + output LMMIRDATAVALID; + output LMMIREADY; + input DCALIRST; + input DFACQRST; + input RRST; + input SPCLK; + output SRCLK; + output [9:0] SRXD; + input RSTBFBW; + input RSTBRXF; + input SGMIIIN; + input SREFCLK; + output CDRLOL; +endmodule + +module SP16K_MODE (...); + parameter DATA_WIDTH = "X18"; + parameter OUTREG = "BYPASSED"; + parameter RESETMODE = "SYNC"; + parameter GSR = "ENABLED"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE = "000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter INIT_DATA = "STATIC"; + input DI0; + input DI1; + input DI2; + input DI3; + input DI4; + input DI5; + input DI6; + input DI7; + input DI8; + input DI9; + input DI10; + input DI11; + input DI12; + input DI13; + input DI14; + input DI15; + input DI16; + input DI17; + input AD0; + input AD1; + input AD2; + input AD3; + input AD4; + input AD5; + input AD6; + input AD7; + input AD8; + input AD9; + input AD10; + input AD11; + input AD12; + input AD13; + input CLK; + input CE; + input WE; + input CS0; + input CS1; + input CS2; + input RST; + output DO0; + output DO1; + output DO2; + output DO3; + output DO4; + output DO5; + output DO6; + output DO7; + output DO8; + output DO9; + output DO10; + output DO11; + output DO12; + output DO13; + output DO14; + output DO15; + output DO16; + output DO17; +endmodule + +module SP16K (...); + parameter DATA_WIDTH = "X18"; + parameter OUTREG = "BYPASSED"; + parameter RESETMODE = "SYNC"; + parameter GSR = "ENABLED"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter CSDECODE = "000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter INIT_DATA = "STATIC"; + input [17:0] DI; + input [13:0] AD; + input CLK; + input CE; + input WE; + input [2:0] CS; + input RST; + output [17:0] DO; +endmodule + +module SP512K (...); + parameter OUTREG = "NO_REG"; + parameter GSR = "ENABLED"; + parameter RESETMODE = "SYNC"; + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_40 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_41 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_42 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_43 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_44 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_45 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_46 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_47 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_48 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_49 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_50 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_51 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_52 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_53 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_54 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_55 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_56 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_57 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_58 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_59 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_60 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_61 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_62 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_63 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_64 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_65 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_66 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_67 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_68 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_69 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_70 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_71 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_72 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_73 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_74 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_75 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_76 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_77 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_78 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_79 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ASYNC_RESET_RELEASE = "SYNC"; + parameter ECC_BYTE_SEL = "ECC_EN"; + input [31:0] DI; + input [13:0] AD; + input CLK; + input CE; + input WE; + input CS; + input RSTOUT; + input CEOUT; + input [3:0] BYTEEN_N; + output [31:0] DO; + output [1:0] ERRDECA; + output [1:0] ERRDECB; +endmodule + +module TSHX2DQS (...); + parameter GSR = "ENABLED"; + input T0; + input T1; + input DQSW; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module TSHX2DQ (...); + parameter GSR = "ENABLED"; + input T0; + input T1; + input DQSW270; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module TSHX4DQS (...); + parameter GSR = "ENABLED"; + input T0; + input T1; + input T2; + input T3; + input DQSW; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +module TSHX4DQ (...); + parameter GSR = "ENABLED"; + input T0; + input T1; + input T2; + input T3; + input DQSW270; + input ECLK; + input SCLK; + input RST; + output Q; +endmodule + +(* keep *) +module WDT (...); + parameter WDTEN = "DIS"; + parameter WDTMODE = "SINGLE"; + parameter WDTVALUE = "0b000000000000000000"; + input WDTRELOAD; + input WDT_CLK; + input WDT_RST; +endmodule + +module MIPI (...); + parameter MIPI_ID = "0"; + (* iopad_external_pin *) + inout BP; + (* iopad_external_pin *) + inout BN; + input AP; + input AN; + input TP; + input TN; + input IHS; + input HSRXEN; + input HSTXEN; + output OHS; + output OLSP; + output OLSN; +endmodule + +(* keep *) +module CONFIG_IP_CORE (...); + parameter DONEPHASE = "DIS"; + parameter DSRFCTRL = "0b00"; + parameter ENTSALL = "DIS"; + parameter MCCFGUSEREN = "DIS"; + parameter MCCIBINT = "DIS"; + parameter MCHSEUSEREN = "DIS"; + parameter MCJTAGDISABLE = "EN"; + parameter MCPERSISTUI2C = "DIS"; + parameter MCSPARE = "0b00000"; + parameter MCUCLKSEL = "DIS"; + parameter MCUI2CAFWKUP = "DIS"; + parameter PERSISTI2C = "DIS"; + parameter PERSISTI3C = "DIS"; + parameter PERSISTMQUAD = "DIS"; + parameter PERSISTMSPI = "DIS"; + parameter PERSISTSHEXA = "DIS"; + parameter PERSISTSOCTA = "DIS"; + parameter PERSISTSQUAD = "DIS"; + parameter PERSISTSSPI = "DIS"; + parameter PERSISTWKUP = "DIS"; + parameter PPTQOUT = "0b0000"; + parameter SCANEN = "DIS"; + parameter SYNCEXTDONE = "DIS"; + parameter TRANECI = "DIS"; + parameter TRANHSE = "DIS"; + parameter TRANSBI = "DIS"; + parameter TSALLINV = "NINV"; + parameter WLSLEW = "DIS"; + output CFGDONECIB; + input CIBTSALL; + output FREEZEIOCIB; + output LASTADDRCIB15; + output LASTADDRCIB14; + output LASTADDRCIB13; + output LASTADDRCIB12; + output LASTADDRCIB11; + output LASTADDRCIB10; + output LASTADDRCIB9; + output LASTADDRCIB8; + output LASTADDRCIB7; + output LASTADDRCIB6; + output LASTADDRCIB5; + output LASTADDRCIB4; + output LASTADDRCIB3; + output LASTADDRCIB2; + output LASTADDRCIB1; + output LASTADDRCIB0; + input MBISTENABLEN; + output MBISTRRMATCH; + input MBISTTRRAEN; +endmodule + +module TSALLA (...); + input TSALL; +endmodule + +module OSCA (...); + parameter HF_CLK_DIV = "1"; + parameter HF_SED_SEC_DIV = "1"; + parameter HF_OSC_EN = "ENABLED"; + parameter LF_OUTPUT_EN = "DISABLED"; + input HFOUTEN; + input HFSDSCEN; + output HFCLKOUT; + output LFCLKOUT; + output HFCLKCFG; + output HFSDCOUT; +endmodule + +module OSC (...); + parameter DTR_EN = "ENABLED"; + parameter HF_CLK_DIV = "1"; + parameter HF_SED_SEC_DIV = "1"; + parameter HF_FABRIC_EN = "DISABLED"; + parameter HF_OSC_EN = "ENABLED"; + parameter HFDIV_FABRIC_EN = "ENABLED"; + parameter LF_FABRIC_EN = "DISABLED"; + parameter LF_OUTPUT_EN = "DISABLED"; + parameter DEBUG_N = "DISABLED"; + parameter MCJTAGGSRNDIS = "EN"; + parameter MCLMMIGSRNDIS = "EN"; + parameter MCSEDCGSRNDIS = "EN"; + parameter MCWDTGSRNDIS = "EN"; + parameter SMCLK_DIV = "3"; + output HFCLKOUT; + input HFSDSCEN; + output LFCLKOUT; + output HFSDCOUT; + output HSE_CLK; + input JTAG_LRST_N; + input LMMI_CLK; + output LMMI_CLK_O; + input LMMI_LRST_N; + output LMMI_RST; + input SEDC_CLK; + input SEDC_LRST_N; + output SEDC_RST; + output CFG_CLK; + output SMCLK_RST; + output WDT_CLK; + input WDT_LRST_N; + output WDT_RST; +endmodule + +module ACC54_CORE (...); + parameter SIGN = "DISABLED"; + parameter M9ADDSUB_CTRL = "ADDITION"; + parameter ADDSUB_CTRL = "ADD_ADD_CTRL_54_BIT_ADDER"; + parameter STATICOPCODE_EN = "DISABLED"; + parameter OUTREGBYPS = "REGISTER"; + parameter GSR = "ENABLED"; + parameter PROGCONST = "0b000000000000000000000000000000000000000000000000000000"; + parameter CONSTSEL = "BYPASS"; + parameter DSPCASCADE = "DISABLED"; + parameter ACC108CASCADE = "BYPASSCASCADE"; + parameter ACCUMODE = "MODE0"; + parameter ACCUBYPS = "USED"; + parameter CREGBYPS1 = "REGISTER"; + parameter CREGBYPS2 = "REGISTER"; + parameter CREGBYPS3 = "REGISTER"; + parameter CINREGBYPS1 = "REGISTER"; + parameter CINREGBYPS2 = "REGISTER"; + parameter CINREGBYPS3 = "REGISTER"; + parameter LOADREGBYPS1 = "REGISTER"; + parameter LOADREGBYPS2 = "REGISTER"; + parameter LOADREGBYPS3 = "REGISTER"; + parameter M9ADDSUBREGBYPS1 = "REGISTER"; + parameter M9ADDSUBREGBYPS2 = "REGISTER"; + parameter M9ADDSUBREGBYPS3 = "REGISTER"; + parameter ADDSUBSIGNREGBYPS1 = "REGISTER"; + parameter ADDSUBSIGNREGBYPS2 = "REGISTER"; + parameter ADDSUBSIGNREGBYPS3 = "REGISTER"; + parameter ROUNDHALFUP = "DISABLED"; + parameter ROUNDRTZI = "ROUND_TO_ZERO"; + parameter ROUNDBIT = "ROUND_TO_BIT0"; + parameter CASCOUTREGBYPS = "REGISTER"; + parameter SFTEN = "DISABLED"; + parameter RESET = "SYNC"; + input SFTCTRL3; + input SFTCTRL2; + input SFTCTRL1; + input SFTCTRL0; + input DSPIN53; + input DSPIN52; + input DSPIN51; + input DSPIN50; + input DSPIN49; + input DSPIN48; + input DSPIN47; + input DSPIN46; + input DSPIN45; + input DSPIN44; + input DSPIN43; + input DSPIN42; + input DSPIN41; + input DSPIN40; + input DSPIN39; + input DSPIN38; + input DSPIN37; + input DSPIN36; + input DSPIN35; + input DSPIN34; + input DSPIN33; + input DSPIN32; + input DSPIN31; + input DSPIN30; + input DSPIN29; + input DSPIN28; + input DSPIN27; + input DSPIN26; + input DSPIN25; + input DSPIN24; + input DSPIN23; + input DSPIN22; + input DSPIN21; + input DSPIN20; + input DSPIN19; + input DSPIN18; + input DSPIN17; + input DSPIN16; + input DSPIN15; + input DSPIN14; + input DSPIN13; + input DSPIN12; + input DSPIN11; + input DSPIN10; + input DSPIN9; + input DSPIN8; + input DSPIN7; + input DSPIN6; + input DSPIN5; + input DSPIN4; + input DSPIN3; + input DSPIN2; + input DSPIN1; + input DSPIN0; + input PP71; + input PP70; + input PP69; + input PP68; + input PP67; + input PP66; + input PP65; + input PP64; + input PP63; + input PP62; + input PP61; + input PP60; + input PP59; + input PP58; + input PP57; + input PP56; + input PP55; + input PP54; + input PP53; + input PP52; + input PP51; + input PP50; + input PP49; + input PP48; + input PP47; + input PP46; + input PP45; + input PP44; + input PP43; + input PP42; + input PP41; + input PP40; + input PP39; + input PP38; + input PP37; + input PP36; + input PP35; + input PP34; + input PP33; + input PP32; + input PP31; + input PP30; + input PP29; + input PP28; + input PP27; + input PP26; + input PP25; + input PP24; + input PP23; + input PP22; + input PP21; + input PP20; + input PP19; + input PP18; + input PP17; + input PP16; + input PP15; + input PP14; + input PP13; + input PP12; + input PP11; + input PP10; + input PP9; + input PP8; + input PP7; + input PP6; + input PP5; + input PP4; + input PP3; + input PP2; + input PP1; + input PP0; + input CINPUT53; + input CINPUT52; + input CINPUT51; + input CINPUT50; + input CINPUT49; + input CINPUT48; + input CINPUT47; + input CINPUT46; + input CINPUT45; + input CINPUT44; + input CINPUT43; + input CINPUT42; + input CINPUT41; + input CINPUT40; + input CINPUT39; + input CINPUT38; + input CINPUT37; + input CINPUT36; + input CINPUT35; + input CINPUT34; + input CINPUT33; + input CINPUT32; + input CINPUT31; + input CINPUT30; + input CINPUT29; + input CINPUT28; + input CINPUT27; + input CINPUT26; + input CINPUT25; + input CINPUT24; + input CINPUT23; + input CINPUT22; + input CINPUT21; + input CINPUT20; + input CINPUT19; + input CINPUT18; + input CINPUT17; + input CINPUT16; + input CINPUT15; + input CINPUT14; + input CINPUT13; + input CINPUT12; + input CINPUT11; + input CINPUT10; + input CINPUT9; + input CINPUT8; + input CINPUT7; + input CINPUT6; + input CINPUT5; + input CINPUT4; + input CINPUT3; + input CINPUT2; + input CINPUT1; + input CINPUT0; + input LOAD; + input M9ADDSUB1; + input M9ADDSUB0; + input ADDSUB1; + input ADDSUB0; + input CIN; + input CASIN1; + input CASIN0; + input CEO; + input RSTO; + input CEC; + input RSTC; + input CLK; + input SIGNEDI; + output SUM135; + output SUM134; + output SUM133; + output SUM132; + output SUM131; + output SUM130; + output SUM129; + output SUM128; + output SUM127; + output SUM126; + output SUM125; + output SUM124; + output SUM123; + output SUM122; + output SUM121; + output SUM120; + output SUM119; + output SUM118; + output SUM117; + output SUM116; + output SUM115; + output SUM114; + output SUM113; + output SUM112; + output SUM111; + output SUM110; + output SUM19; + output SUM18; + output SUM17; + output SUM16; + output SUM15; + output SUM14; + output SUM13; + output SUM12; + output SUM11; + output SUM10; + output SUM035; + output SUM034; + output SUM033; + output SUM032; + output SUM031; + output SUM030; + output SUM029; + output SUM028; + output SUM027; + output SUM026; + output SUM025; + output SUM024; + output SUM023; + output SUM022; + output SUM021; + output SUM020; + output SUM019; + output SUM018; + output SUM017; + output SUM016; + output SUM015; + output SUM014; + output SUM013; + output SUM012; + output SUM011; + output SUM010; + output SUM09; + output SUM08; + output SUM07; + output SUM06; + output SUM05; + output SUM04; + output SUM03; + output SUM02; + output SUM01; + output SUM00; + output DSPOUT53; + output DSPOUT52; + output DSPOUT51; + output DSPOUT50; + output DSPOUT49; + output DSPOUT48; + output DSPOUT47; + output DSPOUT46; + output DSPOUT45; + output DSPOUT44; + output DSPOUT43; + output DSPOUT42; + output DSPOUT41; + output DSPOUT40; + output DSPOUT39; + output DSPOUT38; + output DSPOUT37; + output DSPOUT36; + output DSPOUT35; + output DSPOUT34; + output DSPOUT33; + output DSPOUT32; + output DSPOUT31; + output DSPOUT30; + output DSPOUT29; + output DSPOUT28; + output DSPOUT27; + output DSPOUT26; + output DSPOUT25; + output DSPOUT24; + output DSPOUT23; + output DSPOUT22; + output DSPOUT21; + output DSPOUT20; + output DSPOUT19; + output DSPOUT18; + output DSPOUT17; + output DSPOUT16; + output DSPOUT15; + output DSPOUT14; + output DSPOUT13; + output DSPOUT12; + output DSPOUT11; + output DSPOUT10; + output DSPOUT9; + output DSPOUT8; + output DSPOUT7; + output DSPOUT6; + output DSPOUT5; + output DSPOUT4; + output DSPOUT3; + output DSPOUT2; + output DSPOUT1; + output DSPOUT0; + output CASCOUT1; + output CASCOUT0; + input ROUNDEN; + input CECIN; + input CECTRL; + input RSTCIN; + input RSTCTRL; +endmodule + +module ADC_CORE (...); + parameter ADC_ENP = "ENABLED"; + parameter CLK_DIV = "2"; + parameter CTLCOMPSW1 = "DISABLED"; + parameter CTLCOMPSW2 = "DISABLED"; + parameter CTLCOMPSW3 = "DISABLED"; + parameter DF = "STRAIGHT_BINARY"; + parameter EN_COMP1 = "ENABLED"; + parameter EN_COMP2 = "ENABLED"; + parameter EN_COMP3 = "ENABLED"; + parameter OMA = "BIPOLAR"; + parameter OMB = "BIPOLAR"; + parameter REFBUFAEN = "ENABLED"; + parameter REFBUFBEN = "ENABLED"; + parameter SLEEP = "DISABLED"; + parameter VREFACFG = "1P0_TO_1P2"; + parameter VREFASEL = "INTERNAL"; + parameter VREFBCFG = "1P0_TO_1P2"; + parameter VREFBSEL = "INTERNAL"; + input ADCEN; + input CAL; + output CALRDY; + input CHAEN; + input CHASEL3; + input CHASEL2; + input CHASEL1; + input CHASEL0; + input CHBEN; + input CHBSEL3; + input CHBSEL2; + input CHBSEL1; + input CHBSEL0; + input CLKDCLK; + input CLKFAB; + output COG; + input COMP1IN; + input COMP1IP; + output COMP1OL; + input COMP2IN; + input COMP2IP; + output COMP2OL; + input COMP3IN; + input COMP3IP; + output COMP3OL; + input CONVSTOP; + output DA11; + output DA10; + output DA9; + output DA8; + output DA7; + output DA6; + output DA5; + output DA4; + output DA3; + output DA2; + output DA1; + output DA0; + output DB11; + output DB10; + output DB9; + output DB8; + output DB7; + output DB6; + output DB5; + output DB4; + output DB3; + output DB2; + output DB1; + output DB0; + (* iopad_external_pin *) + input DN1; + (* iopad_external_pin *) + input DN0; + (* iopad_external_pin *) + input DP1; + (* iopad_external_pin *) + input DP0; + output EOC; + input GPION15; + input GPION14; + input GPION13; + input GPION12; + input GPION11; + input GPION10; + input GPION9; + input GPION8; + input GPION7; + input GPION6; + input GPION5; + input GPION4; + input GPION3; + input GPION2; + input GPION1; + input GPION0; + input GPIOP15; + input GPIOP14; + input GPIOP13; + input GPIOP12; + input GPIOP11; + input GPIOP10; + input GPIOP9; + input GPIOP8; + input GPIOP7; + input GPIOP6; + input GPIOP5; + input GPIOP4; + input GPIOP3; + input GPIOP2; + input GPIOP1; + input GPIOP0; + input RESETN; + input RSTN; + input RSVDH; + input RSVDL; + input SOC; + output COMP1O; + output COMP2O; + output COMP3O; +endmodule + +module ALUREG_CORE (...); + parameter ALURST_ACTIVELOW = "DISABLE"; + parameter GSR = "ENABLED"; + parameter INREG = "DISABLE"; + parameter MULFXP_ROUND = "ENABLE"; + parameter OUTREG = "DISABLE"; + parameter REGRST_ACTIVELOW = "DISABLE"; + parameter RETAIN = "ENABLE"; + parameter RFASYNC_RD = "SYNC_RD"; + parameter RFR0_RO = "R0READONLY"; + parameter RFUNALIA_WR = "DISABLE"; + parameter RFWCLK_INV = "SIG"; + input OPCGLOADCLK; + input ALUCLK; + output ALUFLAGC; + output ALUFLAGV; + output ALUFLAGZ; + input ALUFORWARDA; + input ALUFORWARDB; + input ALUIREGEN; + input ALUOREGEN; + input ALURST; + input DATAA31; + input DATAA30; + input DATAA29; + input DATAA28; + input DATAA27; + input DATAA26; + input DATAA25; + input DATAA24; + input DATAA23; + input DATAA22; + input DATAA21; + input DATAA20; + input DATAA19; + input DATAA18; + input DATAA17; + input DATAA16; + input DATAA15; + input DATAA14; + input DATAA13; + input DATAA12; + input DATAA11; + input DATAA10; + input DATAA9; + input DATAA8; + input DATAA7; + input DATAA6; + input DATAA5; + input DATAA4; + input DATAA3; + input DATAA2; + input DATAA1; + input DATAA0; + input DATAB31; + input DATAB30; + input DATAB29; + input DATAB28; + input DATAB27; + input DATAB26; + input DATAB25; + input DATAB24; + input DATAB23; + input DATAB22; + input DATAB21; + input DATAB20; + input DATAB19; + input DATAB18; + input DATAB17; + input DATAB16; + input DATAB15; + input DATAB14; + input DATAB13; + input DATAB12; + input DATAB11; + input DATAB10; + input DATAB9; + input DATAB8; + input DATAB7; + input DATAB6; + input DATAB5; + input DATAB4; + input DATAB3; + input DATAB2; + input DATAB1; + input DATAB0; + input DATAC4; + input DATAC3; + input DATAC2; + input DATAC1; + input DATAC0; + input OPC6; + input OPC5; + input OPC4; + input OPC3; + input OPC2; + input OPC1; + input OPC0; + input OPCCUSTOM; + input RADDRA4; + input RADDRA3; + input RADDRA2; + input RADDRA1; + input RADDRA0; + input RADDRB4; + input RADDRB3; + input RADDRB2; + input RADDRB1; + input RADDRB0; + output RDATAA31; + output RDATAA30; + output RDATAA29; + output RDATAA28; + output RDATAA27; + output RDATAA26; + output RDATAA25; + output RDATAA24; + output RDATAA23; + output RDATAA22; + output RDATAA21; + output RDATAA20; + output RDATAA19; + output RDATAA18; + output RDATAA17; + output RDATAA16; + output RDATAA15; + output RDATAA14; + output RDATAA13; + output RDATAA12; + output RDATAA11; + output RDATAA10; + output RDATAA9; + output RDATAA8; + output RDATAA7; + output RDATAA6; + output RDATAA5; + output RDATAA4; + output RDATAA3; + output RDATAA2; + output RDATAA1; + output RDATAA0; + output RDATAB31; + output RDATAB30; + output RDATAB29; + output RDATAB28; + output RDATAB27; + output RDATAB26; + output RDATAB25; + output RDATAB24; + output RDATAB23; + output RDATAB22; + output RDATAB21; + output RDATAB20; + output RDATAB19; + output RDATAB18; + output RDATAB17; + output RDATAB16; + output RDATAB15; + output RDATAB14; + output RDATAB13; + output RDATAB12; + output RDATAB11; + output RDATAB10; + output RDATAB9; + output RDATAB8; + output RDATAB7; + output RDATAB6; + output RDATAB5; + output RDATAB4; + output RDATAB3; + output RDATAB2; + output RDATAB1; + output RDATAB0; + input REGCLK; + input REGCLKEN; + input REGRST; + output RESULT31; + output RESULT30; + output RESULT29; + output RESULT28; + output RESULT27; + output RESULT26; + output RESULT25; + output RESULT24; + output RESULT23; + output RESULT22; + output RESULT21; + output RESULT20; + output RESULT19; + output RESULT18; + output RESULT17; + output RESULT16; + output RESULT15; + output RESULT14; + output RESULT13; + output RESULT12; + output RESULT11; + output RESULT10; + output RESULT9; + output RESULT8; + output RESULT7; + output RESULT6; + output RESULT5; + output RESULT4; + output RESULT3; + output RESULT2; + output RESULT1; + output RESULT0; + input SCANCLK; + input SCANRST; + input WADDR4; + input WADDR3; + input WADDR2; + input WADDR1; + input WADDR0; + input WDROTATE1; + input WDROTATE0; + input WDSIGNEXT; + input WDSIZE1; + input WDSIZE0; + input WDATA31; + input WDATA30; + input WDATA29; + input WDATA28; + input WDATA27; + input WDATA26; + input WDATA25; + input WDATA24; + input WDATA23; + input WDATA22; + input WDATA21; + input WDATA20; + input WDATA19; + input WDATA18; + input WDATA17; + input WDATA16; + input WDATA15; + input WDATA14; + input WDATA13; + input WDATA12; + input WDATA11; + input WDATA10; + input WDATA9; + input WDATA8; + input WDATA7; + input WDATA6; + input WDATA5; + input WDATA4; + input WDATA3; + input WDATA2; + input WDATA1; + input WDATA0; + input WREN; +endmodule + +module BNKREF18_CORE (...); + parameter BANK = "0b0000"; + parameter STANDBY_DIFFIO = "DISABLED"; + parameter STANDBY_INR = "DISABLED"; + input STDBYINR; + input STDBYDIF; + input PVTSNKI6; + input PVTSNKI5; + input PVTSNKI4; + input PVTSNKI3; + input PVTSNKI2; + input PVTSNKI1; + input PVTSNKI0; + input PVTSRCI6; + input PVTSRCI5; + input PVTSRCI4; + input PVTSRCI3; + input PVTSRCI2; + input PVTSRCI1; + input PVTSRCI0; + output PVTCODE6; + output PVTCODE5; + output PVTCODE4; + output PVTCODE3; + output PVTCODE2; + output PVTCODE1; + output PVTCODE0; + input PVTSEL; +endmodule + +module BNKREF33_CORE (...); + parameter BANK = "0b0000"; + input PVTSEL; + input PVTSNKI6; + input PVTSNKI5; + input PVTSNKI4; + input PVTSNKI3; + input PVTSNKI2; + input PVTSNKI1; + input PVTSNKI0; + input PVTSRCI6; + input PVTSRCI5; + input PVTSRCI4; + input PVTSRCI3; + input PVTSRCI2; + input PVTSRCI1; + input PVTSRCI0; + output PVTCODE6; + output PVTCODE5; + output PVTCODE4; + output PVTCODE3; + output PVTCODE2; + output PVTCODE1; + output PVTCODE0; +endmodule + +module DIFFIO18_CORE (...); + parameter MIPI_ID = "0"; + parameter PULLMODE = "DOWN"; + parameter ENADC_IN = "DISABLED"; + parameter MIPI = "DISABLED"; + input I; + input DOLP; + (* iopad_external_pin *) + inout B; + output O; + output INLP; + input T; + output INADC; + input HSRXEN; + input HSTXEN; +endmodule + +(* keep *) +module CONFIG_CLKRST_CORE (...); + parameter MCJTAGGSRNDIS = "EN"; + parameter MCLMMIGSRNDIS = "EN"; + parameter MCSEDCGSRNDIS = "EN"; + parameter MCWDTGSRNDIS = "EN"; + parameter SMCLK_DIV = "3"; + output HSE_CLK; + input JTAG_LRST_N; + input LMMI_CLK; + output LMMI_CLK_O; + input LMMI_LRST_N; + output LMMI_RST; + input OSCCLK; + input SEDC_CLK; + input SEDC_LRST_N; + output SEDC_RST; + output CFG_CLK; + output SMCLK_RST; + output WDT_CLK; + input WDT_LRST_N; + output WDT_RST; +endmodule + +(* keep *) +module CONFIG_HSE_CORE (...); + parameter MCGLBGSRNDIS = "EN"; + parameter MCHSEDISABLE = "EN"; + parameter MCHSEOTPEN = "DIS"; + input ASFCLKI; + output ASFEMPTYO; + output ASFFULLO; + input ASFRDI; + input ASFRESETI; + input ASFWRI; + input CFG_CLK; + input HSE_CLK; + input HSELRSTN; + input LMMICLK; + input LMMIOFFSET17; + input LMMIOFFSET16; + input LMMIOFFSET15; + input LMMIOFFSET14; + input LMMIOFFSET13; + input LMMIOFFSET12; + input LMMIOFFSET11; + input LMMIOFFSET10; + input LMMIOFFSET9; + input LMMIOFFSET8; + input LMMIOFFSET7; + input LMMIOFFSET6; + input LMMIOFFSET5; + input LMMIOFFSET4; + input LMMIOFFSET3; + input LMMIOFFSET2; + input LMMIOFFSET1; + input LMMIOFFSET0; + output LMMIRDATA31; + output LMMIRDATA30; + output LMMIRDATA29; + output LMMIRDATA28; + output LMMIRDATA27; + output LMMIRDATA26; + output LMMIRDATA25; + output LMMIRDATA24; + output LMMIRDATA23; + output LMMIRDATA22; + output LMMIRDATA21; + output LMMIRDATA20; + output LMMIRDATA19; + output LMMIRDATA18; + output LMMIRDATA17; + output LMMIRDATA16; + output LMMIRDATA15; + output LMMIRDATA14; + output LMMIRDATA13; + output LMMIRDATA12; + output LMMIRDATA11; + output LMMIRDATA10; + output LMMIRDATA9; + output LMMIRDATA8; + output LMMIRDATA7; + output LMMIRDATA6; + output LMMIRDATA5; + output LMMIRDATA4; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIREQUEST; + input LMMIRESETN; + input LMMIWDATA31; + input LMMIWDATA30; + input LMMIWDATA29; + input LMMIWDATA28; + input LMMIWDATA27; + input LMMIWDATA26; + input LMMIWDATA25; + input LMMIWDATA24; + input LMMIWDATA23; + input LMMIWDATA22; + input LMMIWDATA21; + input LMMIWDATA20; + input LMMIWDATA19; + input LMMIWDATA18; + input LMMIWDATA17; + input LMMIWDATA16; + input LMMIWDATA15; + input LMMIWDATA14; + input LMMIWDATA13; + input LMMIWDATA12; + input LMMIWDATA11; + input LMMIWDATA10; + input LMMIWDATA9; + input LMMIWDATA8; + input LMMIWDATA7; + input LMMIWDATA6; + input LMMIWDATA5; + input LMMIWDATA4; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + input LMMIWRRDN; + input OTM; +endmodule + +(* keep *) +module CONFIG_JTAG_CORE (...); + parameter MCER1EXIST = "NEXIST"; + parameter MCER2EXIST = "NEXIST"; + output JCE1; + output JCE2; + output JRSTN; + output JRTI1; + output JRTI2; + output JSHIFT; + output JTDI; + output JUPDATE; + input JTDO1; + input JTDO2; + input SMCLK; + input TCK; + output JTCK; + input TDI; + output TDO_OEN; + output TDO; + input TMS; +endmodule + +(* keep *) +module CONFIG_LMMI_CORE (...); + parameter LMMI_EN = "DIS"; + input LMMIOFFSET7; + input LMMIOFFSET6; + input LMMIOFFSET5; + input LMMIOFFSET4; + input LMMIOFFSET3; + input LMMIOFFSET2; + input LMMIOFFSET1; + input LMMIOFFSET0; + input LMMICLK; + output LMMIRDATA7; + output LMMIRDATA6; + output LMMIRDATA5; + output LMMIRDATA4; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIRESETN; + input LMMIREQUEST; + input LMMIWDATA7; + input LMMIWDATA6; + input LMMIWDATA5; + input LMMIWDATA4; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + input LMMIWRRDN; + input RSTSMCLK; + input SMCLK; +endmodule + +(* keep *) +module CONFIG_MULTIBOOT_CORE (...); + parameter MSPIADDR = "0b00000000000000000000000000000000"; + parameter SOURCESEL = "DIS"; + input CIBAUTOREBOOT; + input CIBMSPIMADDR31; + input CIBMSPIMADDR30; + input CIBMSPIMADDR29; + input CIBMSPIMADDR28; + input CIBMSPIMADDR27; + input CIBMSPIMADDR26; + input CIBMSPIMADDR25; + input CIBMSPIMADDR24; + input CIBMSPIMADDR23; + input CIBMSPIMADDR22; + input CIBMSPIMADDR21; + input CIBMSPIMADDR20; + input CIBMSPIMADDR19; + input CIBMSPIMADDR18; + input CIBMSPIMADDR17; + input CIBMSPIMADDR16; + input CIBMSPIMADDR15; + input CIBMSPIMADDR14; + input CIBMSPIMADDR13; + input CIBMSPIMADDR12; + input CIBMSPIMADDR11; + input CIBMSPIMADDR10; + input CIBMSPIMADDR9; + input CIBMSPIMADDR8; + input CIBMSPIMADDR7; + input CIBMSPIMADDR6; + input CIBMSPIMADDR5; + input CIBMSPIMADDR4; + input CIBMSPIMADDR3; + input CIBMSPIMADDR2; + input CIBMSPIMADDR1; + input CIBMSPIMADDR0; +endmodule + +(* keep *) +module CONFIG_SEDC_CORE (...); + parameter SEDCEN = "DIS"; + input CIBSED1ENABLE; + input CIBSEDCCOF; + input CIBSEDCENABLE; + input CIBSEDCMODE; + input CIBSEDCSTART; + input OSCCLKSEDC; + input RSTSEDC; + output SEDCBUSYCIB; + output SEDCDSRERRLOCCIB12; + output SEDCDSRERRLOCCIB11; + output SEDCDSRERRLOCCIB10; + output SEDCDSRERRLOCCIB9; + output SEDCDSRERRLOCCIB8; + output SEDCDSRERRLOCCIB7; + output SEDCDSRERRLOCCIB6; + output SEDCDSRERRLOCCIB5; + output SEDCDSRERRLOCCIB4; + output SEDCDSRERRLOCCIB3; + output SEDCDSRERRLOCCIB2; + output SEDCDSRERRLOCCIB1; + output SEDCDSRERRLOCCIB0; + output SEDCERR1CIB; + output SEDCERRCCIB; + output SEDCERRCRCCIB; + output SEDCERRMCIB; + output SEDCFRMERRLOCCIB15; + output SEDCFRMERRLOCCIB14; + output SEDCFRMERRLOCCIB13; + output SEDCFRMERRLOCCIB12; + output SEDCFRMERRLOCCIB11; + output SEDCFRMERRLOCCIB10; + output SEDCFRMERRLOCCIB9; + output SEDCFRMERRLOCCIB8; + output SEDCFRMERRLOCCIB7; + output SEDCFRMERRLOCCIB6; + output SEDCFRMERRLOCCIB5; + output SEDCFRMERRLOCCIB4; + output SEDCFRMERRLOCCIB3; + output SEDCFRMERRLOCCIB2; + output SEDCFRMERRLOCCIB1; + output SEDCFRMERRLOCCIB0; +endmodule + +(* keep *) +module CONFIG_WDT_CORE (...); + parameter WDTEN = "DIS"; + parameter WDTMODE = "SINGLE"; + parameter WDTVALUE = "0b000000000000000000"; + input CIBWDTRELOAD; + input WDT_CLK; + input WDT_RST; +endmodule + +module DDRDLL_CORE (...); + parameter GSR = "ENABLED"; + parameter ENA_ROUNDOFF = "ENABLED"; + parameter FORCE_MAX_DELAY = "CODE_OR_LOCK_FROM_DLL_LOOP"; + output CODE8; + output CODE7; + output CODE6; + output CODE5; + output CODE4; + output CODE3; + output CODE2; + output CODE1; + output CODE0; + input FREEZE; + output LOCK; + input CLKIN; + input RST; + output DCNTL8; + output DCNTL7; + output DCNTL6; + output DCNTL5; + output DCNTL4; + output DCNTL3; + output DCNTL2; + output DCNTL1; + output DCNTL0; + input UDDCNTL_N; +endmodule + +module DLLDEL_CORE (...); + parameter ADJUST = "0"; + parameter DEL_ADJUST = "PLUS"; + parameter ENABLE = "DISABLED"; + input CLKIN; + output CLKOUT; + input CODE8; + input CODE7; + input CODE6; + input CODE5; + input CODE4; + input CODE3; + input CODE2; + input CODE1; + input CODE0; + output COUT; + input DIR; + input LOAD_N; + input MOVE; +endmodule + +module DPHY_CORE (...); + parameter GSR = "ENABLED"; + parameter AUTO_PD_EN = "POWERED_UP"; + parameter CFG_NUM_LANES = "ONE_LANE"; + parameter CM = "0b00000000"; + parameter CN = "0b00000"; + parameter CO = "0b000"; + parameter CONT_CLK_MODE = "DISABLED"; + parameter DESKEW_EN = "DISABLED"; + parameter DSI_CSI = "CSI2_APP"; + parameter EN_CIL = "CIL_ENABLED"; + parameter HSEL = "DISABLED"; + parameter LANE0_SEL = "LANE_0"; + parameter LOCK_BYP = "GATE_TXBYTECLKHS"; + parameter MASTER_SLAVE = "SLAVE"; + parameter PLLCLKBYPASS = "REGISTERED"; + parameter RSEL = "0b00"; + parameter RXCDRP = "0b00"; + parameter RXDATAWIDTHHS = "0b00"; + parameter RXLPRP = "0b000"; + parameter TEST_ENBL = "0b000000"; + parameter TEST_PATTERN = "0b00000000000000000000000000000000"; + parameter TST = "0b1001"; + parameter TXDATAWIDTHHS = "0b00"; + parameter U_PRG_HS_PREPARE = "0b00"; + parameter U_PRG_HS_TRAIL = "0b000000"; + parameter U_PRG_HS_ZERO = "0b000000"; + parameter U_PRG_RXHS_SETTLE = "0b000000"; + parameter UC_PRG_HS_PREPARE = "1P0_TXCLKESC"; + parameter UC_PRG_HS_TRAIL = "0b00000"; + parameter UC_PRG_HS_ZERO = "0b0000000"; + parameter UC_PRG_RXHS_SETTLE = "0b000000"; + input BITCKEXT; + (* iopad_external_pin *) + inout CKN; + (* iopad_external_pin *) + inout CKP; + input CLKREF; + output D0ACTIVE1; + output D0ACTIVE0; + output D0BYTCNT9; + output D0BYTCNT8; + output D0BYTCNT7; + output D0BYTCNT6; + output D0BYTCNT5; + output D0BYTCNT4; + output D0BYTCNT3; + output D0BYTCNT2; + output D0BYTCNT1; + output D0BYTCNT0; + output D0ERRCNT9; + output D0ERRCNT8; + output D0ERRCNT7; + output D0ERRCNT6; + output D0ERRCNT5; + output D0ERRCNT4; + output D0ERRCNT3; + output D0ERRCNT2; + output D0ERRCNT1; + output D0ERRCNT0; + output D0PASS1; + output D0PASS0; + output D0VALID1; + output D0VALID0; + output D1ACTIVE1; + output D1ACTIVE0; + output D1BYTCNT9; + output D1BYTCNT8; + output D1BYTCNT7; + output D1BYTCNT6; + output D1BYTCNT5; + output D1BYTCNT4; + output D1BYTCNT3; + output D1BYTCNT2; + output D1BYTCNT1; + output D1BYTCNT0; + output D1ERRCNT9; + output D1ERRCNT8; + output D1ERRCNT7; + output D1ERRCNT6; + output D1ERRCNT5; + output D1ERRCNT4; + output D1ERRCNT3; + output D1ERRCNT2; + output D1ERRCNT1; + output D1ERRCNT0; + output D1PASS1; + output D1PASS0; + output D1VALID1; + output D1VALID0; + output D2ACTIVE1; + output D2ACTIVE0; + output D2BYTCNT9; + output D2BYTCNT8; + output D2BYTCNT7; + output D2BYTCNT6; + output D2BYTCNT5; + output D2BYTCNT4; + output D2BYTCNT3; + output D2BYTCNT2; + output D2BYTCNT1; + output D2BYTCNT0; + output D2ERRCNT9; + output D2ERRCNT8; + output D2ERRCNT7; + output D2ERRCNT6; + output D2ERRCNT5; + output D2ERRCNT4; + output D2ERRCNT3; + output D2ERRCNT2; + output D2ERRCNT1; + output D2ERRCNT0; + output D2PASS1; + output D2PASS0; + output D2VALID1; + output D2VALID0; + output D3ACTIVE1; + output D3ACTIVE0; + output D3BYTCNT9; + output D3BYTCNT8; + output D3BYTCNT7; + output D3BYTCNT6; + output D3BYTCNT5; + output D3BYTCNT4; + output D3BYTCNT3; + output D3BYTCNT2; + output D3BYTCNT1; + output D3BYTCNT0; + output D3ERRCNT9; + output D3ERRCNT8; + output D3ERRCNT7; + output D3ERRCNT6; + output D3ERRCNT5; + output D3ERRCNT4; + output D3ERRCNT3; + output D3ERRCNT2; + output D3ERRCNT1; + output D3ERRCNT0; + output D3PASS1; + output D3PASS0; + output D3VALID1; + output D3VALID0; + output DCTSTOUT9; + output DCTSTOUT8; + output DCTSTOUT7; + output DCTSTOUT6; + output DCTSTOUT5; + output DCTSTOUT4; + output DCTSTOUT3; + output DCTSTOUT2; + output DCTSTOUT1; + output DCTSTOUT0; + (* iopad_external_pin *) + inout DN0; + (* iopad_external_pin *) + inout DN1; + (* iopad_external_pin *) + inout DN2; + (* iopad_external_pin *) + inout DN3; + (* iopad_external_pin *) + inout DP0; + (* iopad_external_pin *) + inout DP1; + (* iopad_external_pin *) + inout DP2; + (* iopad_external_pin *) + inout DP3; + output LOCK; + input PDDPHY; + input PDPLL; + input SCCLKIN; + input SCRSTNIN; + output UDIR; + input UED0THEN; + output UERCLP0; + output UERCLP1; + output UERCTRL; + output UERE; + output UERSTHS; + output UERSSHS; + output UERSE; + input UFRXMODE; + input UTXMDTX; + output URXACTHS; + output URXCKE; + input URXCKINE; + output URXDE7; + output URXDE6; + output URXDE5; + output URXDE4; + output URXDE3; + output URXDE2; + output URXDE1; + output URXDE0; + output URXDHS15; + output URXDHS14; + output URXDHS13; + output URXDHS12; + output URXDHS11; + output URXDHS10; + output URXDHS9; + output URXDHS8; + output URXDHS7; + output URXDHS6; + output URXDHS5; + output URXDHS4; + output URXDHS3; + output URXDHS2; + output URXDHS1; + output URXDHS0; + output URXLPDTE; + output URXSKCHS; + output URXDRX; + output URXSHS3; + output URXSHS2; + output URXSHS1; + output URXSHS0; + output URE0D3DP; + output URE1D3DN; + output URE2CKDP; + output URE3CKDN; + output URXULPSE; + output URXVDE; + output URXVDHS3; + output URXVDHS2; + output URXVDHS1; + output URXVDHS0; + output USSTT; + input UTDIS; + input UTXCKE; + input UDE0D0TN; + input UDE1D1TN; + input UDE2D2TN; + input UDE3D3TN; + input UDE4CKTN; + input UDE5D0RN; + input UDE6D1RN; + input UDE7D2RN; + input UTXDHS31; + input UTXDHS30; + input UTXDHS29; + input UTXDHS28; + input UTXDHS27; + input UTXDHS26; + input UTXDHS25; + input UTXDHS24; + input UTXDHS23; + input UTXDHS22; + input UTXDHS21; + input UTXDHS20; + input UTXDHS19; + input UTXDHS18; + input UTXDHS17; + input UTXDHS16; + input UTXDHS15; + input UTXDHS14; + input UTXDHS13; + input UTXDHS12; + input UTXDHS11; + input UTXDHS10; + input UTXDHS9; + input UTXDHS8; + input UTXDHS7; + input UTXDHS6; + input UTXDHS5; + input UTXDHS4; + input UTXDHS3; + input UTXDHS2; + input UTXDHS1; + input UTXDHS0; + input UTXENER; + output UTXRRS; + output UTXRYP; + output UTXRYSK; + input UTXRD0EN; + input UTRD0SEN; + input UTXSKD0N; + input UTXTGE0; + input UTXTGE1; + input UTXTGE2; + input UTXTGE3; + input UTXULPSE; + input UTXUPSEX; + input UTXVDE; + input UTXWVDHS3; + input UTXWVDHS2; + input UTXWVDHS1; + input UTXWVDHS0; + output UUSAN; + output U1DIR; + input U1ENTHEN; + output U1ERCLP0; + output U1ERCLP1; + output U1ERCTRL; + output U1ERE; + output U1ERSTHS; + output U1ERSSHS; + output U1ERSE; + input U1FRXMD; + input U1FTXST; + output U1RXATHS; + output U1RXCKE; + output U1RXDE7; + output U1RXDE6; + output U1RXDE5; + output U1RXDE4; + output U1RXDE3; + output U1RXDE2; + output U1RXDE1; + output U1RXDE0; + output U1RXDHS15; + output U1RXDHS14; + output U1RXDHS13; + output U1RXDHS12; + output U1RXDHS11; + output U1RXDHS10; + output U1RXDHS9; + output U1RXDHS8; + output U1RXDHS7; + output U1RXDHS6; + output U1RXDHS5; + output U1RXDHS4; + output U1RXDHS3; + output U1RXDHS2; + output U1RXDHS1; + output U1RXDHS0; + output U1RXDTE; + output U1RXSKS; + output U1RXSK; + output U1RXSHS3; + output U1RXSHS2; + output U1RXSHS1; + output U1RXSHS0; + output U1RE0D; + output U1RE1CN; + output U1RE2D; + output U1RE3N; + output U1RXUPSE; + output U1RXVDE; + output U1RXVDHS3; + output U1RXVDHS2; + output U1RXVDHS1; + output U1RXVDHS0; + output U1SSTT; + input U1TDIS; + input U1TREQ; + input U1TDE0D3; + input U1TDE1CK; + input U1TDE2D0; + input U1TDE3D1; + input U1TDE4D2; + input U1TDE5D3; + input U1TDE6; + input U1TDE7; + input U1TXDHS31; + input U1TXDHS30; + input U1TXDHS29; + input U1TXDHS28; + input U1TXDHS27; + input U1TXDHS26; + input U1TXDHS25; + input U1TXDHS24; + input U1TXDHS23; + input U1TXDHS22; + input U1TXDHS21; + input U1TXDHS20; + input U1TXDHS19; + input U1TXDHS18; + input U1TXDHS17; + input U1TXDHS16; + input U1TXDHS15; + input U1TXDHS14; + input U1TXDHS13; + input U1TXDHS12; + input U1TXDHS11; + input U1TXDHS10; + input U1TXDHS9; + input U1TXDHS8; + input U1TXDHS7; + input U1TXDHS6; + input U1TXDHS5; + input U1TXDHS4; + input U1TXDHS3; + input U1TXDHS2; + input U1TXDHS1; + input U1TXDHS0; + input U1TXLPD; + output U1TXRYE; + output U1TXRY; + output U1TXRYSK; + input U1TXREQ; + input U1TXREQH; + input U1TXSK; + input U1TXTGE0; + input U1TXTGE1; + input U1TXTGE2; + input U1TXTGE3; + input U1TXUPSE; + input U1TXUPSX; + input U1TXVDE; + input U1TXWVHS3; + input U1TXWVHS2; + input U1TXWVHS1; + input U1TXWVHS0; + output U1USAN; + output U2DIR; + input U2END2; + output U2ERCLP0; + output U2ERCLP1; + output U2ERCTRL; + output U2ERE; + output U2ERSTHS; + output U2ERSSHS; + output U2ERSE; + input U2FRXMD; + input U2FTXST; + output U2RXACHS; + output U2RXCKE; + output U2RXDE7; + output U2RXDE6; + output U2RXDE5; + output U2RXDE4; + output U2RXDE3; + output U2RXDE2; + output U2RXDE1; + output U2RXDE0; + output U2RXDHS15; + output U2RXDHS14; + output U2RXDHS13; + output U2RXDHS12; + output U2RXDHS11; + output U2RXDHS10; + output U2RXDHS9; + output U2RXDHS8; + output U2RXDHS7; + output U2RXDHS6; + output U2RXDHS5; + output U2RXDHS4; + output U2RXDHS3; + output U2RXDHS2; + output U2RXDHS1; + output U2RXDHS0; + output U2RPDTE; + output U2RXSK; + output U2RXSKC; + output U2RXSHS3; + output U2RXSHS2; + output U2RXSHS1; + output U2RXSHS0; + output U2RE0D2; + output U2RE1D2; + output U2RE2D3; + output U2RE3D3; + output U2RXUPSE; + output U2RXVDE; + output U2RXVDHS3; + output U2RXVDHS2; + output U2RXVDHS1; + output U2RXVDHS0; + output U2SSTT; + input U2TDIS; + input U2TREQ; + input U2TDE0D0; + input U2TDE1D1; + input U2TDE2D2; + input U2TDE3D3; + input U2TDE4CK; + input U2TDE5D0; + input U2TDE6D1; + input U2TDE7D2; + input U2TXDHS31; + input U2TXDHS30; + input U2TXDHS29; + input U2TXDHS28; + input U2TXDHS27; + input U2TXDHS26; + input U2TXDHS25; + input U2TXDHS24; + input U2TXDHS23; + input U2TXDHS22; + input U2TXDHS21; + input U2TXDHS20; + input U2TXDHS19; + input U2TXDHS18; + input U2TXDHS17; + input U2TXDHS16; + input U2TXDHS15; + input U2TXDHS14; + input U2TXDHS13; + input U2TXDHS12; + input U2TXDHS11; + input U2TXDHS10; + input U2TXDHS9; + input U2TXDHS8; + input U2TXDHS7; + input U2TXDHS6; + input U2TXDHS5; + input U2TXDHS4; + input U2TXDHS3; + input U2TXDHS2; + input U2TXDHS1; + input U2TXDHS0; + input U2TPDTE; + output U2TXRYE; + output U2TXRYH; + output U2TXRYSK; + input U2TXREQ; + input U2TXREQH; + input U2TXSKC; + input U2TXTGE0; + input U2TXTGE1; + input U2TXTGE2; + input U2TXTGE3; + input U2TXUPSE; + input U2TXUPSX; + input U2TXVDE; + input U2TXWVHS3; + input U2TXWVHS2; + input U2TXWVHS1; + input U2TXWVHS0; + output U2USAN; + output U3DIR; + input U3END3; + output U3ERCLP0; + output U3ERCLP1; + output U3ERCTRL; + output U3ERE; + output U3ERSTHS; + output U3ERSSHS; + output U3ERSE; + input U3FRXMD; + input U3FTXST; + output U3RXATHS; + output U3RXCKE; + output U3RXDE7; + output U3RXDE6; + output U3RXDE5; + output U3RXDE4; + output U3RXDE3; + output U3RXDE2; + output U3RXDE1; + output U3RXDE0; + output U3RXDHS15; + output U3RXDHS14; + output U3RXDHS13; + output U3RXDHS12; + output U3RXDHS11; + output U3RXDHS10; + output U3RXDHS9; + output U3RXDHS8; + output U3RXDHS7; + output U3RXDHS6; + output U3RXDHS5; + output U3RXDHS4; + output U3RXDHS3; + output U3RXDHS2; + output U3RXDHS1; + output U3RXDHS0; + output U3RPDTE; + output U3RXSK; + output U3RXSKC; + output U3RXSHS3; + output U3RXSHS2; + output U3RXSHS1; + output U3RXSHS0; + output U3RE0CK; + output U3RE1CK; + output U3RE2; + output U3RE3; + output U3RXUPSE; + output U3RXVDE; + output U3RXVDHS3; + output U3RXVDHS2; + output U3RXVDHS1; + output U3RXVDHS0; + output U3SSTT; + input U3TDISD2; + input U3TREQD2; + input U3TDE0D3; + input U3TDE1D0; + input U3TDE2D1; + input U3TDE3D2; + input U3TDE4D3; + input U3TDE5CK; + input U3TDE6; + input U3TDE7; + input U3TXDHS31; + input U3TXDHS30; + input U3TXDHS29; + input U3TXDHS28; + input U3TXDHS27; + input U3TXDHS26; + input U3TXDHS25; + input U3TXDHS24; + input U3TXDHS23; + input U3TXDHS22; + input U3TXDHS21; + input U3TXDHS20; + input U3TXDHS19; + input U3TXDHS18; + input U3TXDHS17; + input U3TXDHS16; + input U3TXDHS15; + input U3TXDHS14; + input U3TXDHS13; + input U3TXDHS12; + input U3TXDHS11; + input U3TXDHS10; + input U3TXDHS9; + input U3TXDHS8; + input U3TXDHS7; + input U3TXDHS6; + input U3TXDHS5; + input U3TXDHS4; + input U3TXDHS3; + input U3TXDHS2; + input U3TXDHS1; + input U3TXDHS0; + input U3TXLPDT; + output U3TXRY; + output U3TXRYHS; + output U3TXRYSK; + input U3TXREQ; + input U3TXREQH; + input U3TXSKC; + input U3TXTGE0; + input U3TXTGE1; + input U3TXTGE2; + input U3TXTGE3; + input U3TXULPS; + input U3TXUPSX; + input U3TXVD3; + input U3TXWVHS3; + input U3TXWVHS2; + input U3TXWVHS1; + input U3TXWVHS0; + output U3USAN; + input UCENCK; + output UCRXCKAT; + output UCRXUCKN; + output UCSSTT; + input UCTXREQH; + input UCTXUPSC; + input UCTXUPSX; + output UCUSAN; + input SCANCLK; + input SCANRST; + input LMMICLK; + input LMMIOFFSET4; + input LMMIOFFSET3; + input LMMIOFFSET2; + input LMMIOFFSET1; + input LMMIOFFSET0; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIREQUEST; + input LMMIRESETN; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + input LMMIWRRDN; + input LTSTEN; + input LTSTLANE1; + input LTSTLANE0; + output URWDCKHS; + input UTRNREQ; + output UTWDCKHS; + output UCRXWCHS; + input OPCGLDCK; + output CLKLBACT; +endmodule + +module DQSBUF_CORE (...); + parameter GSR = "ENABLED"; + parameter ENABLE_FIFO = "DISABLED"; + parameter FORCE_READ = "DISABLED"; + parameter FREE_WHEEL = "DDR"; + parameter MODX = "NOT_USED"; + parameter MT_EN_READ = "DISABLED"; + parameter MT_EN_WRITE = "DISABLED"; + parameter MT_EN_WRITE_LEVELING = "DISABLED"; + parameter RD_PNTR = "0b000"; + parameter READ_ENABLE = "DISABLED"; + parameter RX_CENTERED = "ENABLED"; + parameter S_READ = "0"; + parameter S_WRITE = "0"; + parameter SIGN_READ = "POSITIVE"; + parameter SIGN_WRITE = "POSITIVE"; + parameter UPDATE_QU = "UP1_AND_UP0_SAME"; + parameter WRITE_ENABLE = "DISABLED"; + parameter SEL_READ_BIT_ENABLE_CYCLES = "NORMAL"; + parameter BYPASS_WR_LEVEL_SMTH_LATCH = "SMOOTHING_PATH"; + parameter BYPASS_WR_SMTH_LATCH = "SMOOTHING_PATH"; + parameter BYPASS_READ_SMTH_LATCH = "SMOOTHING_PATH"; + output BTDETECT; + output BURSTDETECT; + output DATAVALID; + input DQSI; + output DQSW; + output DQSWRD; + input PAUSE; + input RDCLKSEL3; + input RDCLKSEL2; + input RDCLKSEL1; + input RDCLKSEL0; + input RDDIR; + input RDLOADN; + output RDPNTR2; + output RDPNTR1; + output RDPNTR0; + input READ3; + input READ2; + input READ1; + input READ0; + output READCOUT; + input READMOVE; + input RST; + input SCLK; + input SELCLK; + output DQSR90; + output DQSW270; + output WRCOUT; + input WRDIR; + input WRLOAD_N; + output WRLVCOUT; + input WRLVDIR; + input WRLVLOAD_N; + input WRLVMOVE; + input WRMOVE; + output WRPNTR2; + output WRPNTR1; + output WRPNTR0; + input ECLKIN; + input RSTSMCNT; + input DLLCODE8; + input DLLCODE7; + input DLLCODE6; + input DLLCODE5; + input DLLCODE4; + input DLLCODE3; + input DLLCODE2; + input DLLCODE1; + input DLLCODE0; +endmodule + +module ECLKDIV_CORE (...); + parameter ECLK_DIV = "DISABLE"; + parameter GSR = "ENABLED"; + output DIVOUT; + input DIVRST; + input ECLKIN; + input SLIP; + input TESTINP3; + input TESTINP2; + input TESTINP1; + input TESTINP0; +endmodule + +module ECLKSYNC_CORE (...); + parameter STOP_EN = "DISABLE"; + input ECLKIN; + output ECLKOUT; + input STOP; +endmodule + +module FBMUX_CORE (...); + parameter INTFB = "IGNORED"; + parameter SEL_FBK = "DIVA"; + parameter CLKMUX_FB = "CMUX_CLKOP"; + parameter INTFBKDEL_SEL = "DISABLED"; + output ENEXT; + output FBKCK; + input LGYRDYN; + input INTLOCK; + input WKUPSYNC; + input FBKCLK15; + input FBKCLK14; + input FBKCLK13; + input FBKCLK12; + input FBKCLK11; + input FBKCLK10; + input FBKCLK9; + input FBKCLK8; + input FBKCLK7; + input FBKCLK6; + input FBKCLK5; + input FBKCLK4; + input FBKCLK3; + input FBKCLK2; + input FBKCLK1; + input FBKCLK0; +endmodule + +module I2CFIFO_CORE (...); + parameter BRNBASEDELAY = "0b0000"; + parameter CR1CKDIS = "EN"; + parameter CR1FIFOMODE = "REG"; + parameter CR1GCEN = "DIS"; + parameter CR1I2CEN = "DIS"; + parameter CR1SDADELSEL = "NDLY0"; + parameter CR1SLPCLKEN = "DIS"; + parameter CR2CORERSTN = "DIS"; + parameter CR2HARDTIE = "TIE"; + parameter CR2INTCLREN = "DIS"; + parameter CR2MRDCMPLWKUP = "DIS"; + parameter CR2RXFIFOAFWKUP = "DIS"; + parameter CR2SLVADDRWKUP = "DIS"; + parameter GSR = "ENABLED"; + parameter I2CRXFIFOAFVAL = "0b00000"; + parameter I2CSLVADDRA = "0b0000000000"; + parameter I2CTXFIFOAEVAL = "0b0000"; + parameter INTARBLIE = "DIS"; + parameter INTBUSFREEIE = "DIS"; + parameter INTHGCIE = "DIS"; + parameter INTMRDCMPLIE = "DIS"; + parameter INTRNACKIEORRSVD = "DIS"; + parameter INTRSVDORTROEIE = "DIS"; + parameter INTRSVDORTRRDYIE = "DIS"; + parameter INTRXOVERFIEORRSVD = "DIS"; + parameter INTRXUNDERFIE = "DIS"; + parameter INTTXOVERFIE = "DIS"; + parameter INTTXSERRIEORRSVD = "DIS"; + parameter LMMI_EXTRA_ONE = "DIS"; + parameter LMMI_EXTRA_TWO = "DIS"; + parameter NCRALTIOEN = "FABRIC"; + parameter NCRFILTERDIS = "EN"; + parameter NCRSDAINDLYEN = "DIS"; + parameter NCRSDAOUTDLYEN = "DIS"; + parameter NONUSRTESTSOFTTRIMEN = "DIS"; + parameter NONUSRTSTSOFTTRIMVALUE = "0b000"; + parameter REGI2CBR = "0b0000000000"; + parameter TSPTIMERVALUE = "0b10010010111"; + input ALTSCLIN; + output ALTSCLOEN; + output ALTSCLOUT; + input ALTSDAIN; + output ALTSDAOEN; + output ALTSDAOUT; + output BUSBUSY; + input FIFORESET; + input I2CLSRRSTN; + output INSLEEP; + output IRQ; + input LMMICLK; + input LMMIOFFSET5; + input LMMIOFFSET4; + input LMMIOFFSET3; + input LMMIOFFSET2; + input LMMIOFFSET1; + input LMMIOFFSET0; + output LMMIRDATA7; + output LMMIRDATA6; + output LMMIRDATA5; + output LMMIRDATA4; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIREQUEST; + input LMMIRESETN; + input LMMIWDATA7; + input LMMIWDATA6; + input LMMIWDATA5; + input LMMIWDATA4; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + input LMMIWRRDN; + output MRDCMPL; + input OPCGLOADCLK; + output RXFIFOAF; + output RXFIFOE; + output RXFIFOF; + input SCANCLK; + input SCANRST; + input SCLIN; + output SCLOE; + output SCLOEN; + output SCLOUT; + input SDAIN; + output SDAOE; + output SDAOEN; + output SDAOUT; + input SLEEPCLKSELN; + output SLVADDRMATCH; + output SLVADDRMATCHSCL; + output SRDWR; + output TXFIFOAE; + output TXFIFOE; + output TXFIFOF; +endmodule + +module LRAM_CORE (...); + parameter INITVAL_00 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_01 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_02 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_03 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_04 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_05 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_06 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_07 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_08 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_09 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_0F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_10 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_11 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_12 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_13 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_14 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_15 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_16 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_17 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_18 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_19 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_1F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_20 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_21 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_22 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_23 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_24 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_25 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_26 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_27 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_28 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_29 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_2F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_30 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_31 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_32 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_33 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_34 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_35 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_36 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_37 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_38 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_39 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_3F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_40 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_41 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_42 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_43 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_44 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_45 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_46 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_47 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_48 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_49 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_4F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_50 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_51 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_52 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_53 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_54 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_55 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_56 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_57 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_58 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_59 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_5F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_60 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_61 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_62 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_63 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_64 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_65 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_66 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_67 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_68 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_69 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_6F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_70 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_71 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_72 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_73 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_74 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_75 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_76 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_77 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_78 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_79 = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7A = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7B = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7C = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7D = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7E = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter INITVAL_7F = "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ASYNC_RST_RELEASE = "SYNC"; + parameter CFG_INIT_ID = "0b00000000000"; + parameter DATA_PRESERVE = "DISABLE"; + parameter EBR_SP_EN = "DISABLE"; + parameter ECC_BYTE_SEL = "ECC_EN"; + parameter GSR = "ENABLED"; + parameter OUT_REGMODE_A = "NO_REG"; + parameter OUT_REGMODE_B = "NO_REG"; + parameter RESETMODE = "SYNC"; + parameter RST_AB_EN = "RESET_AB_DISABLE"; + parameter SP_EN = "DISABLE"; + parameter UNALIGNED_READ = "DISABLE"; + input ADA13; + input ADA12; + input ADA11; + input ADA10; + input ADA9; + input ADA8; + input ADA7; + input ADA6; + input ADA5; + input ADA4; + input ADA3; + input ADA2; + input ADA1; + input ADA0; + input ADB13; + input ADB12; + input ADB11; + input ADB10; + input ADB9; + input ADB8; + input ADB7; + input ADB6; + input ADB5; + input ADB4; + input ADB3; + input ADB2; + input ADB1; + input ADB0; + input BENA_N3; + input BENA_N2; + input BENA_N1; + input BENA_N0; + input BENB_N3; + input BENB_N2; + input BENB_N1; + input BENB_N0; + input CEA; + input CEB; + input CLK; + input CSA; + input CSB; + input DIA31; + input DIA30; + input DIA29; + input DIA28; + input DIA27; + input DIA26; + input DIA25; + input DIA24; + input DIA23; + input DIA22; + input DIA21; + input DIA20; + input DIA19; + input DIA18; + input DIA17; + input DIA16; + input DIA15; + input DIA14; + input DIA13; + input DIA12; + input DIA11; + input DIA10; + input DIA9; + input DIA8; + input DIA7; + input DIA6; + input DIA5; + input DIA4; + input DIA3; + input DIA2; + input DIA1; + input DIA0; + input DIB31; + input DIB30; + input DIB29; + input DIB28; + input DIB27; + input DIB26; + input DIB25; + input DIB24; + input DIB23; + input DIB22; + input DIB21; + input DIB20; + input DIB19; + input DIB18; + input DIB17; + input DIB16; + input DIB15; + input DIB14; + input DIB13; + input DIB12; + input DIB11; + input DIB10; + input DIB9; + input DIB8; + input DIB7; + input DIB6; + input DIB5; + input DIB4; + input DIB3; + input DIB2; + input DIB1; + input DIB0; + output DOA31; + output DOA30; + output DOA29; + output DOA28; + output DOA27; + output DOA26; + output DOA25; + output DOA24; + output DOA23; + output DOA22; + output DOA21; + output DOA20; + output DOA19; + output DOA18; + output DOA17; + output DOA16; + output DOA15; + output DOA14; + output DOA13; + output DOA12; + output DOA11; + output DOA10; + output DOA9; + output DOA8; + output DOA7; + output DOA6; + output DOA5; + output DOA4; + output DOA3; + output DOA2; + output DOA1; + output DOA0; + output DOB31; + output DOB30; + output DOB29; + output DOB28; + output DOB27; + output DOB26; + output DOB25; + output DOB24; + output DOB23; + output DOB22; + output DOB21; + output DOB20; + output DOB19; + output DOB18; + output DOB17; + output DOB16; + output DOB15; + output DOB14; + output DOB13; + output DOB12; + output DOB11; + output DOB10; + output DOB9; + output DOB8; + output DOB7; + output DOB6; + output DOB5; + output DOB4; + output DOB3; + output DOB2; + output DOB1; + output DOB0; + input DPS; + output ERRDECA1; + output ERRDECA0; + output ERRDECB1; + output ERRDECB0; + input IGN; + input INITN; + input OCEA; + input OCEB; + output OEA; + output OEB; + input RSTA; + input RSTB; + input STDBYN; + input TBISTN; + input WEA; + input WEB; + output ERRDET; + output LRAMREADY; + input OPCGLOADCLK; + input SCANCLK; + input SCANRST; +endmodule + +module MULT18_CORE (...); + parameter SFTEN = "DISABLED"; + parameter MULT18X18 = "ENABLED"; + parameter ROUNDHALFUP = "DISABLED"; + parameter ROUNDRTZI = "ROUND_TO_ZERO"; + parameter ROUNDBIT = "ROUND_TO_BIT0"; + input SFTCTRL3; + input SFTCTRL2; + input SFTCTRL1; + input SFTCTRL0; + input ARHSIGN; + input BRHSIGN; + input ARH8; + input ARH7; + input ARH6; + input ARH5; + input ARH4; + input ARH3; + input ARH2; + input ARH1; + input ARH0; + input BRH8; + input BRH7; + input BRH6; + input BRH5; + input BRH4; + input BRH3; + input BRH2; + input BRH1; + input BRH0; + input ARL8; + input ARL7; + input ARL6; + input ARL5; + input ARL4; + input ARL3; + input ARL2; + input ARL1; + input ARL0; + input BRL8; + input BRL7; + input BRL6; + input BRL5; + input BRL4; + input BRL3; + input BRL2; + input BRL1; + input BRL0; + input PL1819; + input PL1818; + input PL1817; + input PL1816; + input PL1815; + input PL1814; + input PL1813; + input PL1812; + input PL1811; + input PL1810; + input PL189; + input PL188; + input PL187; + input PL186; + input PL185; + input PL184; + input PL183; + input PL182; + input PL181; + input PL180; + input PH1819; + input PH1818; + input PH1817; + input PH1816; + input PH1815; + input PH1814; + input PH1813; + input PH1812; + input PH1811; + input PH1810; + input PH189; + input PH188; + input PH187; + input PH186; + input PH185; + input PH184; + input PH183; + input PH182; + input PH181; + input PH180; + output SIGNED18; + output P3637; + output P3636; + output P3635; + output P3634; + output P3633; + output P3632; + output P3631; + output P3630; + output P3629; + output P3628; + output P3627; + output P3626; + output P3625; + output P3624; + output P3623; + output P3622; + output P3621; + output P3620; + output P3619; + output P3618; + output P3617; + output P3616; + output P3615; + output P3614; + output P3613; + output P3612; + output P3611; + output P3610; + output P369; + output P368; + output P367; + output P366; + output P365; + output P364; + output P363; + output P362; + output P361; + output P360; + input ROUNDEN; +endmodule + +module MULT18X36_CORE (...); + parameter SFTEN = "DISABLED"; + parameter MULT18X36 = "ENABLED"; + parameter MULT36 = "DISABLED"; + parameter MULT36X36H = "USED_AS_LOWER_BIT_GENERATION"; + parameter ROUNDHALFUP = "DISABLED"; + parameter ROUNDRTZI = "ROUND_TO_ZERO"; + parameter ROUNDBIT = "ROUND_TO_BIT0"; + input SFTCTRL3; + input SFTCTRL2; + input SFTCTRL1; + input SFTCTRL0; + input PH3637; + input PH3636; + input PH3635; + input PH3634; + input PH3633; + input PH3632; + input PH3631; + input PH3630; + input PH3629; + input PH3628; + input PH3627; + input PH3626; + input PH3625; + input PH3624; + input PH3623; + input PH3622; + input PH3621; + input PH3620; + input PH3619; + input PH3618; + input PH3617; + input PH3616; + input PH3615; + input PH3614; + input PH3613; + input PH3612; + input PH3611; + input PH3610; + input PH369; + input PH368; + input PH367; + input PH366; + input PH365; + input PH364; + input PH363; + input PH362; + input PH361; + input PH360; + input PL3637; + input PL3636; + input PL3635; + input PL3634; + input PL3633; + input PL3632; + input PL3631; + input PL3630; + input PL3629; + input PL3628; + input PL3627; + input PL3626; + input PL3625; + input PL3624; + input PL3623; + input PL3622; + input PL3621; + input PL3620; + input PL3619; + input PL3618; + input PL3617; + input PL3616; + input PL3615; + input PL3614; + input PL3613; + input PL3612; + input PL3611; + input PL3610; + input PL369; + input PL368; + input PL367; + input PL366; + input PL365; + input PL364; + input PL363; + input PL362; + input PL361; + input PL360; + input SGNED18H; + input SGNED18L; + output P7272; + output P7271; + output P7270; + output P7269; + output P7268; + output P7267; + output P7266; + output P7265; + output P7264; + output P7263; + output P7262; + output P7261; + output P7260; + output P7259; + output P7258; + output P7257; + output P7256; + output P7255; + output P7254; + output P7253; + output P7252; + output P7251; + output P7250; + output P7249; + output P7248; + output P7247; + output P7246; + output P7245; + output P7244; + output P7243; + output P7242; + output P7241; + output P7240; + output P7239; + output P7238; + output P7237; + output P7236; + output P7235; + output P7234; + output P7233; + output P7232; + output P7231; + output P7230; + output P7229; + output P7228; + output P7227; + output P7226; + output P7225; + output P7224; + output P7223; + output P7222; + output P7221; + output P7220; + output P7219; + output P7218; + output P7217; + output P7216; + output P7215; + output P7214; + output P7213; + output P7212; + output P7211; + output P7210; + output P729; + output P728; + output P727; + output P726; + output P725; + output P724; + output P723; + output P722; + output P721; + output P720; + input ROUNDEN; +endmodule + +module MULT36_CORE (...); + parameter MULT36X36 = "ENABLED"; + input PH7272; + input PH7271; + input PH7270; + input PH7269; + input PH7268; + input PH7267; + input PH7266; + input PH7265; + input PH7264; + input PH7263; + input PH7262; + input PH7261; + input PH7260; + input PH7259; + input PH7258; + input PH7257; + input PH7256; + input PH7255; + input PH7254; + input PH7253; + input PH7252; + input PH7251; + input PH7250; + input PH7249; + input PH7248; + input PH7247; + input PH7246; + input PH7245; + input PH7244; + input PH7243; + input PH7242; + input PH7241; + input PH7240; + input PH7239; + input PH7238; + input PH7237; + input PH7236; + input PH7235; + input PH7234; + input PH7233; + input PH7232; + input PH7231; + input PH7230; + input PH7229; + input PH7228; + input PH7227; + input PH7226; + input PH7225; + input PH7224; + input PH7223; + input PH7222; + input PH7221; + input PH7220; + input PH7219; + input PH7218; + input PH7217; + input PH7216; + input PH7215; + input PH7214; + input PH7213; + input PH7212; + input PH7211; + input PH7210; + input PH729; + input PH728; + input PH727; + input PH726; + input PH725; + input PH724; + input PH723; + input PH722; + input PH721; + input PH720; + input PL7272; + input PL7271; + input PL7270; + input PL7269; + input PL7268; + input PL7267; + input PL7266; + input PL7265; + input PL7264; + input PL7263; + input PL7262; + input PL7261; + input PL7260; + input PL7259; + input PL7258; + input PL7257; + input PL7256; + input PL7255; + input PL7254; + input PL7253; + input PL7252; + input PL7251; + input PL7250; + input PL7249; + input PL7248; + input PL7247; + input PL7246; + input PL7245; + input PL7244; + input PL7243; + input PL7242; + input PL7241; + input PL7240; + input PL7239; + input PL7238; + input PL7237; + input PL7236; + input PL7235; + input PL7234; + input PL7233; + input PL7232; + input PL7231; + input PL7230; + input PL7229; + input PL7228; + input PL7227; + input PL7226; + input PL7225; + input PL7224; + input PL7223; + input PL7222; + input PL7221; + input PL7220; + input PL7219; + input PL7218; + input PL7217; + input PL7216; + input PL7215; + input PL7214; + input PL7213; + input PL7212; + input PL7211; + input PL7210; + input PL729; + input PL728; + input PL727; + input PL726; + input PL725; + input PL724; + input PL723; + input PL722; + input PL721; + input PL720; + output PML7271; + output PML7270; + output PML7269; + output PML7268; + output PML7267; + output PML7266; + output PML7265; + output PML7264; + output PML7263; + output PML7262; + output PML7261; + output PML7260; + output PML7259; + output PML7258; + output PML7257; + output PML7256; + output PML7255; + output PML7254; + output PML7253; + output PML7252; + output PML7251; + output PML7250; + output PML7249; + output PML7248; + output PML7247; + output PML7246; + output PML7245; + output PML7244; + output PML7243; + output PML7242; + output PML7241; + output PML7240; + output PML7239; + output PML7238; + output PML7237; + output PML7236; + output PML7235; + output PML7234; + output PML7233; + output PML7232; + output PML7231; + output PML7230; + output PML7229; + output PML7228; + output PML7227; + output PML7226; + output PML7225; + output PML7224; + output PML7223; + output PML7222; + output PML7221; + output PML7220; + output PML7219; + output PML7218; + output PML7217; + output PML7216; + output PML7215; + output PML7214; + output PML7213; + output PML7212; + output PML7211; + output PML7210; + output PML729; + output PML728; + output PML727; + output PML726; + output PML725; + output PML724; + output PML723; + output PML722; + output PML721; + output PML720; + output PMH7271; + output PMH7270; + output PMH7269; + output PMH7268; + output PMH7267; + output PMH7266; + output PMH7265; + output PMH7264; + output PMH7263; + output PMH7262; + output PMH7261; + output PMH7260; + output PMH7259; + output PMH7258; + output PMH7257; + output PMH7256; + output PMH7255; + output PMH7254; + output PMH7253; + output PMH7252; + output PMH7251; + output PMH7250; + output PMH7249; + output PMH7248; + output PMH7247; + output PMH7246; + output PMH7245; + output PMH7244; + output PMH7243; + output PMH7242; + output PMH7241; + output PMH7240; + output PMH7239; + output PMH7238; + output PMH7237; + output PMH7236; + output PMH7235; + output PMH7234; + output PMH7233; + output PMH7232; + output PMH7231; + output PMH7230; + output PMH7229; + output PMH7228; + output PMH7227; + output PMH7226; + output PMH7225; + output PMH7224; + output PMH7223; + output PMH7222; + output PMH7221; + output PMH7220; + output PMH7219; + output PMH7218; + output PMH7217; + output PMH7216; + output PMH7215; + output PMH7214; + output PMH7213; + output PMH7212; + output PMH7211; + output PMH7210; + output PMH729; + output PMH728; + output PMH727; + output PMH726; + output PMH725; + output PMH724; + output PMH723; + output PMH722; + output PMH721; + output PMH720; +endmodule + +module MULT9_CORE (...); + parameter SIGNEDSTATIC_EN = "DISABLED"; + parameter ASIGNED_OPERAND_EN = "DISABLED"; + parameter BYPASS_MULT9 = "USED"; + parameter REGBYPSB = "REGISTER"; + parameter REGBYPSA1 = "REGISTER"; + parameter REGBYPSA2 = "REGISTER"; + parameter SHIFTA = "DISABLED"; + parameter SR_18BITSHIFT_EN = "DISABLED"; + parameter GSR = "ENABLED"; + parameter RESET = "SYNC"; + input A8; + input A7; + input A6; + input A5; + input A4; + input A3; + input A2; + input A1; + input A0; + input ASIGNED; + input BR8; + input BR7; + input BR6; + input BR5; + input BR4; + input BR3; + input BR2; + input BR1; + input BR0; + input AS18; + input AS17; + input AS16; + input AS15; + input AS14; + input AS13; + input AS12; + input AS11; + input AS10; + input AS28; + input AS27; + input AS26; + input AS25; + input AS24; + input AS23; + input AS22; + input AS21; + input AS20; + input ASSIGNED1; + input ASSIGNED2; + input BRSIGNED; + input CLK; + input CEA; + input RSTA; + output AO8; + output AO7; + output AO6; + output AO5; + output AO4; + output AO3; + output AO2; + output AO1; + output AO0; + output BO8; + output BO7; + output BO6; + output BO5; + output BO4; + output BO3; + output BO2; + output BO1; + output BO0; + output AOSIGNED; + output BOSIGNED; + output AR8; + output AR7; + output AR6; + output AR5; + output AR4; + output AR3; + output AR2; + output AR1; + output AR0; + output ARSIGNED; + output P1819; + output P1818; + output P1817; + output P1816; + output P1815; + output P1814; + output P1813; + output P1812; + output P1811; + output P1810; + output P189; + output P188; + output P187; + output P186; + output P185; + output P184; + output P183; + output P182; + output P181; + output P180; + input CEP; + input RSTP; +endmodule + +module OSC_CORE (...); + parameter DTR_EN = "ENABLED"; + parameter HF_CLK_DIV = "1"; + parameter HF_SED_SEC_DIV = "1"; + parameter HF_FABRIC_EN = "DISABLED"; + parameter HF_OSC_EN = "ENABLED"; + parameter HFDIV_FABRIC_EN = "ENABLED"; + parameter LF_FABRIC_EN = "DISABLED"; + parameter LF_OUTPUT_EN = "DISABLED"; + parameter DEBUG_N = "DISABLED"; + output HFCLKOUT; + input HFOUTEN; + input HFSDSCEN; + input HFTRMFAB8; + input HFTRMFAB7; + input HFTRMFAB6; + input HFTRMFAB5; + input HFTRMFAB4; + input HFTRMFAB3; + input HFTRMFAB2; + input HFTRMFAB1; + input HFTRMFAB0; + output LFCLKOUT; + input LFTRMFAB8; + input LFTRMFAB7; + input LFTRMFAB6; + input LFTRMFAB5; + input LFTRMFAB4; + input LFTRMFAB3; + input LFTRMFAB2; + input LFTRMFAB1; + input LFTRMFAB0; + output HFCLKCFG; + output HFSDCOUT; +endmodule + +module PCIE_CORE (...); + parameter ENABLE_USER_CFG = "DISABLED"; + parameter PWDN_N = "DISABLED"; + parameter GSR = "ENABLED"; + parameter IDDQ_PCS = "DISABLED"; + parameter PHY_MODE = "0b0000"; + parameter ALT_CLK_SEL_VCC = "PAD"; + parameter L0S_ADJ = "0b00000110000000"; + parameter L0S_EXIT_LATENCY = "MORE_4_US"; + parameter L1_EXIT_LATENCY = "MORE_64_US"; + parameter CALIB_3DB = "ENABLED"; + parameter DB_UPSTREAM = "6DB"; + parameter ERR_REC_ENTRY_SEL = "RCVRY_AFTER"; + parameter A_CHNGD_MAX = "0b100"; + parameter A0_FORCE = "DISABLED"; + parameter A0_FREEZE = "DISABLED"; + parameter A0_INIT = "0b000000"; + parameter A0DIR_VAL = "DISABLED"; + parameter A1_FORCE = "DISABLED"; + parameter A1_FREEZE = "DISABLED"; + parameter A1_INIT = "0b000000"; + parameter A1DIR_VAL = "DISABLED"; + parameter A2_FORCE = "DISABLED"; + parameter A2_FREEZE = "DISABLED"; + parameter A2_INIT = "0b000000"; + parameter A2GAIN_CALIB = "0b100110"; + parameter ACJTAG_REG = "0b00"; + parameter ADDR_LIMIT_PRE_MTHD_CTRL = "0b0100"; + parameter ADDR_LIMIT_TABLE_MTHD_CTRL = "0b00101"; + parameter ADIR_OVR = "DISABLED"; + parameter ADV_CH_CD_SEL = "IMPLEMENT_CH"; + parameter ADV_TARGET_LINK_SPEED_USPORT_A = "DISABLED"; + parameter ADV_TARGET_LINK_SPEED_USPORT_B = "DISABLED"; + parameter ADV_TARGET_LINK_SPEED_USPORT_C = "DISABLED"; + parameter ADV_TARGET_LINK_SPEED_USPORT_D = "DISABLED"; + parameter ADVANCE = "DISABLED"; + parameter ALERT_ENABLE = "0b000"; + parameter ALMOST_EMPTY_10B = "0b001110"; + parameter MID_VALUE_10B = "0b011110"; + parameter ALMOST_EMPTY_20B = "0b001111"; + parameter ALMOST_EMPTY_GEN3 = "0b001100"; + parameter ALMOST_FULL_10B = "0b110000"; + parameter ALMOST_FULL_20B = "0b011000"; + parameter ALMOST_FULL_GEN3 = "0b010110"; + parameter ARRAY_DA = "0b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter ARRAY_MT = "0b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000011100000000000010000000000000001001000000000000011000000000000001010000000000000100"; + parameter ARXCDRICP_RATE0 = "0b011"; + parameter ARXCDRICP_RATE1 = "0b011"; + parameter ARXCDRICP_RATE2 = "0b011"; + parameter ARXDMPWRDWN = "DISABLED"; + parameter ARXDPPWRDN = "DISABLED"; + parameter ARXEOM_PWRDN = "POWERED_DOWN"; + parameter ARXICP_RATE0 = "0b011"; + parameter ARXICP_RATE1 = "0b011"; + parameter ARXICP_RATE2 = "0b011"; + parameter ARXOVR_OUT = "DISABLED"; + parameter ARXRSACTAT = "0b0001"; + parameter ARXRSAPTAT = "0b1000"; + parameter ARXRSVCTL = "0b00000000"; + parameter ARXSEL_OUT = "DISABLED"; + parameter ASPM_L1_1_SUPPORTED = "SUPPORTED"; + parameter ASPM_L1_2_SUPPORTED = "SUPPORTED"; + parameter ASPM_SUPPORT = "L0S_AND_L1_SUPPORTED"; + parameter ATTENTION_BUTTON_PRESENT = "NOT_SUPPORTED"; + parameter ATTENTION_INDICATOR_PRESENT = "NOT_SUPPORTED"; + parameter ATXICP_RATE0 = "0b101"; + parameter ATXICP_RATE1 = "0b101"; + parameter AUTO_SHIFT = "ENABLED"; + parameter AUX_CURRENT = "SELF_POWERED"; + parameter AUXCLK1US_MAX = "0b00001001"; + parameter AUXIDL_MAX = "0b00000100"; + parameter BAR_INDEX_CFG0_A = "0b000"; + parameter BAR_INDEX_CFG0_B = "0b000"; + parameter BAR_INDEX_CFG0_C = "0b000"; + parameter BAR_INDEX_CFG0_D = "0b000"; + parameter BAR_INDEX_CFG1_A = "0b001"; + parameter BAR_INDEX_CFG1_B = "0b001"; + parameter BAR_INDEX_CFG1_C = "0b001"; + parameter BAR_INDEX_CFG1_D = "0b001"; + parameter BAR_INDEX_CFG2_A = "0b010"; + parameter BAR_INDEX_CFG2_B = "0b010"; + parameter BAR_INDEX_CFG2_C = "0b010"; + parameter BAR_INDEX_CFG2_D = "0b010"; + parameter BAR_INDEX_CFG3_A = "0b011"; + parameter BAR_INDEX_CFG3_B = "0b011"; + parameter BAR_INDEX_CFG3_C = "0b011"; + parameter BAR_INDEX_CFG3_D = "0b011"; + parameter BAR_INDEX_CFG4_A = "0b100"; + parameter BAR_INDEX_CFG4_B = "0b100"; + parameter BAR_INDEX_CFG4_C = "0b100"; + parameter BAR_INDEX_CFG4_D = "0b100"; + parameter BAR_INDEX_CFG5_A = "0b101"; + parameter BAR_INDEX_CFG5_B = "0b101"; + parameter BAR_INDEX_CFG5_C = "0b101"; + parameter BAR_INDEX_CFG5_D = "0b101"; + parameter BIR_MSIX_PBA_A = "BAR0"; + parameter BIR_MSIX_PBA_B = "BAR0"; + parameter BIR_MSIX_PBA_C = "BAR0"; + parameter BIR_MSIX_PBA_D = "BAR0"; + parameter BIR_MSIX_TABLE_A = "BAR0"; + parameter BIR_MSIX_TABLE_B = "BAR0"; + parameter BIR_MSIX_TABLE_C = "BAR0"; + parameter BIR_MSIX_TABLE_D = "BAR0"; + parameter BYP_AVG = "USED"; + parameter BYPASS = "PERFORM_RECEIVER_DETECTION"; + parameter BYPASS_ADDR_DEC = "NORMAL"; + parameter CALIB_SETTLE_MAX = "0b001"; + parameter CALIB_STABLE_MAX = "0b11000"; + parameter CAPABILITY_VERSION = "0b0010"; + parameter CDR_ERR = "DISABLED"; + parameter CDR_P1 = "CDR_PLL_RESET"; + parameter CDR_PLL_DELTA = "0P4_PERCENT"; + parameter CDR_REFERENCE = "0b00"; + parameter CDRPLL_CMP_MAX = "0b00010100"; + parameter CDRPLL_CNT_MAX = "0b00000100"; + parameter CDRPLL_PRE_RXEQ_COARSE_TIMER = "0b01010000"; + parameter CDRPLL_PRE_RXEQ_FINE_TIMER = "0b10110100"; + parameter CDRPLL_PST_RXEQ_COARSE_TIMER = "0b01000000"; + parameter CDRPLL_PST_RXEQ_FINE_TIMER = "0b01000010"; + parameter CFG_A_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_A_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_A_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_A_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_A_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_A_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_B_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_B_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_B_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_B_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_B_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_B_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_C_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_C_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_C_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_C_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_C_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_C_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_D_BAR0 = "0b11111111111111110000000000001100"; + parameter CFG_D_BAR1 = "0b11111111111111111111111111111111"; + parameter CFG_D_BAR2 = "0b11111111111111111110000000001100"; + parameter CFG_D_BAR3 = "0b11111111111111111111111111111111"; + parameter CFG_D_BAR4 = "0b11111111111111111110000000001100"; + parameter CFG_D_BAR5 = "0b11111111111111111111111111111111"; + parameter CFG_EXP_ROM_A = "0b00000000000000000000000000000000"; + parameter CFG_EXP_ROM_B = "0b00000000000000000000000000000000"; + parameter CFG_EXP_ROM_C = "0b00000000000000000000000000000000"; + parameter CFG_EXP_ROM_D = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_A = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_B = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_C = "0b00000000000000000000000000000000"; + parameter CIS_POINTER_CARDBUS_D = "0b00000000000000000000000000000000"; + parameter CLASS_CODE_ID3A = "0b000100011000000000000000"; + parameter CLASS_CODE_ID3B = "0b000100011000000000000000"; + parameter CLASS_CODE_ID3C = "0b000100011000000000000000"; + parameter CLASS_CODE_ID3D = "0b000100011000000000000000"; + parameter CM_RESTORE_TIME = "0b00000000"; + parameter CNT250NS_MAX = "0b001111100"; + parameter COARSE_GAIN = "DISABLED"; + parameter COEF_EN_LPBK_MASTER = "OTHERWISE"; + parameter COEF_EN_LPBK_SLAVE = "OTHERWISE"; + parameter COEF_ENABLE = "DETERMINE_LOCAL_PHY"; + parameter COEF_EQTX_FORCE = "0b000000000000000000"; + parameter COEF_LPBK_MASTER = "0b000000000000000000"; + parameter COEF_LPBK_SLAVE = "0b000000000000000000"; + parameter COEF0_POST = "0b000101"; + parameter COEF0_POST_CURSOR = "0b000000"; + parameter COEF0_PRE = "0b000000"; + parameter COEF0_PRE_CURSOR = "0b000000"; + parameter COEF1_POST = "0b000011"; + parameter COEF1_POST_CURSOR = "0b000000"; + parameter COEF1_PRE = "0b000000"; + parameter COEF1_PRE_CURSOR = "0b000000"; + parameter COEF10_POST = "0b000111"; + parameter COEF10_PRE = "0b000000"; + parameter COEF2_POST = "0b000100"; + parameter COEF2_POST_CURSOR = "0b000000"; + parameter COEF2_PRE = "0b000000"; + parameter COEF2_PRE_CURSOR = "0b000000"; + parameter COEF3_POST = "0b000010"; + parameter COEF3_POST_CURSOR = "0b000000"; + parameter COEF3_PRE = "0b000000"; + parameter COEF3_PRE_CURSOR = "0b000000"; + parameter COEF4_POST = "0b000000"; + parameter COEF4_PRE = "0b000000"; + parameter COEF5_POST = "0b000000"; + parameter COEF5_PRE = "0b000001"; + parameter COEF6_POST = "0b000000"; + parameter COEF6_PRE = "0b000010"; + parameter COEF7_POST = "0b000100"; + parameter COEF7_PRE = "0b000011"; + parameter COEF8_POST = "0b000011"; + parameter COEF8_PRE = "0b000010"; + parameter COEF9_POST = "0b000000"; + parameter COEF9_PRE = "0b000011"; + parameter COMP_128_SUPPORTED = "ENABLED"; + parameter COMP_32_SUPPORTED = "ENABLED"; + parameter COMP_64_SUPPORTED = "ENABLED"; + parameter COMPLETE = "DISABLED"; + parameter CONV_METHOD = "COMPUTE_PCIE_SPEC"; + parameter CORE_BYPASS = "NORMAL"; + parameter CORE_EN = "ENABLED"; + parameter COUNT_ACK_TO_NAK = "0b00000000"; + parameter CPL_TIMEOUT_DISABLE_SUPPORTED = "SUPPORTED"; + parameter CPL_TIMEOUT_RANGES_SUPPORTED = "NOT_SUPPORTED"; + parameter CRS_ENABLE = "DISABLED"; + parameter CSTAT_DATA_SCALE = "UNKNOWN_SCALE"; + parameter CSTAT_DATA_SELECT = "D0_POWER_CONSUMED"; + parameter CTLE_SETTLE = "0b100"; + parameter CTLEBIAS_1 = "0b1000"; + parameter ATXICP_RATE2 = "0b100"; + parameter CTLEBYPASS = "DISABLED"; + parameter CUR_FOM = "NUMBER_OF_CLOCK"; + parameter CUR_FOM_AVG = "0b101"; + parameter CUST_AUTO = "DISABLED"; + parameter CUST_CHK = "SET"; + parameter CUST_SEL = "DISABLED"; + parameter CUST_SKIP = "DISABLED"; + parameter CUST_TYP = "0b000"; + parameter CUSTOM_PATTERN = "0b00000000000000000000000000000000000000000000000000000000000000000000000000000000"; + parameter D1_SUPPORT = "SUPPORTED"; + parameter D2_SUPPORT = "SUPPORTED"; + parameter DATA_INJECT = "0b00000000000000000000000000000000"; + parameter DATA_PM = "0b00000000"; + parameter DEEMPH_5G_3_5DB_6DB_N = "6DB"; + parameter DEEMPH_5G_ENABLE = "DISABLED"; + parameter DEEMPH_LPBK_MASTER = "6P0DB"; + parameter DEEMPH_LPBK_SLAVE = "6P0DB"; + parameter DEVICE_ID_ID1A = "0b1110000000000100"; + parameter DEVICE_ID_ID1B = "0b1110000000000100"; + parameter DEVICE_ID_ID1C = "0b1110000000000100"; + parameter DEVICE_ID_ID1D = "0b1110000000000100"; + parameter DEVICE_PORT_TYPE = "PCIE_ENDPOINT"; + parameter DFE_BIAS = "0b0001"; + parameter DFE_PWDN = "DISABLED"; + parameter DIR_PRE_GAIN = "0b00"; + parameter DIR_PST_GAIN = "0b01"; + parameter DIS_ARI_CAP = "ENABLED"; + parameter DIS_CSR_RST = "DISABLED"; + parameter DIS_INTERRUPT = "ENABLED"; + parameter DIS_INTERRUPT_B = "ENABLED"; + parameter DIS_INTERRUPT_C = "ENABLED"; + parameter DIS_INTERRUPT_D = "ENABLED"; + parameter DIS_MSI_CAP = "ENABLED"; + parameter DIS_MSI_CAP_B = "ENABLED"; + parameter DIS_MSI_CAP_C = "ENABLED"; + parameter DIS_MSI_CAP_D = "ENABLED"; + parameter DIS_MSIX_CAP = "ENABLED"; + parameter DIS_MSIX_CAP_B = "ENABLED"; + parameter DIS_MSIX_CAP_C = "ENABLED"; + parameter DIS_MSIX_CAP_D = "ENABLED"; + parameter DISABLE_FLR_CAPABILITY = "ENABLED"; + parameter DLLP_CRC_ERR_ENABLE = "DISABLED"; + parameter DLLP_CRC_ERR_RATE = "0b000000000000"; + parameter DLLP_INJECT_ENABLE = "DISABLED"; + parameter DOUBLE_TX_DATA_VALID = "ONE_CLK_EVERY_64_CLKS"; + parameter DOWNSTREAM_EQ_SKIP_PHASE_2_3 = "NORMAL_OPERATION"; + parameter DS_DRIVE_CLKREQ = "ENABLED"; + parameter DS_PORT_RX_PRESET_HINT = "0b001"; + parameter DS_PORT_TX_PRESET = "0b0011"; + parameter DS_US_N_PORTTYPE = "UPSTREAM"; + parameter DSI = "NO_DSI_NECESSARY"; + parameter DSP_DIR = "ANALYSIS_OF_DATA_BY_DSP"; + parameter DSPDIR_PRESGN = "0b11110000"; + parameter DSPDIR_PREVAL = "0b00011000"; + parameter DSPDIR_PSTSGN0 = "0b11111111"; + parameter DSPDIR_PSTSGN1 = "0b00000000"; + parameter DSPDIR_PSTVAL0 = "0b00000010"; + parameter DSPDIR_PSTVAL1 = "0b01000000"; + parameter EARLY_RX_EVAL = "RX_SIGNAL_AFTER_TS1"; + parameter ECRC_GEN_CHK_CAPABLE = "SUPPORTED"; + parameter EFF_LPBK = "PASSED"; + parameter EI4 = "EI_IV"; + parameter EM_INTERLOCK_PRESENT = "NOT_SUPPORTED"; + parameter EN = "DISABLED"; + parameter EN_ACK_TO_DIV = "ACK_SPEC"; + parameter EN_ACK_TO_NAK = "DO_NOTHING"; + parameter EN_ACS_VIOLATION = "DISABLED"; + parameter EN_ASPM_L0S = "ENABLED"; + parameter EN_ASPM_L1 = "ENABLED"; + parameter EN_ATOMIC_OP_CAP = "ENABLED"; + parameter EN_ATOMICOP_EGRESS_BLOCKED = "DISABLED"; + parameter EN_ATS_CAP = "ENABLED"; + parameter EN_BDGT_CAP = "DISABLED"; + parameter EN_CAP = "ENABLED"; + parameter EN_CAP_B = "ENABLED"; + parameter EN_CAP_C = "ENABLED"; + parameter EN_CAP_D = "ENABLED"; + parameter EN_COMPLETER_ABORT = "DISABLED"; + parameter EN_COMPLETION_TIMEOUT = "ENABLED"; + parameter EN_CORR_INTERNAL_ERROR = "DISABLED"; + parameter EN_DPA_CAP = "DISABLED"; + parameter EN_DRCT_SCR_OFF = "OTHERWISE"; + parameter EN_DRCT_TO_LPBK = "OTHERWISE"; + parameter EN_EQTX_OVERRIDE = "PIPE_LOCAL_FS_AND_PIPE_LOCAL_LF"; + parameter EN_FORCE_SCR_OFF_FAST = "OTHERWISE"; + parameter EN_L1 = "ENABLED"; + parameter EN_L1PMSS_CAP = "ENABLED"; + parameter EN_L2 = "ENABLED"; + parameter EN_LPBK_ERR_RST = "MASTER_LPBK_INCREMENT"; + parameter EN_LTR_CAP = "ENABLED"; + parameter EN_MC_BLOCKED_TLP = "DISABLED"; + parameter EN_NWL_VSEC_CAP = "ENABLED"; + parameter EN_PORT_DIS = "DISABLED"; + parameter EN_PORT_INTLEG = "ENABLED"; + parameter EN_RBAR_CAP_A = "ENABLED"; + parameter EN_RBAR_CAP_B = "ENABLED"; + parameter EN_RBAR_CAP_C = "ENABLED"; + parameter EN_RBAR_CAP_D = "ENABLED"; + parameter EN_RECEIVER_OVERFLOW = "DISABLED"; + parameter EN_SELF_XLINK = "OTHERWISE"; + parameter EN_SURPRISE_DOWN_ERROR = "DISABLED"; + parameter EN_TLP_PREFIX_BLOCKED = "DISABLED"; + parameter EN_UCORR_INTERNAL_ERROR = "DISABLED"; + parameter EN_USER_WRITE = "READ_WRITE_ACCESS"; + parameter END_END_PREFIXES_SUPPORTED = "NOT_SUPPORTED"; + parameter END_ON_HOLD = "YES_EXIT_ON_HOLD"; + parameter ENDCALIB_MAX = "0b10000100"; + parameter ENDPOINT_L0S_ACCEPTABLE_LATENCY = "MAX_64_NS"; + parameter ENDPOINT_L1_ACCEPTABLE_LATENCY = "MAX_1_US"; + parameter ENTRY_TIME_ASPM_L0S = "0b0000000000000000"; + parameter ENTRY_TIME_ASPM_L1 = "0b0000000000000000"; + parameter EOM_TIME = "0b0000000000000000"; + parameter EOM0DIR = "SELECT_DIR_1"; + parameter EOM1DIR = "SELECT_DIR_0"; + parameter EOMCTRL0_LOW = "DISABLED"; + parameter EOMDIVDIS = "DISABLED"; + parameter EOMMODE = "0b00"; + parameter EOMRDSEL = "DISABLED"; + parameter EOMSTART = "DISABLED"; + parameter EOMX = "0b000000"; + parameter EOMX_UPDATE_CNT_VALUE = "0b0011111"; + parameter EOMY = "0b00000000"; + parameter ERRCNT_DEC = "0b00100000"; + parameter ERRCNT_THR = "0b1000"; + parameter ES_PWDN = "DISABLED"; + parameter EVAL_RST = "DISABLED"; + parameter EXCLUDE_L0 = "INCLUDE"; + parameter EXCLUDE_CFG_COMPLETE = "INCLUDE"; + parameter EXCLUDE_CFG_IDLE = "INCLUDE"; + parameter EXCLUDE_LOOPBACK_MASTER = "INCLUDE"; + parameter EXCLUDE_REC_IDLE = "INCLUDE"; + parameter EXCLUDE_REC_RCVR_CFG = "INCLUDE"; + parameter EXIT_DIRECT_TO_DETECT = "DO_NOT_EXIT_TO_DETECT"; + parameter EXT_CONTROL = "DISABLED"; + parameter EXTENDED_TAG_FIELD_EN_DEFAULT = "EIGHT_BIT"; + parameter EXTENDED_TAG_FIELD_SUPPORTED = "EIGHT_BIT"; + parameter F_ARXCTLEDIR = "IGNORED"; + parameter F_ARXCTLENULL = "0b0000"; + parameter F_ARXDMDIR = "DISABLED"; + parameter F_ARXDMNULL = "0b00000"; + parameter F_ARXEOMDIR = "IGNORED"; + parameter F_ARXEOMNULL = "0b00000"; + parameter F_ARXESDIR = "IGNORED"; + parameter F_ARXESNULL = "0b00000"; + parameter F_ARXTDIR = "IGNORED"; + parameter F_ARXTNULL = "0b00000"; + parameter F_ASCHCAL = "IGNORED"; + parameter F_ASCHDIR = "IGNORED"; + parameter F_ASCHNULL = "0b0000"; + parameter FAIL_LIMIT_ERR = "RXEQ_NOT_FAIL"; + parameter FAST = "L0"; + parameter FC_UPDATE_TIMER_DISABLE = "ENABLED"; + parameter FC_UPDATE_TIMER_DIV = "PCIE_REC_VALUES"; + parameter FILTER = "0b1001"; + parameter FINE_GAIN = "DISABLED"; + parameter FOM_COMPARE = "0b00000000"; + parameter FOM_HIRES = "DISABLED"; + parameter FOM_ITERCNT = "0b101"; + parameter FOM_THR = "0b0100"; + parameter FORCE_ATXDRA = "0b000000000000000000000"; + parameter FORCE_ATXDRP = "0b000000000000000000000"; + parameter FORCE_ATXDRR = "0b000000000000000000000"; + parameter FORCE_ATXDRT = "0b000000000000000000000"; + parameter FORCE_DIR_RSLT = "0b000000"; + parameter FORCE_FOM_RSLT = "0b00000000"; + parameter FORCE_IDLE = "DISABLED"; + parameter FORCE_RX_DETECT = "DISABLED"; + parameter FORCE_SIGNAL = "DISABLED"; + parameter FREQ_LOCK = "DISABLED"; + parameter FS = "0b110000"; + parameter GAIN_TIMER1 = "0b0101"; + parameter GEN12_ENA_POST_A0 = "DISABLED"; + parameter GEN12_ENA_POST_A1A2 = "DISABLED"; + parameter GEN12_ENA_PREA0 = "DISABLED"; + parameter GEN3_ENA_POST_A0 = "ENABLED"; + parameter GEN3_ENA_POST_A1A2 = "ENABLED"; + parameter GEN3_ENA_PREA0 = "ENABLED"; + parameter GLOBAL_INVAL_SUPPORT = "ENABLED"; + parameter HINT = "0b000"; + parameter HINT0_3DB = "ENABLED"; + parameter HINT0_A0GAIN = "0b111"; + parameter HINT0_A2GAIN = "0b111"; + parameter HINT1_3DB = "ENABLED"; + parameter HINT1_A0GAIN = "0b011"; + parameter HINT1_A2GAIN = "0b101"; + parameter HINT2_3DB = "ENABLED"; + parameter HINT2_A0GAIN = "0b011"; + parameter HINT2_A2GAIN = "0b111"; + parameter HINT3_3DB = "ENABLED"; + parameter HINT3_A0GAIN = "0b000"; + parameter HINT3_A2GAIN = "0b111"; + parameter HINT4_3DB = "DISABLED"; + parameter HINT4_A0GAIN = "0b111"; + parameter HINT4_A2GAIN = "0b111"; + parameter HINT5_3DB = "DISABLED"; + parameter HINT5_A0GAIN = "0b011"; + parameter HINT5_A2GAIN = "0b101"; + parameter HINT6_3DB = "DISABLED"; + parameter HINT6_A0GAIN = "0b011"; + parameter HINT6_A2GAIN = "0b111"; + parameter HINT7_3DB = "DISABLED"; + parameter HINT7_A0GAIN = "0b000"; + parameter HINT7_A2GAIN = "0b111"; + parameter HINT7_OVR = "DISABLED"; + parameter HLD_RST = "WRITE_1"; + parameter HOT_PLUG_CAPABLE = "NOT_SUPPORTED"; + parameter HOT_PLUG_SURPRISE = "NOT_POSSIBLE"; + parameter ID_DS_PORT = "0b0000000000000000"; + parameter ID_NWL_VSEC_CAP = "0b0000000000000001"; + parameter IGNORE_ECRC = "DISABLED"; + parameter IGNORE_POISON = "ENABLED"; + parameter INDICATOR = "0b00000000000000000000000000000000"; + parameter INHIBIT = "PERFORM_RECEIVER_DETECTION"; + parameter INJECT_DATA_ERROR_0 = "DISABLED"; + parameter INJECT_DATA_ERROR_1 = "DISABLED"; + parameter INJECT_DATA_ERROR_2 = "DISABLED"; + parameter INJECT_DATA_ERROR_3 = "DISABLED"; + parameter INJECT_DATA_ERROR_EN = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_0 = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_1 = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_2 = "DISABLED"; + parameter INJECT_ERR_LANE_SELECT_3 = "DISABLED"; + parameter INJECT_RX_1BIT_DATA_ERR = "DISABLED"; + parameter INJECT_RX_2BIT_DATA_ERR = "DISABLED"; + parameter INJECT_RX_SKP_ERR = "DISABLED"; + parameter INJECT_RX_VALID_ERR = "DISABLED"; + parameter INT_CLR = "DISABLED"; + parameter INT_EN = "DISABLED"; + parameter INTERRUPT_MESSAGE_NUMBER = "0b00000"; + parameter INVAL_Q_DEPTH = "0b00000"; + parameter ITERATION_MAX = "0b000000"; + parameter L1_ENTER_PLL_RESET_TIME = "0b100"; + parameter L1_EXIT_PLL_LOCK_TIME = "0b01110"; + parameter L1PM_SUPPORTED = "SUPPORTED"; + parameter L2_D3HOT_ENABLE = "DISABLED"; + parameter LANE_SELECT = "0b0000"; + parameter LF = "0b001000"; + parameter LF_PHY = "0b001010"; + parameter LINK_LANE = "ENABLED"; + parameter LPBK_EN = "DISABLED"; + parameter LW_START_UPDN_ACK_EN = "DISABLED"; + parameter LW_START_UPDN_COUNT = "0b000011111010"; + parameter LW_START_UPDN_EIE_EN = "DISABLED"; + parameter LW_START_UPDN_EN_DIR_DS = "DO_NOT_ASSERT"; + parameter LW_START_UPDN_END_DELAY = "0b1001"; + parameter LW_START_UPDN_RATE_EN_16G = "DISABLED"; + parameter LW_START_UPDN_RATE_EN_2P5G = "ENABLED"; + parameter LW_START_UPDN_RATE_EN_5G = "ENABLED"; + parameter LW_START_UPDN_RATE_EN_8G = "ENABLED"; + parameter LW_START_UPDN_START_DELAY = "0b1000"; + parameter LW_START_UPDN_TIMER_EN = "DISABLED"; + parameter MARGIN_ENABLE = "PCIE_SPEC"; + parameter MARGIN_VALUE = "0b000"; + parameter MASK_0 = "SKIP_RCVR_DETECTION"; + parameter MASK_1 = "SKIP_RCVR_DETECTION"; + parameter MASK_2 = "SKIP_RCVR_DETECTION"; + parameter MASK_3 = "SKIP_RCVR_DETECTION"; + parameter MAX_LINK_WIDTH = "1_LANE"; + parameter MAX_SPEED = "8G"; + parameter MAX_VAR = "0b00100"; + parameter MERGE_LMMI_RDATA = "DISABLED"; + parameter METHOD_FMERIT_CTRL = "STEP_PCIE_TX_PRESETS"; + parameter METHOD_TX_CRED_CLEANUP = "HEADER"; + parameter MGMT_INTLEG = "0b0000"; + parameter MGMT_LTSSM_DIS = "DISABLED"; + parameter MID_VALUE_20B = "0b010100"; + parameter MID_VALUE_GEN3 = "0b001110"; + parameter MIN_SPEED = "2P5G"; + parameter MIN_TIME = "0_MS"; + parameter MIN_TIME_CFG = "4US"; + parameter MIX_DIR = "DISABLED"; + parameter MODE_BFF = "RESTART"; + parameter MRL_SENSOR_PRESENT = "NOT_SUPPORTED"; + parameter MULT_ENABLE = "RECOMMENDED_VALUES"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_A = "EIGHT"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_B = "EIGHT"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_C = "EIGHT"; + parameter MULT_MESSAGE_CAPABLE_MSICAP_D = "EIGHT"; + parameter NFTS = "0b11111111"; + parameter NO_COMMAND_COMPLETED_SUPPORT = "SW_NOTIF_PROVIDED"; + parameter NO_FCMP = "DISABLED"; + parameter NO_REMOTE_CHANGE = "DISABLED"; + parameter NO_TX_IDLE_DELAY = "DATA_VALID_GAP"; + parameter NUM_LANES = "1_LANE"; + parameter NUMBER_DSLINK = "0b00000"; + parameter NUMHI_A = "0b00000000000000000000000000000000"; + parameter NUMHI_B = "0b00000000000000000000000000000000"; + parameter NUMHI_C = "0b00000000000000000000000000000000"; + parameter NUMHI_D = "0b00000000000000000000000000000000"; + parameter NUMHOLD = "SINGLE_HOLD_RESPONSE"; + parameter NUMLO_A = "0b00000000000000000000000000000000"; + parameter NUMLO_B = "0b00000000000000000000000000000000"; + parameter NUMLO_C = "0b00000000000000000000000000000000"; + parameter NUMLO_D = "0b00000000000000000000000000000000"; + parameter OBFF_SUPPORTED = "NOT_SUPPORTED"; + parameter OFFSET_MSIX_PBA_A = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_PBA_B = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_PBA_C = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_PBA_D = "0b00000000000000000111000000000"; + parameter OFFSET_MSIX_TABLE_A = "0b00000000000000000110000000000"; + parameter OFFSET_MSIX_TABLE_B = "0b00000000000000000110000000000"; + parameter OFFSET_MSIX_TABLE_C = "0b00000000000000000110000000000"; + parameter OFFSET_MSIX_TABLE_D = "0b00000000000000000110000000000"; + parameter OVER_CTLE = "DISABLED"; + parameter OVER_RX = "DISABLED"; + parameter OVER_RXDM = "DISABLED"; + parameter OVER_RXDP = "DISABLED"; + parameter OVER_RXES = "DISABLED"; + parameter OVER_RXT = "DISABLED"; + parameter OVER_SCH = "DISABLED"; + parameter OVER_TX = "DISABLED"; + parameter OVERRIDE = "DISABLED"; + parameter OVR_CDR = "DISABLED"; + parameter OVR_DIR = "DISABLED"; + parameter OVR_FOM = "DISABLED"; + parameter OVR_GAIN3DB = "ENABLED"; + parameter OVR_HINT3DB = "ENABLED"; + parameter P_CLK_PERIOD = "0b0000111110100000"; + parameter PAR_LPBK = "DISABLED"; + parameter PAS = "10X"; + parameter PATTERN_0 = "UNSCRAMBLED"; + parameter PATTERN_1 = "UNSCRAMBLED"; + parameter PATTERN_2 = "UNSCRAMBLED"; + parameter PCIPM_L1_1_SUPPORTED = "SUPPORTED"; + parameter PCIPM_L1_2_SUPPORTED = "SUPPORTED"; + parameter PERIOD_SRIS_128B130B = "0b000000"; + parameter PERIOD_SRIS_8B10B = "0b00000000"; + parameter PERIOD_SRNS_128B130B = "0b00000000"; + parameter PERIOD_SRNS_8B10B = "0b00000000"; + parameter PHANTOM_FUNCTIONS_SUPPORTED = "NO_FUNCTION_BITS"; + parameter PHYSICAL_SLOT_NUMBER = "0b0000000000001"; + parameter PIN_INTERRUPT_A = "INTA"; + parameter PIN_INTERRUPT_B = "INTA"; + parameter PIN_INTERRUPT_C = "INTA"; + parameter PIN_INTERRUPT_D = "INTA"; + parameter PIPE_TX_SWING = "FULL_SWING"; + parameter PLESIO_LPBK = "DISABLED"; + parameter PM_REDUCE_TIMEOUTS = "DISABLED"; + parameter PMA_DRIVEN_MODE = "PCS_DRIVEN"; + parameter PMCSR_B2_B3_SUPPORT = "DISABLED"; + parameter PMCSR_BUS_P_C_EN = "DISABLED"; + parameter PME_CLOCK = "DISABLED"; + parameter PME_SUPPORT = "0b11111"; + parameter PMFF_ALL = "DISABLED"; + parameter PORT_CM_RESTORE_TIME = "0b00000000"; + parameter PORT_NUMBER = "0b00000000"; + parameter PORT_TPOWER_ON_SCALE = "2_US"; + parameter PORT_TPOWER_ON_VALUE = "0b00000"; + parameter POST = "0b000000"; + parameter POST_A0COEF = "0b001"; + parameter POST_A1COEF = "0b001"; + parameter POST_A2COEF = "0b001"; + parameter POST_CURSOR_LIMIT = "0b100000"; + parameter POST_CURSOR_STEP_SIZE = "0b001000"; + parameter POST_ITERCNT = "0b100"; + parameter POST_STEP = "STEP_SIZE_4"; + parameter POWER_CONTROLLER_PRESENT = "NOT_SUPPORTED"; + parameter POWER_INDICATOR_PRESENT = "NOT_SUPPORTED"; + parameter POWER_REQUIRED = "AUX_POWER_NOT_REQUIRED"; + parameter PRBS_CHK = "DISABLED"; + parameter PRBS_GEN = "DISABLED"; + parameter PRBS_TYP = "PRBS7"; + parameter PRE = "0b000000"; + parameter PRE_A0COEF = "0b101"; + parameter PRE_A1COEF = "0b101"; + parameter PRE_A2COEF = "0b101"; + parameter PRE_CURSOR_LIMIT = "0b010000"; + parameter PRE_CURSOR_STEP_SIZE = "0b000100"; + parameter PRE_FOM = "ENABLED"; + parameter PRE_FOM_AVG = "0b100"; + parameter PRE_ITERCNT = "0b100"; + parameter PRE_RXEQ_TIMER = "0b00010100"; + parameter PRE_STEP = "STEP_SIZE_2"; + parameter PRESET_COUNT_INI = "0b0000"; + parameter PRESET_EN_LPBK_MASTER = "OTHERWISE"; + parameter PRESET_EN_LPBK_SLAVE = "OTHERWISE"; + parameter PRESET_ENABLE = "NORMAL_OP"; + parameter PRESET_EQTX_FORCE = "0b0000"; + parameter PRESET_LPBK_MASTER = "0b0000"; + parameter PRESET_LPBK_SLAVE_0 = "OTHERWISE"; + parameter PRESET_LPBK_SLAVE_1 = "OTHERWISE"; + parameter PRESET_LPBK_SLAVE_2 = "OTHERWISE"; + parameter PRESET_LPBK_SLAVE_3 = "OTHERWISE"; + parameter PRESET_REJECT = "0b00000000000"; + parameter PRESET0_POSTCURSOR = "0b1000"; + parameter PRESET0_PRECURSOR = "0b0000"; + parameter PRESET1_POSTCURSOR = "0b0101"; + parameter PRESET1_PRECURSOR = "0b0000"; + parameter PRESET10_POSTCURSOR = "0b1010"; + parameter PRESET10_PRECURSOR = "0b0000"; + parameter PRESET2_POSTCURSOR = "0b0110"; + parameter PRESET2_PRECURSOR = "0b0000"; + parameter PRESET3_POSTCURSOR = "0b0100"; + parameter PRESET3_PRECURSOR = "0b0000"; + parameter PRESET4_POSTCURSOR = "0b0000"; + parameter PRESET4_PRECURSOR = "0b0000"; + parameter PRESET5_POSTCURSOR = "0b0000"; + parameter PRESET5_PRECURSOR = "0b0011"; + parameter PRESET6_POSTCURSOR = "0b0000"; + parameter PRESET6_PRECURSOR = "0b0100"; + parameter PRESET7_POSTCURSOR = "0b0110"; + parameter PRESET7_PRECURSOR = "0b0011"; + parameter PRESET8_POSTCURSOR = "0b0100"; + parameter PRESET8_PRECURSOR = "0b0100"; + parameter PRESET9_POSTCURSOR = "0b0000"; + parameter PRESET9_PRECURSOR = "0b0101"; + parameter PS_REENTRY_TIME = "0b00000000"; + parameter RATE = "2P5G"; + parameter RATE_ENABLE = "INITIAL_SPEED_CHANGES"; + parameter RCB = "DISABLED"; + parameter REC_SPD_INFER_EQ_PH0123 = "EXCLUDE_TIME_SPENT"; + parameter REC_SPD_INFER_RCVR_CFG = "EXCLUDE_TIME_SPENT"; + parameter REC_SPD_INFER_RCVR_LOCK = "EXCLUDE_TIME_SPENT"; + parameter DIS_FUNC_B = "ENABLED"; + parameter DIS_FUNC_C = "ENABLED"; + parameter DIS_FUNC_D = "ENABLED"; + parameter REDUCE_TIMEOUTS_LTSSMSIM = "DISABLED"; + parameter REDUCE_TIMEOUTS_SIM = "DISABLED"; + parameter REDUCE_TS1 = "DISABLED"; + parameter REENTRY_DISABLE = "ENABLED"; + parameter REENTRY_TIME = "0b00000000000000"; + parameter REQ_FEEDBACK = "0b00000000"; + parameter RESET_EIEOS_INTERVAL_COUNT = "DISABLED"; + parameter REVISION_ID_ID3A = "0b00000100"; + parameter REVISION_ID_ID3B = "0b00000100"; + parameter REVISION_ID_ID3C = "0b00000100"; + parameter REVISION_ID_ID3D = "0b00000100"; + parameter RL1 = "0b0011"; + parameter RL2 = "0b0101"; + parameter RL3 = "0b0011"; + parameter ROUTING_SUPPORTED = "DISABLED"; + parameter RP_COMPLETER_EN = "DISABLED"; + parameter RSTCDR_ERR = "ENABLED"; + parameter RSTCDR_FRQ = "ENABLED"; + parameter RSTCDR_IDL = "DISABLED"; + parameter RX_BYPASS_DECODE_EN = "ENABLED"; + parameter RX_BYPASS_MSG_DEC = "NORMAL_OPERATION"; + parameter RX_CONVERT_UR_TO_CA = "NORMAL_OPERATION"; + parameter RX_D_ALLOC_C = "0b0000000001100000"; + parameter RX_D_ALLOC_N = "0b0000000000000110"; + parameter RX_D_ALLOC_P = "0b0000000001101100"; + parameter RX_DIV_MODE1 = "0b10"; + parameter RX_DIV_MODE0 = "DIV_2"; + parameter RX_DIV_MODE2 = "0b00"; + parameter RX_DL_ACTIVE_DISABLE = "BLOCK_RECEPTION_TLP"; + parameter RX_EARLY_FORWARD_DISABLE = "FWD_RX_DATA_LL"; + parameter RX_ERR_COR = "DISABLED"; + parameter RX_ERR_UCOR = "DISABLED"; + parameter RX_FORCE_RO = "DISABLED"; + parameter RX_H_ALLOC_C = "0b000000100000"; + parameter RX_H_ALLOC_N = "0b000000001000"; + parameter RX_H_ALLOC_P = "0b000000010000"; + parameter RX_HIZ = "IGNORED"; + parameter RX_IMPED_RATIO = "0b10000000"; + parameter RX_INHIBIT_ACK_NAK = "PROCESS_RCVD_ACK"; + parameter RX_INHIBIT_TLP = "PROCESS_RCVD_TLP"; + parameter RX_LCRC_INJECT_EN = "DO_NOT_INJECT_ERROR"; + parameter RX_MALF_INJECT_EN = "DO_NOT_INJECT_ERROR"; + parameter RX_POLINV = "NORMAL"; + parameter RX_PRIORITY = "DISABLED"; + parameter RX_PRIORITY_N_STARVE_THRESH = "0b00010000"; + parameter RX_PRIORITY_P_STARVE_THRESH = "0b00010000"; + parameter RX_PWRDN = "IGNORED"; + parameter RX_TLP_VALID = "DISABLED"; + parameter RXEQ_ALGO = "0b111"; + parameter RXEQ_ENABLE = "0b100"; + parameter RXEQ_EVAL_MAX = "0b11111111"; + parameter RXEQ_MANUAL = "DISABLED"; + parameter RXEQ_STATE = "0b0000"; + parameter RXF_A = "0b0100"; + parameter RXF_B = "0b0100"; + parameter RXF_C = "0b0100"; + parameter RXHF_CLKDN = "ENABLED"; + parameter RXIDLE_MAX = "0b1111"; + parameter RXIDLE_MAX2 = "0b0000010000000000"; + parameter RXIDLE_MSB = "0b11"; + parameter RXM_A = "0b10"; + parameter RXM_B = "0b01"; + parameter RXM_C = "0b00"; + parameter RXN_A = "0b00100"; + parameter RXN_B = "0b01001"; + parameter RXN_C = "0b01111"; + parameter RXOFF_SETTLE_MAX = "0b011"; + parameter RXOFF_STABLE_MAX = "0b10000"; + parameter RXPLLINIT = "DISABLED"; + parameter RXPLLRST = "SET"; + parameter SELECT_DIR_FOM_N = "FME_METHOD"; + parameter SELECTABLE_DEEMPHASIS = "6P0DB"; + parameter SEQ_NUM = "0b000000000000"; + parameter SIGNAL_DETECT_THRESHOLD = "125_MV"; + parameter SIZE_CFG0_A = "0b00000"; + parameter SIZE_CFG0_B = "0b00000"; + parameter SIZE_CFG0_C = "0b00000"; + parameter SIZE_CFG0_D = "0b00000"; + parameter SIZE_CFG1_A = "0b00000"; + parameter SIZE_CFG1_B = "0b00000"; + parameter SIZE_CFG1_C = "0b00000"; + parameter SIZE_CFG1_D = "0b00000"; + parameter SIZE_CFG2_A = "0b00000"; + parameter SIZE_CFG2_B = "0b00000"; + parameter SIZE_CFG2_C = "0b00000"; + parameter SIZE_CFG2_D = "0b00000"; + parameter SIZE_CFG3_A = "0b00000"; + parameter SIZE_CFG3_B = "0b00000"; + parameter SIZE_CFG3_C = "0b00000"; + parameter SIZE_CFG3_D = "0b00000"; + parameter SIZE_CFG4_A = "0b00000"; + parameter SIZE_CFG4_B = "0b00000"; + parameter SIZE_CFG4_C = "0b00000"; + parameter SIZE_CFG4_D = "0b00000"; + parameter SIZE_CFG5_A = "0b00000"; + parameter SIZE_CFG5_B = "0b00000"; + parameter SIZE_CFG5_C = "0b00000"; + parameter SIZE_CFG5_D = "0b00000"; + parameter SKIP_FINAL_COEF_CHECK = "DISABLED"; + parameter SLOT_CLOCK_CONFIGURATION = "REFCLK_BY_SLOT"; + parameter SLOT_IMPLEMENTED = "UNCONNECTED"; + parameter SLOT_POWER_LIMIT_SCALE = "0b00"; + parameter SLOT_POWER_LIMIT_VALUE = "0b00001010"; + parameter SPEED_LPBK_CTRL = "2P5G"; + parameter START_PRESET = "PRESET_VALUE"; + parameter START_REMOTE_ADV = "OTHERWISE"; + parameter STATE_DATA_N = "USE_RX_DATA_OBSERVATION"; + parameter STEP_SELECT = "0b00000"; + parameter STP_OVERRIDE_EN = "DISABLED"; + parameter STP_OVERRIDE_LEN = "0b00000000000"; + parameter STP_OVERRIDE_NEW_LEN = "0b00000000000"; + parameter SUBSTATE_MAX = "0b00000"; + parameter SUBSYSTEM_ID_ID2A = "0b1110000000000100"; + parameter SUBSYSTEM_ID_ID2B = "0b1110000000000100"; + parameter SUBSYSTEM_ID_ID2C = "0b1110000000000100"; + parameter SUBSYSTEM_ID_ID2D = "0b1110000000000100"; + parameter SUBSYSTEM_VENDOR_ID_ID2A = "0b0001100110101010"; + parameter SUBSYSTEM_VENDOR_ID_ID2B = "0b0001100110101010"; + parameter SUBSYSTEM_VENDOR_ID_ID2C = "0b0001100110101010"; + parameter SUBSYSTEM_VENDOR_ID_ID2D = "0b0001100110101010"; + parameter SUPP_SIZE_CFG0_A = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG0_B = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG0_C = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG0_D = "0b00000000000000001111"; + parameter SUPP_SIZE_CFG1_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG1_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG1_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG1_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG2_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG3_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG4_D = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_A = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_B = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_C = "0b00000000000000000000"; + parameter SUPP_SIZE_CFG5_D = "0b00000000000000000000"; + parameter SYS_ALLOC = "PWR_BUDGET_CAP_VALUES"; + parameter T0_RX_BYPASS_MSG_DEC = "NORMAL_OPERATION"; + parameter TABLE_SIZE_MSIXCAP_A = "0b00000000111"; + parameter TABLE_SIZE_MSIXCAP_B = "0b00000000111"; + parameter TABLE_SIZE_MSIXCAP_C = "0b00000000111"; + parameter TABLE_SIZE_MSIXCAP_D = "0b00000000111"; + parameter TARGET_LINK_SPEED = "8G"; + parameter TARGET_ONLY = "DISABLED"; + parameter TD1_MEANS_ADD_HAS_N = "ECRC_CONTAINED"; + parameter TIMEOUT_THRESHOLD_PME = "0b000000000000"; + parameter TIMEOUT_THRESHOLD_PME_TO_ACK_DS = "0b00000000"; + parameter TIMER = "0b00000000"; + parameter TLP_LCRC_ERR_ENABLE = "DISABLED"; + parameter TLP_LCRC_ERR_RATE = "0b000"; + parameter TLP_SEQ_ERR_ENABLE = "DISABLED"; + parameter TLUNIT = "1_MS"; + parameter TO_EXTEND = "0b01111111"; + parameter TRNG_A0COEF = "0b101"; + parameter TRNG_A1COEF = "0b101"; + parameter TRNG_A2COEF = "0b101"; + parameter TRNG_FAST = "DISABLED"; + parameter TRNG_ITERCNT = "0b100"; + parameter TRNG_RXEQ_TIMER = "0b00100000"; + parameter TS1_ACK_BLOCK_USE_PRESET = "FORCED_TO_ZERO"; + parameter TS1_ACK_DELAY = "0b00011111"; + parameter TS1_ACK_MASK_USE_PRESET = "IGNORES_USE_PRESET"; + parameter TX_AMP_RATIO_MARGIN0_FULL = "0b10000000"; + parameter TX_AMP_RATIO_MARGIN0_HALF = "0b01010000"; + parameter TX_AMP_RATIO_MARGIN1_FULL = "0b01111000"; + parameter TX_AMP_RATIO_MARGIN1_HALF = "0b01011000"; + parameter TX_AMP_RATIO_MARGIN2_FULL = "0b01101000"; + parameter TX_AMP_RATIO_MARGIN2_HALF = "0b01001000"; + parameter TX_AMP_RATIO_MARGIN3_FULL = "0b01100000"; + parameter TX_AMP_RATIO_MARGIN3_HALF = "0b01000000"; + parameter TX_AMP_RATIO_MARGIN4_FULL = "0b01011000"; + parameter TX_AMP_RATIO_MARGIN4_HALF = "0b00111000"; + parameter TX_AMP_RATIO_MARGIN5_FULL = "0b01010000"; + parameter TX_AMP_RATIO_MARGIN5_HALF = "0b00110000"; + parameter TX_AMP_RATIO_MARGIN6_FULL = "0b01001000"; + parameter TX_AMP_RATIO_MARGIN6_HALF = "0b00101000"; + parameter TX_AMP_RATIO_MARGIN7_FULL = "0b01000000"; + parameter TX_AMP_RATIO_MARGIN7_HALF = "0b00100000"; + parameter TX_BYPASS_DECODE_EN = "ENABLED"; + parameter TX_BYPASS_MSG_DEC = "NORMAL_OPERATION"; + parameter TX_COMP_RECEIVE = "DOES_NOT_ASSERT"; + parameter TX_CONVERT_UR_TO_CA = "NORMAL_OPERATION"; + parameter TX_D_ALLOC_C = "0b0000000001100000"; + parameter TX_D_ALLOC_N = "0b0000000000000110"; + parameter TX_D_ALLOC_P = "0b0000000001101100"; + parameter TX_DIV_MODE0 = "0b10"; + parameter TX_DIV_MODE1 = "0b10"; + parameter TX_DIV_MODE2 = "0b10"; + parameter TX_EQ_EVAL_CNT_SEL = "WAIT_8_CLKS"; + parameter TX_ERR_COR = "DISABLED"; + parameter TX_ERR_UCOR = "DISABLED"; + parameter TX_FORCE_RO = "DISABLED"; + parameter TX_GAP_INJECT_EN = "DO_NOT_INJECT_GAP"; + parameter TX_H_ALLOC_C = "0b000000100000"; + parameter TX_H_ALLOC_N = "0b000000001000"; + parameter TX_H_ALLOC_P = "0b000000010000"; + parameter TX_HIZ = "IGNORED"; + parameter TX_IMPED_RATIO = "0b10000000"; + parameter TX_PAR1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_PAR2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_PAR2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_PAR2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_POLINV = "NORMAL"; + parameter TX_PRE_RATIO = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP0_FULL = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP0_HALF = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP1_FULL = "0b00000000"; + parameter TX_PRE_RATIO_DEEMP1_HALF = "0b00000000"; + parameter TX_PRIORITY = "DISABLED"; + parameter TX_PRIORITY_N_STARVE_THRESH = "0b00010000"; + parameter TX_PRIORITY_P_STARVE_THRESH = "0b00010000"; + parameter TX_PST_RATIO = "0b00010101"; + parameter TX_PST_RATIO_DEEMP0_FULL = "0b00100000"; + parameter TX_PST_RATIO_DEEMP0_HALF = "0b00100000"; + parameter TX_PST_RATIO_DEEMP1_FULL = "0b00010101"; + parameter TX_PST_RATIO_DEEMP1_HALF = "0b00010101"; + parameter TX_QUIESCE = "DISABLED"; + parameter TX_REPLAY_ECC1_HANDLE_DISABLE = "ENABLE_CORRECTION"; + parameter TX_REPLAY_ECC1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_REPLAY_ECC1_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_REPLAY_ECC2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_REPLAY_ECC2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_REPLAY_ECC2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_REQ_EQ = "DISABLED"; + parameter TX_SELECT_RX_FEEDBACK = "REFCLK"; + parameter TX_TLP_VALID = "DISABLED"; + parameter TXF_A = "0b0100"; + parameter TXF_B = "0b0100"; + parameter TXF_C = "0b0100"; + parameter TXHF_CLKDN = "ENABLED"; + parameter TXM_A = "0b10"; + parameter TXM_B = "0b01"; + parameter TXM_C = "0b00"; + parameter TXN_A = "0b00100"; + parameter TXN_B = "0b01001"; + parameter TXN_C = "0b01111"; + parameter TXPLL_INIT = "DISABLED"; + parameter TXPLLRST = "DISABLED"; + parameter TYPE1_TYPE0_N = "ENDPOINT"; + parameter U_CLK_PERIOD = "0b0001111101000000"; + parameter US_PORT_PS_ENTRY_TIME = "0b0000000000000000"; + parameter US_PORT_RX_PRESET_HINT = "0b010"; + parameter US_PORT_TX_PRESET = "0b0100"; + parameter USE_COEF_PRE_MTHD_CTRL = "PRESET_VALUE"; + parameter USE_COEF_UPDN_CTRL = "PRESET_VALUE"; + parameter USER_AUTO_N = "AUTOMATIC_ON_RECEPTION"; + parameter VEC_MASK_CAPABLE_MSICAP_A = "ENABLED"; + parameter VEC_MASK_CAPABLE_MSICAP_B = "ENABLED"; + parameter VEC_MASK_CAPABLE_MSICAP_C = "ENABLED"; + parameter VEC_MASK_CAPABLE_MSICAP_D = "ENABLED"; + parameter VENDOR_ID_ID1A = "0b0001100110101010"; + parameter VENDOR_ID_ID1B = "0b0001100110101010"; + parameter VENDOR_ID_ID1C = "0b0001100110101010"; + parameter VENDOR_ID_ID1D = "0b0001100110101010"; + parameter VENDOR0_UR = "REPORT"; + parameter VERSION_AER_CAP = "VER_0X2"; + parameter VERSION_PM_CAP = "0b011"; + parameter XLCY0 = "0b00000000"; + parameter XLCY1 = "0b00000000"; + parameter RX_ESP_RESP_WAIT = "0b01000000"; + parameter SEL_PCLK_DIV2 = "PCLK_DIV2"; + parameter COMPLIANCE = "ENABLED"; + parameter LOOPBACK = "ENABLED"; + parameter HOT_RESET = "ENABLED"; + parameter DIS_PREVENT = "ENABLED"; + parameter MPS_VIOLATION_RX = "DISABLED"; + parameter MPS_VIOLATION_TX = "DISABLED"; + parameter EN_RX_ALLOC_SEL = "HW"; + parameter EN_TX_ALLOC_SEL = "HW"; + parameter AUX_CLK_PERIOD = "0b1111010000100100"; + parameter EN_PIPE_IF_CTRL = "DISABLED"; + parameter PIPE_PWRDN = "P1"; + parameter TX_CM_DIS = "DEASSERTED"; + parameter RX_EI_DIS = "DEASSERTED"; + parameter PCLKREQ_N = "DEASSERTED"; + parameter STS_PHY_STATUS = "DEASSERTED"; + parameter STS_PIPE_RSTN = "DEASSERTED"; + parameter LEGACY_MODE = "MATCH_TS"; + parameter OVERFLOW = "DISABLED"; + parameter DIR = "RECEIVE"; + parameter SPEED = "8G"; + parameter LANE = "0"; + parameter COEF_ENABLE_8G = "DISABLED"; + parameter PRESET_ENABLE_8G = "DISABLED"; + parameter VALUE_8G_PRE = "0b000000"; + parameter VALUE_8G_POST = "0b000000"; + parameter REQ_EQ_MAX_COUNT = "0b10"; + parameter MESO_LPBK = "DISABLED"; + parameter TX_REPLAY_ECC2_INJECT_M_1_N = "INJECT_1_ERR"; + parameter TX_REPLAY_ECC1_INJECT_M_1_N = "INJECT_1_ERR"; + parameter REDO = "DISABLED"; + parameter RX_PAR_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter RX_PAR_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter RX_ECC2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter RX_ECC2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter RX_ECC2_INJECT_M_1_N = "INJECT_1_ERR"; + parameter RX_ECC2_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter RX_ECC2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter RX_ECC1_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter RX_ECC1_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter RX_ECC1_INJECT_M_1_N = "INJECT_1_ERR"; + parameter RX_ECC1_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter RX_ECC1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter RX_ERR_PAR = "OTHERWISE"; + parameter RX_ERR_ECC2 = "OTHERWISE"; + parameter RX_ERR_ECC1 = "OTHERWISE"; + parameter TX_PAR_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_PAR_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_ECC2_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_ECC2_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_ECC2_INJECT_M_1_N = "INJECT_1_ERR"; + parameter TX_ECC2_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter TX_ECC2_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_ECC1_REPORT_DISABLE = "ENABLE_REPORTING"; + parameter TX_ECC1_HANDLE_DISABLE = "ENABLE_HANDLING"; + parameter TX_ECC1_INJECT_M_1_N = "INJECT_1_ERR"; + parameter TX_ECC1_INJECT_TYPE = "POSTED_DATA_RAM"; + parameter TX_ECC1_INJECT_EN = "DO_NOT_INJECT_ERR"; + parameter TX_ERR_PAR = "OTHERWISE"; + parameter TX_ERR_ECC2 = "OTHERWISE"; + parameter TX_ERR_ECC1 = "OTHERWISE"; + parameter MAX_PAYLOAD_SIZE_SUPPORTED = "256_BYTES"; + parameter ARXCAL_OUT = "DISABLED"; + parameter F_ARXDPDIR = "IGNORED"; + parameter IDLE_INFER_REC_RCVR_CFG = "OTHERWISE"; + parameter IDLE_INFER_LPBK_SLAVE = "OTHERWISE"; + parameter IDLE_INFER_REC_SPEED2_SUCCESS = "OTHERWISE"; + parameter IDLE_INFER_REC_SPEED2_UNSUCCESS = "OTHERWISE"; + parameter IDLE_INFER_L0_TO_REC_RCVR_LOCK = "OTHERWISE"; + parameter SPEED_CHANGE_FAIL = "OTHERWISE"; + parameter DIRECT_TO_DETECT_FAST = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_CH_BOND = "OTHERWISE"; + parameter DIRECT_TO_LPBK_ENTRY = "OTHERWISE"; + parameter DIRECT_SPEED_CHANGE = "OTHERWISE"; + parameter L0_TO_REC_RCVR_LOCK_RX_TS12 = "OTHERWISE"; + parameter L0_TO_REC_RCVR_LOCK_RX_8G_EIE = "OTHERWISE"; + parameter L0_TO_REC_RCVR_LOCK_RX_INFER = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_PHY = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_FRAME = "OTHERWISE"; + parameter DIRECT_TO_RCVRY_REPLAY = "OTHERWISE"; + parameter DIRECT_TO_HOT_RESET = "OTHERWISE"; + parameter DIRECT_TO_DISABLE = "OTHERWISE"; + parameter RX_L0S_DIRECT_TO_RCVRY = "OTHERWISE"; + parameter AUTONOMOUS_WIDTH_CHANGE = "OTHERWISE"; + parameter DIRECTED_RETRAIN_LINK = "OTHERWISE"; + parameter ERR_TX_PIPE_UNDERFLOW = "OTHERWISE"; + parameter TS2_DETECT3 = "OTHERWISE"; + parameter TS2_DETECT2 = "OTHERWISE"; + parameter TS2_DETECT1 = "OTHERWISE"; + parameter TS2_DETECT0 = "OTHERWISE"; + parameter TS1_DETECT3 = "OTHERWISE"; + parameter TS1_DETECT2 = "OTHERWISE"; + parameter TS1_DETECT1 = "OTHERWISE"; + parameter TS1_DETECT0 = "OTHERWISE"; + parameter TS2I_DETECT3 = "OTHERWISE"; + parameter TS2I_DETECT2 = "OTHERWISE"; + parameter TS2I_DETECT1 = "OTHERWISE"; + parameter TS2I_DETECT0 = "OTHERWISE"; + parameter TS1I_DETECT3 = "OTHERWISE"; + parameter TS1I_DETECT2 = "OTHERWISE"; + parameter TS1I_DETECT1 = "OTHERWISE"; + parameter TS1I_DETECT0 = "OTHERWISE"; + parameter FTS_DETECT3 = "OTHERWISE"; + parameter FTS_DETECT2 = "OTHERWISE"; + parameter FTS_DETECT1 = "OTHERWISE"; + parameter FTS_DETECT0 = "OTHERWISE"; + parameter SKP_DETECT3 = "OTHERWISE"; + parameter SKP_DETECT2 = "OTHERWISE"; + parameter SKP_DETECT1 = "OTHERWISE"; + parameter SKP_DETECT0 = "OTHERWISE"; + parameter EIE_DETECT3 = "OTHERWISE"; + parameter EIE_DETECT2 = "OTHERWISE"; + parameter EIE_DETECT1 = "OTHERWISE"; + parameter EIE_DETECT0 = "OTHERWISE"; + parameter EIOS_DETECT3 = "OTHERWISE"; + parameter EIOS_DETECT2 = "OTHERWISE"; + parameter EIOS_DETECT1 = "OTHERWISE"; + parameter EIOS_DETECT0 = "OTHERWISE"; + parameter DATA_DETECT3 = "OTHERWISE"; + parameter DATA_DETECT2 = "OTHERWISE"; + parameter DATA_DETECT1 = "OTHERWISE"; + parameter DATA_DETECT0 = "OTHERWISE"; + parameter SDS_DETECT3 = "OTHERWISE"; + parameter SDS_DETECT2 = "OTHERWISE"; + parameter SDS_DETECT1 = "OTHERWISE"; + parameter SDS_DETECT0 = "OTHERWISE"; + parameter INFO_BAD_TLP_NULL_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_PHY_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_MALF_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_ECRC_ERR = "OTHERWISE"; + parameter INFO_SCHEDULE_DUPL_ACK = "OTHERWISE"; + parameter INFO_BAD_TLP_SEQ_ERR = "OTHERWISE"; + parameter INFO_BAD_TLP_CRC_ERR = "OTHERWISE"; + parameter INFO_NAK_RECEIVED = "OTHERWISE"; + parameter INFO_DESKEW_OVERFLOW_ERROR = "OTHERWISE"; + parameter INFO_TX_DATA_UNDERFLOW = "OTHERWISE"; + parameter INFO_REPLAY_STARTED = "OTHERWISE"; + parameter ERR_AER_TX_PAR2 = "OTHERWISE"; + parameter ERR_AER_TX_REPLAY_ECC2 = "OTHERWISE"; + parameter ERR_AER_TX_REPLAY_ECC1 = "OTHERWISE"; + parameter ERR_AER_SURPRISE_DOWN = "OTHERWISE"; + parameter ERR_AER_DL_PROTOCOL_ERROR = "OTHERWISE"; + parameter ERR_AER_REPLAY_TIMER_TIMEOUT = "OTHERWISE"; + parameter ERR_AER_REPLAY_NUM_ROLLOVER = "OTHERWISE"; + parameter ERR_AER_BAD_DLLP = "OTHERWISE"; + parameter ERR_AER_BAD_TLP = "OTHERWISE"; + parameter ERR_AER_RECEIVER_ERROR = "OTHERWISE"; + parameter P_RX_LIM_H = "DISABLED"; + parameter P_RX_LIM_D = "DISABLED"; + parameter N_RX_LIM_H = "DISABLED"; + parameter N_RX_LIM_D = "DISABLED"; + parameter C_RX_LIM_H = "DISABLED"; + parameter C_RX_LIM_D = "DISABLED"; + parameter P_TX_LIM_H = "DISABLED"; + parameter P_TX_LIM_D = "DISABLED"; + parameter N_TX_LIM_H = "DISABLED"; + parameter N_TX_LIM_D = "DISABLED"; + parameter C_TX_LIM_H = "DISABLED"; + parameter C_TX_LIM_D = "DISABLED"; + parameter MAX_RSA_WAIT = "0b00101000"; + parameter F_ARXDPNULL = "0b00000"; + input ACTACMD; + input ACTDR11; + input ACTEN; + input ACTHIGHZ; + input ACTMD; + output ACJNOUT; + output ACJPOUT; + input AUXCK; + input CKUSRI; + output CKUSRO; + input ECKIN; + input ECKIND2; + output ECKINDO; + input ERSTN; + input ERSTND2; + input ERXCKD2; + output ERXCKDO; + input ERXRSND2; + input ETXCKD2; + output ETXCKDO; + input ETXRSND2; + output FLR3; + output FLR2; + output FLR1; + output FLR0; + input FLRACK3; + input FLRACK2; + input FLRACK1; + input FLRACK0; + input MINTLEG3; + input MINTLEG2; + input MINTLEG1; + input MINTLEG0; + output MINTO; + input PERSTN; + output PMCTRL4; + output PMCTRL3; + output PMCTRL2; + output PMCTRL1; + output PMCTRL0; + output PMCTRLEN; + input PMDPAST4; + input PMDPAST3; + input PMDPAST2; + input PMDPAST1; + input PMDPAST0; + input PRMSGSD; + input PRNOSNP12; + input PRNOSNP11; + input PRNOSNP10; + input PRNOSNP9; + input PRNOSNP8; + input PRNOSNP7; + input PRNOSNP6; + input PRNOSNP5; + input PRNOSNP4; + input PRNOSNP3; + input PRNOSNP2; + input PRNOSNP1; + input PRNOSNP0; + input PRNSNPRE; + input PRSNOOP12; + input PRSNOOP11; + input PRSNOOP10; + input PRSNOOP9; + input PRSNOOP8; + input PRSNOOP7; + input PRSNOOP6; + input PRSNOOP5; + input PRSNOOP4; + input PRSNOOP3; + input PRSNOOP2; + input PRSNOOP1; + input PRSNOOP0; + input PRSNPRE; + input PPBDREG31; + input PPBDREG30; + input PPBDREG29; + input PPBDREG28; + input PPBDREG27; + input PPBDREG26; + input PPBDREG25; + input PPBDREG24; + input PPBDREG23; + input PPBDREG22; + input PPBDREG21; + input PPBDREG20; + input PPBDREG19; + input PPBDREG18; + input PPBDREG17; + input PPBDREG16; + input PPBDREG15; + input PPBDREG14; + input PPBDREG13; + input PPBDREG12; + input PPBDREG11; + input PPBDREG10; + input PPBDREG9; + input PPBDREG8; + input PPBDREG7; + input PPBDREG6; + input PPBDREG5; + input PPBDREG4; + input PPBDREG3; + input PPBDREG2; + input PPBDREG1; + input PPBDREG0; + output PPBDSEL7; + output PPBDSEL6; + output PPBDSEL5; + output PPBDSEL4; + output PPBDSEL3; + output PPBDSEL2; + output PPBDSEL1; + output PPBDSEL0; + input REXTCK; + input REXTRST; + input RSTUSRN; + output UDLLKUP; + input ULTSDIS; + output UPLLKUP; + output UTLLKUP; + input UCFGADDR11; + input UCFGADDR10; + input UCFGADDR9; + input UCFGADDR8; + input UCFGADDR7; + input UCFGADDR6; + input UCFGADDR5; + input UCFGADDR4; + input UCFGADDR3; + input UCFGADDR2; + input UCFGF2; + input UCFGF1; + input UCFGF0; + output UCFGRDD31; + output UCFGRDD30; + output UCFGRDD29; + output UCFGRDD28; + output UCFGRDD27; + output UCFGRDD26; + output UCFGRDD25; + output UCFGRDD24; + output UCFGRDD23; + output UCFGRDD22; + output UCFGRDD21; + output UCFGRDD20; + output UCFGRDD19; + output UCFGRDD18; + output UCFGRDD17; + output UCFGRDD16; + output UCFGRDD15; + output UCFGRDD14; + output UCFGRDD13; + output UCFGRDD12; + output UCFGRDD11; + output UCFGRDD10; + output UCFGRDD9; + output UCFGRDD8; + output UCFGRDD7; + output UCFGRDD6; + output UCFGRDD5; + output UCFGRDD4; + output UCFGRDD3; + output UCFGRDD2; + output UCFGRDD1; + output UCFGRDD0; + output UCFGRDE; + output UCFGRDY; + input UCFGSERD; + input UCFGVD; + input UCFGWRBE3; + input UCFGWRBE2; + input UCFGWRBE1; + input UCFGWRBE0; + input UCFGWRD31; + input UCFGWRD30; + input UCFGWRD29; + input UCFGWRD28; + input UCFGWRD27; + input UCFGWRD26; + input UCFGWRD25; + input UCFGWRD24; + input UCFGWRD23; + input UCFGWRD22; + input UCFGWRD21; + input UCFGWRD20; + input UCFGWRD19; + input UCFGWRD18; + input UCFGWRD17; + input UCFGWRD16; + input UCFGWRD15; + input UCFGWRD14; + input UCFGWRD13; + input UCFGWRD12; + input UCFGWRD11; + input UCFGWRD10; + input UCFGWRD9; + input UCFGWRD8; + input UCFGWRD7; + input UCFGWRD6; + input UCFGWRD5; + input UCFGWRD4; + input UCFGWRD3; + input UCFGWRD2; + input UCFGWRD1; + input UCFGWRD0; + input UCFGWRDN; + input USERAUPD; + input USERTRS3; + input USERTRS2; + input USERTRS1; + input USERTRS0; + input LMMICLK; + input LMMIOFFSET16; + input LMMIOFFSET15; + input LMMIOFFSET14; + input LMMIOFFSET13; + input LMMIOFFSET12; + input LMMIOFFSET11; + input LMMIOFFSET10; + input LMMIOFFSET9; + input LMMIOFFSET8; + input LMMIOFFSET7; + input LMMIOFFSET6; + input LMMIOFFSET5; + input LMMIOFFSET4; + input LMMIOFFSET3; + input LMMIOFFSET2; + output LMMIRDATA31; + output LMMIRDATA30; + output LMMIRDATA29; + output LMMIRDATA28; + output LMMIRDATA27; + output LMMIRDATA26; + output LMMIRDATA25; + output LMMIRDATA24; + output LMMIRDATA23; + output LMMIRDATA22; + output LMMIRDATA21; + output LMMIRDATA20; + output LMMIRDATA19; + output LMMIRDATA18; + output LMMIRDATA17; + output LMMIRDATA16; + output LMMIRDATA15; + output LMMIRDATA14; + output LMMIRDATA13; + output LMMIRDATA12; + output LMMIRDATA11; + output LMMIRDATA10; + output LMMIRDATA9; + output LMMIRDATA8; + output LMMIRDATA7; + output LMMIRDATA6; + output LMMIRDATA5; + output LMMIRDATA4; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIREQUEST; + input LMMIRESETN; + input LMMIWDATA31; + input LMMIWDATA30; + input LMMIWDATA29; + input LMMIWDATA28; + input LMMIWDATA27; + input LMMIWDATA26; + input LMMIWDATA25; + input LMMIWDATA24; + input LMMIWDATA23; + input LMMIWDATA22; + input LMMIWDATA21; + input LMMIWDATA20; + input LMMIWDATA19; + input LMMIWDATA18; + input LMMIWDATA17; + input LMMIWDATA16; + input LMMIWDATA15; + input LMMIWDATA14; + input LMMIWDATA13; + input LMMIWDATA12; + input LMMIWDATA11; + input LMMIWDATA10; + input LMMIWDATA9; + input LMMIWDATA8; + input LMMIWDATA7; + input LMMIWDATA6; + input LMMIWDATA5; + input LMMIWDATA4; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + input LMMIWRRDN; + output VRXCMDD12; + output VRXCMDD11; + output VRXCMDD10; + output VRXCMDD9; + output VRXCMDD8; + output VRXCMDD7; + output VRXCMDD6; + output VRXCMDD5; + output VRXCMDD4; + output VRXCMDD3; + output VRXCMDD2; + output VRXCMDD1; + output VRXCMDD0; + input VRXCINIT; + input VRXCNH11; + input VRXCNH10; + input VRXCNH9; + input VRXCNH8; + input VRXCNH7; + input VRXCNH6; + input VRXCNH5; + input VRXCNH4; + input VRXCNH3; + input VRXCNH2; + input VRXCNH1; + input VRXCNH0; + input VRXCNINF; + input VRXCRRE; + output VRXD31; + output VRXD30; + output VRXD29; + output VRXD28; + output VRXD27; + output VRXD26; + output VRXD25; + output VRXD24; + output VRXD23; + output VRXD22; + output VRXD21; + output VRXD20; + output VRXD19; + output VRXD18; + output VRXD17; + output VRXD16; + output VRXD15; + output VRXD14; + output VRXD13; + output VRXD12; + output VRXD11; + output VRXD10; + output VRXD9; + output VRXD8; + output VRXD7; + output VRXD6; + output VRXD5; + output VRXD4; + output VRXD3; + output VRXD2; + output VRXD1; + output VRXD0; + output VRXDP3; + output VRXDP2; + output VRXDP1; + output VRXDP0; + output VRXEOP; + output VRXERR; + output VRXF1; + output VRXF0; + input VRXRDY; + output VRXSEL1; + output VRXSEL0; + output VRXSOP; + output VRXVD; + output VXCDINIT; + output VXCDNH11; + output VXCDNH10; + output VXCDNH9; + output VXCDNH8; + output VXCDNH7; + output VXCDNH6; + output VXCDNH5; + output VXCDNH4; + output VXCDNH3; + output VXCDNH2; + output VXCDNH1; + output VXCDNH0; + output VTXCRRE; + input VXD31; + input VXD30; + input VXD29; + input VXD28; + input VXD27; + input VXD26; + input VXD25; + input VXD24; + input VXD23; + input VXD22; + input VXD21; + input VXD20; + input VXD19; + input VXD18; + input VXD17; + input VXD16; + input VXD15; + input VXD14; + input VXD13; + input VXD12; + input VXD11; + input VXD10; + input VXD9; + input VXD8; + input VXD7; + input VXD6; + input VXD5; + input VXD4; + input VXD3; + input VXD2; + input VXD1; + input VXD0; + input VXDP3; + input VXDP2; + input VXDP1; + input VXDP0; + input VXEOP; + input VXEOPN; + output VXRDY; + input VXSOP; + input VXVD; + output TESTOUT7; + output TESTOUT6; + output TESTOUT5; + output TESTOUT4; + output TESTOUT3; + output TESTOUT2; + output TESTOUT1; + output TESTOUT0; + input REFCLKNA; + (* iopad_external_pin *) + input S0REFCKN; + (* iopad_external_pin *) + input S0REFCKP; + (* iopad_external_pin *) + input S0REFRET; + (* iopad_external_pin *) + input S0REXT; + (* iopad_external_pin *) + input S0RXN; + (* iopad_external_pin *) + input S0RXP; + (* iopad_external_pin *) + output S0TXN; + (* iopad_external_pin *) + output S0TXP; + input CLKREQI; + output CLKREQO; + output CLKREQOE; + input SCANCLK; + input SCANRST; + input OPCGLDCK; + input ALTCLKIN; +endmodule + +module PLL_CORE (...); + parameter BW_CTL_BIAS = "0b0101"; + parameter CLKOP_TRIM = "0b0000"; + parameter CLKOS_TRIM = "0b0000"; + parameter CLKOS2_TRIM = "0b0000"; + parameter CLKOS3_TRIM = "0b0000"; + parameter CLKOS4_TRIM = "0b0000"; + parameter CLKOS5_TRIM = "0b0000"; + parameter CRIPPLE = "5P"; + parameter CSET = "40P"; + parameter DELAY_CTRL = "200PS"; + parameter DELA = "0"; + parameter DELB = "0"; + parameter DELC = "0"; + parameter DELD = "0"; + parameter DELE = "0"; + parameter DELF = "0"; + parameter DIRECTION = "DISABLED"; + parameter DIVA = "0"; + parameter DIVB = "0"; + parameter DIVC = "0"; + parameter DIVD = "0"; + parameter DIVE = "0"; + parameter DIVF = "0"; + parameter DYN_SEL = "0b000"; + parameter DYN_SOURCE = "STATIC"; + parameter ENCLK_CLKOP = "DISABLED"; + parameter ENCLK_CLKOS = "DISABLED"; + parameter ENCLK_CLKOS2 = "DISABLED"; + parameter ENCLK_CLKOS3 = "DISABLED"; + parameter ENCLK_CLKOS4 = "DISABLED"; + parameter ENCLK_CLKOS5 = "DISABLED"; + parameter ENABLE_SYNC = "DISABLED"; + parameter FAST_LOCK_EN = "ENABLED"; + parameter V2I_1V_EN = "DISABLED"; + parameter FBK_CUR_BLE = "0b00000000"; + parameter FBK_EDGE_SEL = "POSITIVE"; + parameter FBK_IF_TIMING_CTL = "0b00"; + parameter FBK_INTEGER_MODE = "DISABLED"; + parameter FBK_MASK = "0b00001000"; + parameter FBK_MMD_DIG = "8"; + parameter FBK_MMD_PULS_CTL = "0b0000"; + parameter FBK_MODE = "0b00"; + parameter FBK_PI_BYPASS = "NOT_BYPASSED"; + parameter FBK_PI_RC = "0b1100"; + parameter FBK_PR_CC = "0b0000"; + parameter FBK_PR_IC = "0b1000"; + parameter FLOAT_CP = "DISABLED"; + parameter FLOCK_CTRL = "2X"; + parameter FLOCK_EN = "ENABLED"; + parameter FLOCK_SRC_SEL = "REFCLK"; + parameter FORCE_FILTER = "DISABLED"; + parameter I_CTRL = "10UA"; + parameter IPI_CMP = "0b1000"; + parameter IPI_CMPN = "0b0011"; + parameter IPI_COMP_EN = "DISABLED"; + parameter IPP_CTRL = "0b1000"; + parameter IPP_SEL = "0b1111"; + parameter KP_VCO = "0b11001"; + parameter LDT_INT_LOCK_STICKY = "DISABLED"; + parameter LDT_LOCK = "1536CYC"; + parameter LDT_LOCK_SEL = "U_FREQ"; + parameter LEGACY_ATT = "DISABLED"; + parameter LOAD_REG = "DISABLED"; + parameter OPENLOOP_EN = "DISABLED"; + parameter PHIA = "0"; + parameter PHIB = "0"; + parameter PHIC = "0"; + parameter PHID = "0"; + parameter PHIE = "0"; + parameter PHIF = "0"; + parameter PLLPDN_EN = "DISABLED"; + parameter PLLPD_N = "UNUSED"; + parameter PLLRESET_ENA = "DISABLED"; + parameter REF_INTEGER_MODE = "DISABLED"; + parameter REF_MASK = "0b00000000"; + parameter REF_MMD_DIG = "8"; + parameter REF_MMD_IN = "0b00001000"; + parameter REF_MMD_PULS_CTL = "0b0000"; + parameter REF_TIMING_CTL = "0b00"; + parameter REFIN_RESET = "SET"; + parameter RESET_LF = "DISABLED"; + parameter ROTATE = "DISABLED"; + parameter SEL_OUTA = "DISABLED"; + parameter SEL_OUTB = "DISABLED"; + parameter SEL_OUTC = "DISABLED"; + parameter SEL_OUTD = "DISABLED"; + parameter SEL_OUTE = "DISABLED"; + parameter SEL_OUTF = "DISABLED"; + parameter SLEEP = "DISABLED"; + parameter SSC_DITHER = "DISABLED"; + parameter SSC_EN_CENTER_IN = "DOWN_TRIANGLE"; + parameter SSC_EN_SDM = "DISABLED"; + parameter SSC_EN_SSC = "DISABLED"; + parameter SSC_F_CODE = "0b000000000000000"; + parameter SSC_N_CODE = "0b000010100"; + parameter SSC_ORDER = "SDM_ORDER2"; + parameter SSC_PI_BYPASS = "NOT_BYPASSED"; + parameter SSC_REG_WEIGHTING_SEL = "0b000"; + parameter SSC_SQUARE_MODE = "DISABLED"; + parameter SSC_STEP_IN = "0b0000000"; + parameter SSC_TBASE = "0b000000000000"; + parameter STDBY_ATT = "DISABLED"; + parameter TRIMOP_BYPASS_N = "BYPASSED"; + parameter TRIMOS_BYPASS_N = "BYPASSED"; + parameter TRIMOS2_BYPASS_N = "BYPASSED"; + parameter TRIMOS3_BYPASS_N = "BYPASSED"; + parameter TRIMOS4_BYPASS_N = "BYPASSED"; + parameter TRIMOS5_BYPASS_N = "BYPASSED"; + parameter V2I_KVCO_SEL = "85"; + parameter V2I_PP_ICTRL = "0b00110"; + parameter V2I_PP_RES = "10K"; + parameter CLKMUX_FB = "CMUX_CLKOP"; + parameter SEL_FBK = "DIVA"; + parameter DIV_DEL = "0b0000001"; + parameter PHASE_SEL_DEL = "0b000"; + parameter PHASE_SEL_DEL_P1 = "0b000"; + parameter EXTERNAL_DIVIDE_FACTOR = "0"; + input CIBDIR; + input CIBDSEL2; + input CIBDSEL1; + input CIBDSEL0; + input CIBLDREG; + input CIBROT; + output CLKOP; + output CLKOS; + output CLKOS2; + output CLKOS3; + output CLKOS4; + output CLKOS5; + input ENEXT; + input ENCLKOP; + input ENCLKOS; + input ENCLKOS2; + input ENCLKOS3; + input ENCLKOS4; + input ENCLKOS5; + input FBKCK; + output INTFBK5; + output INTFBK4; + output INTFBK3; + output INTFBK2; + output INTFBK1; + output INTFBK0; + output INTLOCK; + input LEGACY; + output LEGRDYN; + input LMMICLK; + input LMMIOFFSET6; + input LMMIOFFSET5; + input LMMIOFFSET4; + input LMMIOFFSET3; + input LMMIOFFSET2; + input LMMIOFFSET1; + input LMMIOFFSET0; + output LMMIRDATA7; + output LMMIRDATA6; + output LMMIRDATA5; + output LMMIRDATA4; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIREQUEST; + input LMMIRESETN; + input LMMIWDATA7; + input LMMIWDATA6; + input LMMIWDATA5; + input LMMIWDATA4; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + input LMMIWRRDN; + output LOCK; + output PFDDN; + output PFDUP; + input PLLRESET; + input REFCK; + input STDBY; + input ZRSEL3; + output REFMUXCK; + input PLLPDN; + output REGQA; + output REGQB; + output REGQB1; + output CLKOUTDL; + input ROTDEL; + input DIRDEL; + input ROTDELP1; + input GRAYTEST4; + input GRAYTEST3; + input GRAYTEST2; + input GRAYTEST1; + input GRAYTEST0; + input BINTEST1; + input BINTEST0; + input DIRDELP1; + input GRAYACT4; + input GRAYACT3; + input GRAYACT2; + input GRAYACT1; + input GRAYACT0; + input BINACT1; + input BINACT0; + input OPCGLDCK; + input SCANRST; + input SCANCLK; +endmodule + +module PREADD9_CORE (...); + parameter SIGNEDSTATIC_EN = "DISABLED"; + parameter SUBSTRACT_EN = "SUBTRACTION"; + parameter CSIGNED = "DISABLED"; + parameter BSIGNED_OPERAND_EN = "DISABLED"; + parameter BYPASS_PREADD9 = "USED"; + parameter REGBYPSBR0 = "REGISTER"; + parameter REGBYPSBR1 = "BYPASS"; + parameter REGBYPSBL = "REGISTER"; + parameter SHIFTBR = "REGISTER"; + parameter SHIFTBL = "REGISTER"; + parameter GSR = "ENABLED"; + parameter PREADDCAS_EN = "DISABLED"; + parameter SR_18BITSHIFT_EN = "DISABLED"; + parameter OPC = "INPUT_B_AS_PREADDER_OPERAND"; + parameter RESET = "SYNC"; + input B8; + input B7; + input B6; + input B5; + input B4; + input B3; + input B2; + input B1; + input B0; + input BSIGNED; + input C9; + input C8; + input C7; + input C6; + input C5; + input C4; + input C3; + input C2; + input C1; + input C0; + input BRS18; + input BRS17; + input BRS16; + input BRS15; + input BRS14; + input BRS13; + input BRS12; + input BRS11; + input BRS10; + input BRS28; + input BRS27; + input BRS26; + input BRS25; + input BRS24; + input BRS23; + input BRS22; + input BRS21; + input BRS20; + input BLS18; + input BLS17; + input BLS16; + input BLS15; + input BLS14; + input BLS13; + input BLS12; + input BLS11; + input BLS10; + input BLS28; + input BLS27; + input BLS26; + input BLS25; + input BLS24; + input BLS23; + input BLS22; + input BLS21; + input BLS20; + input BRSS1; + input BRSS2; + input BLSS1; + input BLSS2; + input PRCASIN; + input CLK; + input RSTB; + input CEB; + input RSTCL; + input CECL; + output BRSO8; + output BRSO7; + output BRSO6; + output BRSO5; + output BRSO4; + output BRSO3; + output BRSO2; + output BRSO1; + output BRSO0; + output BLSO8; + output BLSO7; + output BLSO6; + output BLSO5; + output BLSO4; + output BLSO3; + output BLSO2; + output BLSO1; + output BLSO0; + output BRSOSGND; + output BLSOSGND; + output PRCASOUT; + output BR8; + output BR7; + output BR6; + output BR5; + output BR4; + output BR3; + output BR2; + output BR1; + output BR0; + output BRSIGNED; +endmodule + +module REFMUX_CORE (...); + parameter REFSEL_ATT = "MC1"; + parameter SEL1 = "SELECT_REFCLK1"; + parameter SEL_REF2 = "REFCLK2_0"; + parameter SEL_REF1 = "REFCLK1_0"; + output REFCK; + output ZRSEL3; + input REFSEL; + input REFCLK17; + input REFCLK16; + input REFCLK15; + input REFCLK14; + input REFCLK13; + input REFCLK12; + input REFCLK11; + input REFCLK10; + input REFCLK27; + input REFCLK26; + input REFCLK25; + input REFCLK24; + input REFCLK23; + input REFCLK22; + input REFCLK21; + input REFCLK20; +endmodule + +module REG18_CORE (...); + parameter REGBYPS = "REGISTER"; + parameter GSR = "ENABLED"; + parameter RESET = "SYNC"; + input PM17; + input PM16; + input PM15; + input PM14; + input PM13; + input PM12; + input PM11; + input PM10; + input PM9; + input PM8; + input PM7; + input PM6; + input PM5; + input PM4; + input PM3; + input PM2; + input PM1; + input PM0; + output PP17; + output PP16; + output PP15; + output PP14; + output PP13; + output PP12; + output PP11; + output PP10; + output PP9; + output PP8; + output PP7; + output PP6; + output PP5; + output PP4; + output PP3; + output PP2; + output PP1; + output PP0; + input CEP; + input RSTP; + input CLK; +endmodule + +module SEIO18_CORE (...); + parameter MIPI_ID = "0"; + parameter PULLMODE = "DOWN"; + parameter MIPI = "DISABLED"; + parameter ENADC_IN = "DISABLED"; + input I; + input DOLP; + (* iopad_external_pin *) + inout B; + output O; + output INLP; + input T; + output INADC; +endmodule + +module SEIO33_CORE (...); + parameter PULLMODE = "DOWN"; + (* iopad_external_pin *) + inout B; + output O; + input I; + input T; + input I3CRESEN; + input I3CWKPU; +endmodule + +module SGMIICDR_CORE (...); + parameter GSR = "ENABLED"; + parameter DCOITUNE4LSB = "0_PERCENT"; + parameter DCOCTLGI = "0_PERCENT"; + parameter DCOSTEP = "100_PERCENT"; + parameter DCOCALDIV = "100_PERCENT"; + parameter DCOIOSTUNE = "0_PERCENT"; + parameter DCOFLTDAC = "80MHZ"; + parameter DCOSTARTVAL = "NOMINAL"; + parameter DCONUOFLSB = "NEG_60_PERCENT"; + parameter RPWDNB = "POWER_UP"; + parameter CDR_CNT4SEL = "BYPASSED"; + parameter DCOITUNE = "100_PERCENT"; + parameter BAND_THRESHOLD = "0b000000"; + parameter AUTO_FACQ_EN = "ENABLED"; + parameter AUTO_CALIB_EN = "ENABLED"; + parameter CDR_LOL_SET = "1000_PPM"; + parameter FC2DCO_FLOOP = "DISABLED"; + parameter FC2DCO_DLOOP = "DISABLED"; + parameter CALIB_TIME_SEL = "24_CYC"; + parameter CALIB_CK_MODE = "BY_2"; + parameter BAND_CALIB_MODE = "256_FDBK_CLK_CYC"; + parameter REG_BAND_SEL = "0b00000"; + parameter REG_BAND_OFFSET = "0b0000"; + parameter REG_IDAC_SEL = "0b00000000"; + parameter LB_CTL = "DISABLED"; + parameter REG_IDAC_EN = "DISABLED"; + parameter ATDCFG = "0_PS"; + parameter ATDDLY = "0_PS"; + parameter BDAVOID_ENB = "ENABLED"; + parameter BYPASSATD = "NOT_BYPASS"; + parameter DCOIUPDNX2 = "1X"; + parameter IDAC_EN = "DISABLED"; + parameter FB_CLK_DIV = "0b010"; + parameter EN_RECALIB = "ENABLED"; + input DCALIRST; + input DFACQRST; + input RRST; + input SPCLK; + output SRCLK; + output SRXD9; + output SRXD8; + output SRXD7; + output SRXD6; + output SRXD5; + output SRXD4; + output SRXD3; + output SRXD2; + output SRXD1; + output SRXD0; + input LMMICLK; + input LMMIREQUEST; + input LMMIWRRDN; + input LMMIOFFSET3; + input LMMIOFFSET2; + input LMMIOFFSET1; + input LMMIOFFSET0; + input LMMIWDATA7; + input LMMIWDATA6; + input LMMIWDATA5; + input LMMIWDATA4; + input LMMIWDATA3; + input LMMIWDATA2; + input LMMIWDATA1; + input LMMIWDATA0; + output LMMIRDATA7; + output LMMIRDATA6; + output LMMIRDATA5; + output LMMIRDATA4; + output LMMIRDATA3; + output LMMIRDATA2; + output LMMIRDATA1; + output LMMIRDATA0; + output LMMIRDATAVALID; + output LMMIREADY; + input LMMIRESETN; + input RSTBFBW; + input RSTBRXF; + input SGMIIIN; + input SREFCLK; + output CDRLOL; + input OPCGLOADCLK; + input SCANCLK; + input SCANRST; +endmodule + +module GSR (...); + parameter SYNCMODE = "ASYNC"; + input GSR_N; + input CLK; +endmodule + +module DCC (...); + parameter DCCEN = "0"; + input CE; + input CLKI; + output CLKO; +endmodule + +module DCS (...); + parameter DCSMODE = "GND"; + input CLK0; + input CLK1; + output DCSOUT; + input SEL; + input SELFORCE; +endmodule + +module GSR_CORE (...); + parameter GSR = "ENABLED"; + parameter GSR_SYNC = "ASYNC"; + output GSROUT; + input CLK; + input GSR_N; +endmodule + +module PCLKDIV (...); + parameter DIV_PCLKDIV = "X1"; + parameter GSR = "ENABLED"; + parameter TESTEN_PCLKDIV = "0"; + parameter TESTMODE_PCLKDIV = "0"; + input CLKIN; + output CLKOUT; + input LSRPDIV; + input PCLKDIVTESTINP2; + input PCLKDIVTESTINP1; + input PCLKDIVTESTINP0; +endmodule + +(* keep *) +module PUR (...); + parameter RST_PULSE = "1"; + input PUR; +endmodule + +module PCLKDIVSP (...); + parameter DIV_PCLKDIV = "X1"; + parameter GSR = "ENABLED"; + input CLKIN; + output CLKOUT; + input LSRPDIV; +endmodule + diff --git a/techlibs/nexus/latches_map.v b/techlibs/nexus/latches_map.v new file mode 100644 index 000000000..c28f88cf7 --- /dev/null +++ b/techlibs/nexus/latches_map.v @@ -0,0 +1,11 @@ +module \$_DLATCH_N_ (E, D, Q); + wire [1023:0] _TECHMAP_DO_ = "simplemap; opt"; + input E, D; + output Q = !E ? D : Q; +endmodule + +module \$_DLATCH_P_ (E, D, Q); + wire [1023:0] _TECHMAP_DO_ = "simplemap; opt"; + input E, D; + output Q = E ? D : Q; +endmodule diff --git a/techlibs/nexus/lutrams.txt b/techlibs/nexus/lutrams.txt new file mode 100644 index 000000000..2568b9998 --- /dev/null +++ b/techlibs/nexus/lutrams.txt @@ -0,0 +1,26 @@ +bram $__NEXUS_DPR16X4 + init 1 + abits 4 + dbits 4 + groups 2 + ports 1 1 + wrmode 0 1 + enable 0 1 + transp 0 0 + clocks 0 1 + clkpol 0 2 +endbram + +# The syn_* attributes are described in: +# https://www.latticesemi.com/-/media/LatticeSemi/Documents/Tutorials/AK/LatticeDiamondTutorial311.ashx +attr_icase 1 + +match $__NEXUS_DPR16X4 + attribute !syn_ramstyle syn_ramstyle=auto syn_ramstyle=distributed + attribute !syn_romstyle syn_romstyle=auto + attribute !ram_block + attribute !rom_block + attribute !logic_block + make_outreg + min wports 1 +endmatch diff --git a/techlibs/nexus/lutrams_map.v b/techlibs/nexus/lutrams_map.v new file mode 100644 index 000000000..0910664ce --- /dev/null +++ b/techlibs/nexus/lutrams_map.v @@ -0,0 +1,34 @@ +module \$__NEXUS_DPR16X4 (CLK1, A1ADDR, A1DATA, B1ADDR, B1DATA, B1EN); + parameter [63:0] INIT = 64'b0; + parameter CLKPOL2 = 1; + input CLK1; + + input [3:0] A1ADDR; + output [3:0] A1DATA; + + input [3:0] B1ADDR; + input [3:0] B1DATA; + input B1EN; + + + wire wck; + + generate + if (CLKPOL2) + assign wck = CLK1; + else + INV wck_inv_i (.A(CLK1), .Z(wck)); + endgenerate + + DPR16X4 #( + .INITVAL($sformatf("0x%08x", INIT)) + ) _TECHMAP_REPLACE_ ( + .RAD(A1ADDR), + .DO(A1DATA), + + .WAD(B1ADDR), + .DI(B1DATA), + .WCK(CLK1), + .WRE(B1EN) + ); +endmodule diff --git a/techlibs/nexus/parse_init.vh b/techlibs/nexus/parse_init.vh new file mode 100644 index 000000000..0f9ab7897 --- /dev/null +++ b/techlibs/nexus/parse_init.vh @@ -0,0 +1,33 @@ +function [15:0] parse_init; + input [((2+(16/4))*8)-1:0] init; + reg [7:0] c; + integer i; + begin + for (i = 0; i < (16/4); i = i + 1) begin + c = init[(i * 8) +: 8]; + if (c >= "0" && c <= "9") + parse_init[(i * 4) +: 4] = (c - "0"); + else if (c >= "A" && c <= "F") + parse_init[(i * 4) +: 4] = (c - "A") + 10; + else if (c >= "a" && c <= "f") + parse_init[(i * 4) +: 4] = (c - "a") + 10; + end + end +endfunction + +function [63:0] parse_init_64; + input [((2+(64/4))*8)-1:0] init; + reg [7:0] c; + integer i; + begin + for (i = 0; i < (64/4); i = i + 1) begin + c = init[(i * 8) +: 8]; + if (c >= "0" && c <= "9") + parse_init_64[(i * 4) +: 4] = (c - "0"); + else if (c >= "A" && c <= "F") + parse_init_64[(i * 4) +: 4] = (c - "A") + 10; + else if (c >= "a" && c <= "f") + parse_init_64[(i * 4) +: 4] = (c - "a") + 10; + end + end +endfunction diff --git a/techlibs/nexus/synth_nexus.cc b/techlibs/nexus/synth_nexus.cc new file mode 100644 index 000000000..7e2185ab6 --- /dev/null +++ b/techlibs/nexus/synth_nexus.cc @@ -0,0 +1,372 @@ +/* + * yosys -- Yosys Open SYnthesis Suite + * + * Copyright (C) 2020 David Shah <dave@ds0.me> + * + * 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. + * + */ + +#include "kernel/register.h" +#include "kernel/celltypes.h" +#include "kernel/rtlil.h" +#include "kernel/log.h" + +USING_YOSYS_NAMESPACE +PRIVATE_NAMESPACE_BEGIN + +struct SynthNexusPass : public ScriptPass +{ + SynthNexusPass() : ScriptPass("synth_nexus", "synthesis for Lattice Nexus FPGAs") { } + + void on_register() override + { + RTLIL::constpad["synth_nexus.abc9.W"] = "300"; + } + + void help() override + { + // |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---| + log("\n"); + log(" synth_nexus [options]\n"); + log("\n"); + log("This command runs synthesis for Lattice Nexus FPGAs.\n"); + log("\n"); + log(" -top <module>\n"); + log(" use the specified module as top module\n"); + log("\n"); + log(" -family <device>\n"); + log(" run synthesis for the specified Nexus device\n"); + log(" supported values: lifcl, lfd2nx\n"); + log("\n"); + log(" -json <file>\n"); + log(" write the design to the specified JSON file. writing of an output file\n"); + log(" is omitted if this parameter is not specified.\n"); + log("\n"); + log(" -vm <file>\n"); + log(" write the design to the specified structural Verilog file. writing of\n"); + log(" an output file is omitted if this parameter is not specified.\n"); + log("\n"); + log(" -run <from_label>:<to_label>\n"); + log(" only run the commands between the labels (see below). an empty\n"); + log(" from label is synonymous to 'begin', and empty to label is\n"); + log(" synonymous to the end of the command list.\n"); + log("\n"); + log(" -noflatten\n"); + log(" do not flatten design before synthesis\n"); + log("\n"); + log(" -dff\n"); + log(" run 'abc'/'abc9' with -dff option\n"); + log("\n"); + log(" -retime\n"); + log(" run 'abc' with '-dff -D 1' options\n"); + log("\n"); + log(" -noccu2\n"); + log(" do not use CCU2 cells in output netlist\n"); + log("\n"); + log(" -nodffe\n"); + log(" do not use flipflops with CE in output netlist\n"); + log("\n"); + log(" -nobram\n"); + log(" do not use block RAM cells in output netlist\n"); + log("\n"); + log(" -nolutram\n"); + log(" do not use LUT RAM cells in output netlist\n"); + log("\n"); + log(" -nowidelut\n"); + log(" do not use PFU muxes to implement LUTs larger than LUT4s\n"); + log("\n"); + log(" -noiopad\n"); + log(" do not insert IO buffers\n"); + log("\n"); + log(" -abc9\n"); + log(" use new ABC9 flow (EXPERIMENTAL)\n"); + log("\n"); + log("The following commands are executed by this synthesis command:\n"); + help_script(); + log("\n"); + } + + string top_opt, json_file, vm_file, family; + bool noccu2, nodffe, nobram, nolutram, nowidelut, noiopad, flatten, dff, retime, abc9; + + void clear_flags() override + { + top_opt = "-auto-top"; + family = "lifcl"; + json_file = ""; + vm_file = ""; + noccu2 = false; + nodffe = false; + nobram = false; + nolutram = false; + nowidelut = false; + noiopad = false; + flatten = true; + dff = false; + retime = false; + } + + void execute(std::vector<std::string> args, RTLIL::Design *design) override + { + string run_from, run_to; + clear_flags(); + + size_t argidx; + for (argidx = 1; argidx < args.size(); argidx++) + { + if (args[argidx] == "-top" && argidx+1 < args.size()) { + top_opt = "-top " + args[++argidx]; + continue; + } + if (args[argidx] == "-json" && argidx+1 < args.size()) { + json_file = args[++argidx]; + continue; + } + if (args[argidx] == "-vm" && argidx+1 < args.size()) { + vm_file = args[++argidx]; + continue; + } + if (args[argidx] == "-run" && argidx+1 < args.size()) { + size_t pos = args[argidx+1].find(':'); + if (pos == std::string::npos) + break; + run_from = args[++argidx].substr(0, pos); + run_to = args[argidx].substr(pos+1); + continue; + } + if ((args[argidx] == "-family") && argidx+1 < args.size()) { + family = args[++argidx]; + continue; + } + if (args[argidx] == "-flatten") { + flatten = true; + continue; + } + if (args[argidx] == "-noflatten") { + flatten = false; + continue; + } + if (args[argidx] == "-dff") { + dff = true; + continue; + } + if (args[argidx] == "-retime") { + retime = true; + continue; + } + if (args[argidx] == "-noccu2") { + noccu2 = true; + continue; + } + if (args[argidx] == "-nodffe") { + nodffe = true; + continue; + } + if (args[argidx] == "-nobram") { + nobram = true; + continue; + } + if (args[argidx] == "-nolutram") { + nolutram = true; + continue; + } + if (args[argidx] == "-nowidelut") { + nowidelut = true; + continue; + } + if (args[argidx] == "-noiopad") { + noiopad = true; + continue; + } + if (args[argidx] == "-abc9") { + abc9 = true; + continue; + } + break; + } + extra_args(args, argidx, design); + + if (!design->full_selection()) + log_cmd_error("This command only operates on fully selected designs!\n"); + + if (abc9 && retime) + log_cmd_error("-retime option not currently compatible with -abc9!\n"); + + log_header(design, "Executing SYNTH_NEXUS pass.\n"); + log_push(); + + run_script(design, run_from, run_to); + + log_pop(); + } + + void script() override + { + + if (family != "lifcl" && family != "lfd2nx") + log_cmd_error("Invalid Nexus -family setting: '%s'.\n", family.c_str()); + + if (check_label("begin")) + { + run("read_verilog -lib -specify +/nexus/cells_sim.v +/nexus/cells_xtra.v"); + run(stringf("hierarchy -check %s", help_mode ? "-top <top>" : top_opt.c_str())); + } + + if (check_label("coarse")) + { + run("proc"); + if (flatten || help_mode) + run("flatten"); + run("tribuf -logic"); + run("deminout"); + run("opt_expr"); + run("opt_clean"); + run("check"); + run("opt -nodffe -nosdff"); + run("fsm"); + run("opt"); + run("wreduce"); + run("peepopt"); + run("opt_clean"); + run("share"); + run("techmap -map +/cmp2lut.v -D LUT_WIDTH=4"); + run("opt_expr"); + run("opt_clean"); + + run("alumacc"); + run("opt"); + run("memory -nomap"); + run("opt_clean"); + } + + if (!nobram && check_label("map_bram", "(skip if -nobram)")) + { + run("memory_bram -rules +/nexus/brams.txt"); + run("setundef -zero -params t:$__NX_PDP16K"); + run("techmap -map +/nexus/brams_map.v"); + } + + if (!nolutram && check_label("map_lutram", "(skip if -nolutram)")) + { + run("memory_bram -rules +/nexus/lutrams.txt"); + run("setundef -zero -params t:$__NEXUS_DPR16X4"); + run("techmap -map +/nexus/lutrams_map.v"); + } + + if (check_label("map_ffram")) + { + run("opt -fast -mux_undef -undriven -fine"); + run("memory_map -iattr -attr !ram_block -attr !rom_block -attr logic_block " + "-attr syn_ramstyle=auto -attr syn_ramstyle=registers " + "-attr syn_romstyle=auto -attr syn_romstyle=logic"); + run("opt -undriven -fine"); + } + + if (check_label("map_gates")) + { + if (noccu2) + run("techmap"); + else + run("techmap -map +/techmap.v -map +/nexus/arith_map.v"); + if (help_mode || !noiopad) + run("iopadmap -bits -outpad OB I:O -inpad IB O:I -toutpad $__NX_TOUTPAD OE:I:O -tinoutpad $__NX_TINOUTPAD OE:O:I:B A:top", "(skip if '-noiopad')"); + run("opt -fast"); + if (retime || help_mode) + run("abc -dff -D 1", "(only if -retime)"); + } + + if (check_label("map_ffs")) + { + run("opt_clean"); + std::string dfflegalize_args = " -cell $_DFF_P_ 01 -cell $_DFF_PP?_ r -cell $_SDFF_PP?_ r -cell $_DLATCH_?_ x"; + if (help_mode) { + dfflegalize_args += " [-cell $_DFFE_PP_ 01 -cell $_DFFE_PP?P_ r -cell $_SDFFE_PP?P_ r]"; + } else if (!nodffe) { + dfflegalize_args += " -cell $_DFFE_PP_ 01 -cell $_DFFE_PP?P_ r -cell $_SDFFE_PP?P_ r"; + } + run("dfflegalize" + dfflegalize_args, "($_*DFFE_* only if not -nodffe)"); + if ((abc9 && dff) || help_mode) + run("zinit -all w:* t:$_DFF_?_ t:$_DFFE_??_ t:$_SDFF*", "(only if -abc9 and -dff"); + run("techmap -D NO_LUT -map +/nexus/cells_map.v"); + run("opt_expr -undriven -mux_undef"); + run("simplemap"); + run("attrmvcp -copy -attr syn_useioff"); + run("opt_clean"); + } + + if (check_label("map_luts")) + { + run("techmap -map +/nexus/latches_map.v"); + + if (abc9) { + std::string abc9_opts; + if (nowidelut) + abc9_opts += " -maxlut 4"; + std::string k = "synth_nexus.abc9.W"; + if (active_design && active_design->scratchpad.count(k)) + abc9_opts += stringf(" -W %s", active_design->scratchpad_get_string(k).c_str()); + else + abc9_opts += stringf(" -W %s", RTLIL::constpad.at(k).c_str()); + if (nowidelut) + abc9_opts += " -maxlut 4"; + if (dff) + abc9_opts += " -dff"; + run("abc9" + abc9_opts); + } else { + std::string abc_args = " -dress"; + if (nowidelut) + abc_args += " -lut 4"; + else + abc_args += " -lut 4:5"; + if (dff) + abc_args += " -dff"; + run("abc" + abc_args); + } + run("clean"); + } + + if (check_label("map_cells")) + { + run("techmap -map +/nexus/cells_map.v"); + + // This is needed for Radiant, but perhaps not optimal for nextpnr... + run("setundef -zero"); + + run("hilomap -singleton -hicell VHI Z -locell VLO Z"); + run("clean"); + } + + if (check_label("check")) + { + run("autoname"); + run("hierarchy -check"); + run("stat"); + run("check -noinit"); + } + + if (check_label("json")) + { + if (!json_file.empty() || help_mode) + run(stringf("write_json %s", help_mode ? "<file-name>" : json_file.c_str())); + } + + if (check_label("vm")) + { + if (!vm_file.empty() || help_mode) + run(stringf("write_verilog %s", help_mode ? "<file-name>" : vm_file.c_str())); + } + } +} SynthNexusPass; + +PRIVATE_NAMESPACE_END diff --git a/techlibs/xilinx/cells_sim.v b/techlibs/xilinx/cells_sim.v index 40804c367..4162160bb 100644 --- a/techlibs/xilinx/cells_sim.v +++ b/techlibs/xilinx/cells_sim.v @@ -2335,6 +2335,8 @@ parameter integer PREG = 1; // The multiplier. wire signed [35:0] P_MULT; +wire signed [17:0] A_MULT; +wire signed [17:0] B_MULT; assign P_MULT = A_MULT * B_MULT; // The cascade output. @@ -2373,8 +2375,6 @@ always @(posedge CLK) begin end // The register enables. -wire signed [17:0] A_MULT; -wire signed [17:0] B_MULT; assign A_MULT = (AREG == 1) ? A_REG : A; assign B_MULT = (BREG == 1) ? B_REG : B_MUX; assign P = (PREG == 1) ? P_REG : P_MULT; diff --git a/tests/arch/ecp5/bug2409.ys b/tests/arch/ecp5/bug2409.ys new file mode 100644 index 000000000..5ba9cec17 --- /dev/null +++ b/tests/arch/ecp5/bug2409.ys @@ -0,0 +1,24 @@ +read_verilog <<EOT +module t (...); + +input CLK; +input [10:0] A; +input WE; +input C; +input [7:0] DI; +output reg [7:0] DO; + +reg [7:0] mem[2047:0]; + +always @(posedge CLK) begin + if (C) + if (WE) + mem[A] <= DI; + DO <= mem[A]; +end + +endmodule +EOT + +synth_ecp5 +select -assert-count 1 t:DP16KD diff --git a/tests/arch/nexus/.gitignore b/tests/arch/nexus/.gitignore new file mode 100644 index 000000000..ba42e1ee6 --- /dev/null +++ b/tests/arch/nexus/.gitignore @@ -0,0 +1,2 @@ +/*.log +/run-test.mk diff --git a/tests/arch/nexus/add_sub.ys b/tests/arch/nexus/add_sub.ys new file mode 100644 index 000000000..4317bab81 --- /dev/null +++ b/tests/arch/nexus/add_sub.ys @@ -0,0 +1,21 @@ +read_verilog ../common/add_sub.v +hierarchy -top top +proc +design -save orig + +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module +stat +select -assert-count 10 t:LUT4 +select -assert-none t:IB t:OB t:VLO t:LUT4 %% t:* %D + +design -load orig + +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus -abc9 # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module +stat +select -assert-count 6 t:LUT4 +select -assert-count 4 t:WIDEFN9 +select -assert-none t:IB t:OB t:VLO t:LUT4 t:WIDEFN9 %% t:* %D diff --git a/tests/arch/nexus/adffs.ys b/tests/arch/nexus/adffs.ys new file mode 100644 index 000000000..f8796425c --- /dev/null +++ b/tests/arch/nexus/adffs.ys @@ -0,0 +1,44 @@ +read_verilog ../common/adffs.v +design -save read + +hierarchy -top adff +proc +equiv_opt -async2sync -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd adff # Constrain all select calls below inside the top module +stat +select -assert-count 1 t:FD1P3DX +select -assert-none t:FD1P3DX t:IB t:OB t:VLO t:VHI %% t:* %D + +design -load read +hierarchy -top adffn +proc +equiv_opt -async2sync -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd adffn # Constrain all select calls below inside the top module +stat +select -assert-count 1 t:FD1P3DX +select -assert-count 1 t:INV +select -assert-none t:FD1P3DX t:INV t:LUT4 t:IB t:OB t:VLO t:VHI %% t:* %D + +design -load read +hierarchy -top dffs +proc +equiv_opt -async2sync -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd dffs # Constrain all select calls below inside the top module +stat +select -assert-count 1 t:FD1P3IX +select -assert-count 1 t:LUT4 +select -assert-none t:FD1P3IX t:LUT4 t:IB t:OB t:VLO t:VHI %% t:* %D + +design -load read +hierarchy -top ndffnr +proc +equiv_opt -async2sync -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd ndffnr # Constrain all select calls below inside the top module +stat +select -assert-count 1 t:FD1P3IX +select -assert-count 2 t:INV +select -assert-none t:FD1P3IX t:INV t:LUT4 t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/blockram.ys b/tests/arch/nexus/blockram.ys new file mode 100644 index 000000000..9540136d5 --- /dev/null +++ b/tests/arch/nexus/blockram.ys @@ -0,0 +1,18 @@ +read_verilog ../common/blockram.v +design -save read + +# Check that we use the right dual and single clock variants + +chparam -set ADDRESS_WIDTH 10 -set DATA_WIDTH 18 sync_ram_sdp +synth_nexus -top sync_ram_sdp +cd sync_ram_sdp +select -assert-count 1 t:PDPSC16K +select -assert-none t:PDPSC16K t:INV t:IB t:OB t:VLO t:VHI %% t:* %D + +design -reset +read_verilog blockram_dc.v +chparam -set ADDRESS_WIDTH 10 -set DATA_WIDTH 18 sync_ram_sdp_dc +synth_nexus -top sync_ram_sdp_dc +cd sync_ram_sdp_dc +select -assert-count 1 t:PDP16K +select -assert-none t:PDP16K t:INV t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/blockram_dc.v b/tests/arch/nexus/blockram_dc.v new file mode 100644 index 000000000..4f5d4f5a6 --- /dev/null +++ b/tests/arch/nexus/blockram_dc.v @@ -0,0 +1,25 @@ + +`default_nettype none +module sync_ram_sdp_dc #(parameter DATA_WIDTH=8, ADDRESS_WIDTH=10) + (input wire clkw, clkr, write_enable, + input wire [DATA_WIDTH-1:0] data_in, + input wire [ADDRESS_WIDTH-1:0] address_in_r, address_in_w, + output wire [DATA_WIDTH-1:0] data_out); + + localparam WORD = (DATA_WIDTH-1); + localparam DEPTH = (2**ADDRESS_WIDTH-1); + + reg [WORD:0] data_out_r; + reg [WORD:0] memory [0:DEPTH]; + + always @(posedge clkw) begin + if (write_enable) + memory[address_in_w] <= data_in; + end + always @(posedge clkr) begin + data_out_r <= memory[address_in_r]; + end + + assign data_out = data_out_r; + +endmodule // sync_ram_sdp_dc diff --git a/tests/arch/nexus/counter.ys b/tests/arch/nexus/counter.ys new file mode 100644 index 000000000..44421e377 --- /dev/null +++ b/tests/arch/nexus/counter.ys @@ -0,0 +1,11 @@ +read_verilog ../common/counter.v +hierarchy -top top +proc +flatten +equiv_opt -assert -multiclock -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module +stat +select -assert-count 5 t:CCU2 +select -assert-count 8 t:FD1P3DX +select -assert-none t:CCU2 t:FD1P3DX t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/dffs.ys b/tests/arch/nexus/dffs.ys new file mode 100644 index 000000000..9ebf68bf4 --- /dev/null +++ b/tests/arch/nexus/dffs.ys @@ -0,0 +1,19 @@ +read_verilog ../common/dffs.v +design -save read + +hierarchy -top dff +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd dff # Constrain all select calls below inside the top module +select -assert-count 1 t:FD1P3IX +select -assert-none t:FD1P3IX t:IB t:OB t:VHI t:VLO %% t:* %D + +design -load read +hierarchy -top dffe +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd dffe # Constrain all select calls below inside the top module +select -assert-count 1 t:FD1P3IX +select -assert-none t:FD1P3IX t:IB t:OB t:VHI t:VLO %% t:* %D diff --git a/tests/arch/nexus/fsm.ys b/tests/arch/nexus/fsm.ys new file mode 100644 index 000000000..24ad8fe5b --- /dev/null +++ b/tests/arch/nexus/fsm.ys @@ -0,0 +1,19 @@ +read_verilog ../common/fsm.v +hierarchy -top fsm +proc +flatten + +equiv_opt -run :prove -map +/nexus/cells_sim.v synth_nexus +miter -equiv -make_assert -flatten gold gate miter +sat -verify -prove-asserts -show-public -set-at 1 in_reset 1 -seq 20 -prove-skip 1 miter + +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd fsm # Constrain all select calls below inside the top module + +stat + +select -assert-max 1 t:INV +select -assert-max 2 t:LUT4 +select -assert-max 6 t:WIDEFN9 +select -assert-count 6 t:FD1P3IX +select -assert-none t:LUT4 t:FD1P3IX t:WIDEFN9 t:INV t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/logic.ys b/tests/arch/nexus/logic.ys new file mode 100644 index 000000000..cff61b509 --- /dev/null +++ b/tests/arch/nexus/logic.ys @@ -0,0 +1,8 @@ +read_verilog ../common/logic.v +hierarchy -top top +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module +select -assert-count 8 t:LUT4 +select -assert-none t:LUT4 t:INV t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/lutram.ys b/tests/arch/nexus/lutram.ys new file mode 100644 index 000000000..cd645f717 --- /dev/null +++ b/tests/arch/nexus/lutram.ys @@ -0,0 +1,19 @@ +read_verilog ../common/lutram.v +hierarchy -top lutram_1w1r +proc +memory -nomap +equiv_opt -run :prove -map +/nexus/cells_sim.v synth_nexus +memory +opt -full + +miter -equiv -flatten -make_assert -make_outputs gold gate miter +sat -verify -prove-asserts -seq 5 -set-init-zero -show-inputs -show-outputs miter + +design -load postopt +cd lutram_1w1r +stat +select -assert-count 8 t:WIDEFN9 +select -assert-count 16 t:LUT4 +select -assert-count 8 t:DPR16X4 +select -assert-count 36 t:FD1P3IX +select -assert-none t:DPR16X4 t:FD1P3IX t:WIDEFN9 t:LUT4 t:INV t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/mul.ys b/tests/arch/nexus/mul.ys new file mode 100644 index 000000000..27ea3e04e --- /dev/null +++ b/tests/arch/nexus/mul.ys @@ -0,0 +1,28 @@ +read_verilog ../common/mul.v +hierarchy -top top +proc + +design -save read + +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module +select -assert-count 7 t:CCU2 +select -assert-max 5 t:WIDEFN9 +select -assert-max 62 t:LUT4 + +select -assert-none t:IB t:OB t:VLO t:VHI t:LUT4 t:CCU2 t:WIDEFN9 %% t:* %D + +design -load read + +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus -abc9 +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module + +stat + +select -assert-count 7 t:CCU2 +select -assert-max 12 t:WIDEFN9 +select -assert-max 58 t:LUT4 + +select -assert-none t:IB t:OB t:VLO t:VHI t:LUT4 t:CCU2 t:WIDEFN9 %% t:* %D diff --git a/tests/arch/nexus/mux.ys b/tests/arch/nexus/mux.ys new file mode 100644 index 000000000..0e12d674a --- /dev/null +++ b/tests/arch/nexus/mux.ys @@ -0,0 +1,43 @@ +read_verilog ../common/mux.v +design -save read + +hierarchy -top mux2 +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd mux2 # Constrain all select calls below inside the top module +select -assert-count 1 t:LUT4 +select -assert-none t:IB t:OB t:VLO t:VHI t:LUT4 t:WIDEFN9 %% t:* %D + +design -load read +hierarchy -top mux4 +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd mux4 # Constrain all select calls below inside the top module +select -assert-count 1 t:WIDEFN9 + +select -assert-none t:IB t:OB t:VLO t:VHI t:LUT4 t:WIDEFN9 %% t:* %D + +design -load read +hierarchy -top mux8 +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd mux8 # Constrain all select calls below inside the top module +select -assert-count 4 t:LUT4 +select -assert-count 1 t:WIDEFN9 + +select -assert-none t:IB t:OB t:VLO t:VHI t:LUT4 t:WIDEFN9 %% t:* %D + +design -load read +hierarchy -top mux16 +proc +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd mux16 # Constrain all select calls below inside the top module +select -assert-min 11 t:LUT4 +select -assert-max 12 t:LUT4 +select -assert-count 1 t:WIDEFN9 + +select -assert-none t:IB t:OB t:VLO t:VHI t:LUT4 t:WIDEFN9 %% t:* %D diff --git a/tests/arch/nexus/run-test.sh b/tests/arch/nexus/run-test.sh new file mode 100644 index 000000000..bf19b887d --- /dev/null +++ b/tests/arch/nexus/run-test.sh @@ -0,0 +1,20 @@ +#!/usr/bin/env bash +set -e +{ +echo "all::" +for x in *.ys; do + echo "all:: run-$x" + echo "run-$x:" + echo " @echo 'Running $x..'" + echo " @../../../yosys -ql ${x%.ys}.log -w 'Yosys has only limited support for tri-state logic at the moment.' $x" +done +for s in *.sh; do + if [ "$s" != "run-test.sh" ]; then + echo "all:: run-$s" + echo "run-$s:" + echo " @echo 'Running $s..'" + echo " @bash $s" + fi +done +} > run-test.mk +exec ${MAKE:-make} -f run-test.mk diff --git a/tests/arch/nexus/shifter.ys b/tests/arch/nexus/shifter.ys new file mode 100644 index 000000000..a8e34b0f9 --- /dev/null +++ b/tests/arch/nexus/shifter.ys @@ -0,0 +1,9 @@ +read_verilog ../common/shifter.v +hierarchy -top top +proc +flatten +equiv_opt -assert -map +/nexus/cells_sim.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd top # Constrain all select calls below inside the top module +select -assert-count 8 t:FD1P3IX +select -assert-none t:FD1P3IX t:WIDEFN9 t:INV t:IB t:OB t:VLO t:VHI %% t:* %D diff --git a/tests/arch/nexus/tribuf.ys b/tests/arch/nexus/tribuf.ys new file mode 100644 index 000000000..70fb7cb5f --- /dev/null +++ b/tests/arch/nexus/tribuf.ys @@ -0,0 +1,12 @@ +read_verilog ../common/tribuf.v +hierarchy -top tristate +proc +tribuf +flatten +synth +equiv_opt -assert -map +/nexus/cells_sim.v -map +/simcells.v synth_nexus # equivalency check +design -load postopt # load the post-opt design (otherwise equiv_opt loads the pre-opt design) +cd tristate # Constrain all select calls below inside the top module +select -assert-count 1 t:OBZ +select -assert-count 1 t:INV +select -assert-none t:OBZ t:INV t:IB t:OB t:VLO t:VHI %% t:* %D |