diff --git a/src/OpenRoad.cc b/src/OpenRoad.cc index 3570a30e7bc..8766e58f2cf 100644 --- a/src/OpenRoad.cc +++ b/src/OpenRoad.cc @@ -668,6 +668,9 @@ void OpenRoad::setThreadCount(int threads, bool print_info) // place limits on tools with threads sta_->setThreadCount(threads_); + if (global_router_ != nullptr) { + global_router_->setNumThreads(threads_); + } } void OpenRoad::setThreadCount(const char* threads, bool print_info) diff --git a/src/grt/README.md b/src/grt/README.md index 8c872155897..573a420214a 100644 --- a/src/grt/README.md +++ b/src/grt/README.md @@ -26,6 +26,7 @@ global_route [-critical_nets_percentage percent] [-skip_large_fanout_nets fanout] [-allow_congestion] + [-snapshot_batched_width width] [-verbose] [-start_incremental] [-end_incremental] @@ -52,6 +53,7 @@ global_route | `-use_cugr` | This flag run GRT using CUGR as the router solver. NOTE: this is not ready for production. | | `-resistance_aware` | This flag enables resistance-aware layer assignment and 3D routing. NOTE: this is not ready for production. | | `-infinite_cap` | Enables "infinite" gcell capacity for testing purpose. NOTE: this is not recommended for production flows. | +| `-snapshot_batched_width` | Set the semantic width of snapshot-batched routing (max batches per wave). The default is `0`, preserving the non-batched behavior. Set a positive integer to enable batched routing; allowed values are integers `[1, MAX_INT]`. Execution width still follows `set_thread_count`. NOTE: this is not recommended for production flows; it is intended for exploration and research projects. | ### Set Routing Layers diff --git a/src/grt/include/grt/GlobalRouter.h b/src/grt/include/grt/GlobalRouter.h index 1475619cb74..0a1a2eb61da 100644 --- a/src/grt/include/grt/GlobalRouter.h +++ b/src/grt/include/grt/GlobalRouter.h @@ -155,12 +155,16 @@ class GlobalRouter void setGridOrigin(int x, int y); void setAllowCongestion(bool allow_congestion); void setResistanceAware(bool resistance_aware); + void setSnapshotBatchedWidth(int snapshot_batched_width); + int getSnapshotBatchedWidth() const; + int getSnapshotBatchCount() const; void setMacroExtension(int macro_extension); void setUseCUGR(bool use_cugr) { use_cugr_ = use_cugr; }; void setSkipLargeFanoutNets(int skip_large_fanout) { skip_large_fanout_ = skip_large_fanout; }; + void setNumThreads(int num_threads); void setInfiniteCapacity(bool infinite_capacity); @@ -531,6 +535,8 @@ class GlobalRouter int congestion_report_iter_step_; bool allow_congestion_; bool resistance_aware_{false}; + int snapshot_batched_width_{0}; + int num_threads_; std::vector vertical_capacities_; std::vector horizontal_capacities_; int macro_extension_; diff --git a/src/grt/src/GlobalRouter.cpp b/src/grt/src/GlobalRouter.cpp index 812f79e819f..743ce42505a 100644 --- a/src/grt/src/GlobalRouter.cpp +++ b/src/grt/src/GlobalRouter.cpp @@ -87,6 +87,7 @@ GlobalRouter::GlobalRouter(utl::Logger* logger, adjustment_(0.0), congestion_report_iter_step_(0), allow_congestion_(false), + num_threads_(1), macro_extension_(0), initialized_(false), total_diodes_count_(0), @@ -110,6 +111,28 @@ GlobalRouter::GlobalRouter(utl::Logger* logger, cugr_ = new CUGR(db_, logger_, service_registry_, stt_builder_, sta_); } +void GlobalRouter::setNumThreads(int num_threads) +{ + num_threads_ = num_threads; + fastroute_->setNumThreads(num_threads_); +} + +void GlobalRouter::setSnapshotBatchedWidth(int snapshot_batched_width) +{ + snapshot_batched_width_ = snapshot_batched_width; + fastroute_->setSnapshotBatchedWidth(snapshot_batched_width_); +} + +int GlobalRouter::getSnapshotBatchedWidth() const +{ + return fastroute_->getSnapshotBatchedWidth(); +} + +int GlobalRouter::getSnapshotBatchCount() const +{ + return fastroute_->getSnapshotBatchCount(); +} + void GlobalRouter::initGui( gui::HeatMapSourceHandle routing_congestion_data_source, gui::HeatMapSourceHandle routing_congestion_data_source_rudy) @@ -2317,6 +2340,7 @@ void GlobalRouter::configFastRoute() fastroute_->setOverflowIterations(congestion_iterations_); fastroute_->setCongestionReportIterStep(congestion_report_iter_step_); fastroute_->setResistanceAware(resistance_aware_); + fastroute_->setSnapshotBatchedWidth(snapshot_batched_width_); if (congestion_file_name_ != nullptr) { fastroute_->setCongestionReportFile(congestion_file_name_); @@ -3838,9 +3862,17 @@ int GlobalRouter::computeNetWirelength(odb::dbNet* db_net) void GlobalRouter::computeWirelength() { + std::vector routed_nets; + routed_nets.reserve(routes_.size()); + for (const auto& [db_net, route] : routes_) { + routed_nets.push_back(db_net); + } + int64_t total_wirelength = 0; - for (auto& net_route : routes_) { - total_wirelength += computeNetWirelength(net_route.first); +#pragma omp parallel for num_threads(num_threads_) \ + reduction(+ : total_wirelength) + for (int i = 0; i < static_cast(routed_nets.size()); i++) { + total_wirelength += computeNetWirelength(routed_nets[i]); } logger_->metric("global_route__wirelength", total_wirelength / block_->getDefUnits()); diff --git a/src/grt/src/GlobalRouter.i b/src/grt/src/GlobalRouter.i index 6b608123e7f..f75fedf67b4 100644 --- a/src/grt/src/GlobalRouter.i +++ b/src/grt/src/GlobalRouter.i @@ -110,6 +110,24 @@ set_resistance_aware(bool resistance_aware) getGlobalRouter()->setResistanceAware(resistance_aware); } +void +set_snapshot_batched_width(int snapshot_batched_width) +{ + getGlobalRouter()->setSnapshotBatchedWidth(snapshot_batched_width); +} + +int +get_snapshot_batched_width() +{ + return getGlobalRouter()->getSnapshotBatchedWidth(); +} + +int +get_snapshot_batch_count() +{ + return getGlobalRouter()->getSnapshotBatchCount(); +} + void set_critical_nets_percentage(float criticalNetsPercentage) { @@ -178,6 +196,8 @@ void end_incremental() void global_route() { + const int num_threads = ord::OpenRoad::openRoad()->getThreadCount(); + getGlobalRouter()->setNumThreads(num_threads); getGlobalRouter()->globalRoute(true); } diff --git a/src/grt/src/GlobalRouter.tcl b/src/grt/src/GlobalRouter.tcl index 603adb88d53..a8b40b9e953 100644 --- a/src/grt/src/GlobalRouter.tcl +++ b/src/grt/src/GlobalRouter.tcl @@ -148,6 +148,7 @@ sta::define_cmd_args "global_route" {[-guide_file out_file] \ [-critical_nets_percentage percent] \ [-skip_large_fanout_nets fanout] \ [-allow_congestion] \ + [-snapshot_batched_width width] \ [-verbose] \ [-start_incremental] \ [-end_incremental] \ @@ -159,8 +160,8 @@ sta::define_cmd_args "global_route" {[-guide_file out_file] \ proc global_route { args } { sta::parse_key_args "global_route" args \ keys {-guide_file -congestion_iterations -congestion_report_file \ - -grid_origin -critical_nets_percentage -congestion_report_iter_step\ - -skip_large_fanout_nets + -grid_origin -critical_nets_percentage -congestion_report_iter_step \ + -skip_large_fanout_nets -snapshot_batched_width } \ flags {-allow_congestion -resistance_aware -infinite_cap -verbose -start_incremental \ -end_incremental -use_cugr} @@ -229,6 +230,15 @@ proc global_route { args } { set resistance_aware [info exists flags(-resistance_aware)] grt::set_resistance_aware $resistance_aware + if { [info exists keys(-snapshot_batched_width)] } { + set snapshot_batched_width $keys(-snapshot_batched_width) + sta::check_positive_integer "-snapshot_batched_width" \ + $snapshot_batched_width + } else { + set snapshot_batched_width 0 + } + grt::set_snapshot_batched_width $snapshot_batched_width + set infinite_cap [info exists flags(-infinite_cap)] grt::set_infinite_cap $infinite_cap diff --git a/src/grt/src/fastroute/include/FastRoute.h b/src/grt/src/fastroute/include/FastRoute.h index a13b4f9b5c0..06849319151 100644 --- a/src/grt/src/fastroute/include/FastRoute.h +++ b/src/grt/src/fastroute/include/FastRoute.h @@ -169,6 +169,7 @@ class FastRouteCore NetRouteMap run(); int totalOverflow() const { return total_overflow_; } bool has2Doverflow() const { return has_2D_overflow_; } + int getSnapshotBatchCount() const { return snapshot_batch_count_; } void getBlockage(odb::dbTechLayer* layer, int x, int y, @@ -244,6 +245,12 @@ class FastRouteCore void setCongestionReportFile(const char* congestion_file_name); void setGridMax(int x_max, int y_max); void setDetourPenalty(int penalty); + void setNumThreads(int num_threads) { num_threads_ = num_threads; } + void setSnapshotBatchedWidth(int snapshot_batched_width) + { + snapshot_batched_width_ = snapshot_batched_width; + } + int getSnapshotBatchedWidth() const { return snapshot_batched_width_; } void getCongestionNets(std::set& congestion_nets); void computeCongestionInformation(); std::vector getOriginalResources(); @@ -326,6 +333,24 @@ class FastRouteCore int L, const CostParams& cost_params, float& slack_th); + void mazeRouteMSMDSequential(int iter, + int expand, + int ripup_threshold, + int maze_edge_threshold, + bool ordering, + int via, + int L, + const CostParams& cost_params, + float& slack_th); + bool runSnapshotBatchedMazeRoute(int iter, + int expand, + int ripup_threshold, + int maze_edge_threshold, + bool ordering, + int via, + int L, + const CostParams& cost_params, + float& slack_th); void convertToMazeroute(); int getOverflow2D(int* maxOverflow); int getOverflow2Dmaze(int* maxOverflow, int* tUsage); @@ -621,6 +646,47 @@ class FastRouteCore void copyBR(); void copyRS(); void freeRR(); + std::vector getMazeRouteNetOrder(bool ordering, float& slack_th); + bool hasNonSoftNdrNets() const; + int resolveSnapshotExecutionThreads(int work_items) const; + int resolveSnapshotWaveSize(int available_batch_count) const; + int resolveSnapshotBaseBatchSize(int net_count) const; + bool useSnapshotBatchRouting(int net_count) const; + int resolveSnapshotBatchIterationLimit(int net_count) const; + bool useSnapshotBatchRoutingForIteration(int iter, int net_count) const; + int resolveSnapshotNetsForBatch(int iter, int net_count) const; + std::unique_ptr buildSnapshotBatchWorker() const; + void syncSnapshotBatchWorker(const FastRouteCore& snapshot, + const std::vector& batch_net_ids); + void applySnapshotBatchRoute(int net_id, StTree&& sttree); + void updatePlanarNetUsage(const StTree& sttree, FrNet* net, int edge_cost); + void resetSnapshotBatchStats(); + + // Timing data collected during run(), reported via reportRunMetrics(). + struct RunTimings + { + double total = 0.0; + double initial_rsmt = 0.0; + double route_l = 0.0; + double congestion_rsmt = 0.0; + double new_route_l = 0.0; + double spiral = 0.0; + double route_z = 0.0; + double monotonic = 0.0; + double overflow_iterations = 0.0; + double finalization = 0.0; + }; + void reportRunMetrics(const RunTimings& timings, + int num_vias, + int final_length); + + // Returns true if the overflow loop should break due to snapshot + // convergence patience being exhausted. + bool checkSnapshotConvergence(int past_cong, + int& bmfl, + int& bwcnt, + int iter, + int snapshot_batch_count_before); int edgeShift(stt::Tree& t, int net); int edgeShiftNew(stt::Tree& t, int net); @@ -635,6 +701,23 @@ class FastRouteCore static const int BIG_INT = 1e9; // big integer used as infinity static const int HCOST = 5000; + // Snapshot-batched routing constants. + // Nets are partitioned into batches and routed in parallel waves against + // a frozen graph snapshot. The user-supplied snapshot_batched_width_ + // controls the maximum batches per wave (independent of thread count) and + // gates the minimum routable net count (2 * width) needed to attempt + // batching. + // + // kSnapshotLowOverflowForSerialCleanup / + // kSnapshotLowMaxOverflowForSerialCleanup: + // overflow thresholds below which batching is disabled for the run, + // because the design is already near-converged. + // kSnapshotCleanupPatience: how many non-improving iterations to tolerate + // in the snapshot cleanup phase before breaking. + static constexpr int kSnapshotLowOverflowForSerialCleanup = 1500; + static constexpr int kSnapshotLowMaxOverflowForSerialCleanup = 32; + static constexpr int kSnapshotCleanupPatience = 12; + int max_degree_; std::vector cap_per_layer_; std::vector usage_per_layer_; @@ -647,6 +730,12 @@ class FastRouteCore std::string congestion_file_name_; std::vector layer_directions_; std::vector db_layers_; + int num_threads_; + // When false, nets_ contains borrowed pointers from a parent + // FastRouteCore (snapshot-batch workers). Workers must not outlive + // the parent's nets_ lifetime. + bool owns_nets_; + int snapshot_batched_width_; int x_range_; int y_range_; @@ -746,6 +835,15 @@ class FastRouteCore std::vector net_ids_; + // Maze 2D variables + std::vector pop_heap2_2D_; + std::vector src_heap_2D_; + std::vector dest_heap_2D_; + multi_array d1_2D_; + multi_array d2_2D_; + std::vector visited_2D_; + std::vector queue_2D_; + // Maze 3D variables multi_array directions_3D_; multi_array corr_edge_3D_; @@ -756,6 +854,15 @@ class FastRouteCore multi_array d1_3D_; multi_array d2_3D_; multi_array path_len_3D_; + double snapshot_batch_sync_time_ = 0.0; + double snapshot_batch_route_time_ = 0.0; + double snapshot_batch_apply_time_ = 0.0; + int snapshot_batch_count_ = 0; + int snapshot_batch_net_count_ = 0; + int snapshot_batch_wave_count_ = 0; + bool snapshot_batch_disabled_for_run_ = false; + bool snapshot_cleanup_active_ = false; + bool has_non_soft_ndr_nets_ = false; int detour_penalty_; }; diff --git a/src/grt/src/fastroute/include/Graph2D.h b/src/grt/src/fastroute/include/Graph2D.h index 4cee0d84897..c7af8aadaee 100644 --- a/src/grt/src/fastroute/include/Graph2D.h +++ b/src/grt/src/fastroute/include/Graph2D.h @@ -55,6 +55,7 @@ class Graph2D void init(int x_grid, int y_grid, int num_layers, utl::Logger* logger); void InitEstUsage(); void InitLastUsage(int upType); + void copyRoutingStateFrom(const Graph2D& other, bool include_ndr_state); void clear(); void clearUsed(); bool hasEdges() const; diff --git a/src/grt/src/fastroute/src/FastRoute.cpp b/src/grt/src/fastroute/src/FastRoute.cpp index 146cc950450..3b6b256973b 100644 --- a/src/grt/src/fastroute/src/FastRoute.cpp +++ b/src/grt/src/fastroute/src/FastRoute.cpp @@ -22,9 +22,11 @@ #include "odb/geom.h" #include "stt/SteinerTreeBuilder.h" #include "utl/Logger.h" +#include "utl/timer.h" namespace grt { +using utl::DebugScopedTimer; using utl::GRT; FastRouteCore::FastRouteCore(odb::dbDatabase* db, @@ -36,6 +38,9 @@ FastRouteCore::FastRouteCore(odb::dbDatabase* db, db_(db), overflow_iterations_(0), congestion_report_iter_step_(0), + num_threads_(1), + owns_nets_(true), + snapshot_batched_width_(0), x_range_(0), y_range_(0), worst_fanout_(0), @@ -134,6 +139,101 @@ void FastRouteCore::clear() horizontal_blocked_intervals_.clear(); detour_penalty_ = 0; + resetSnapshotBatchStats(); +} + +void FastRouteCore::resetSnapshotBatchStats() +{ + snapshot_batch_sync_time_ = 0.0; + snapshot_batch_route_time_ = 0.0; + snapshot_batch_apply_time_ = 0.0; + snapshot_batch_count_ = 0; + snapshot_batch_net_count_ = 0; + snapshot_batch_wave_count_ = 0; + snapshot_batch_disabled_for_run_ = false; + snapshot_cleanup_active_ = false; + has_non_soft_ndr_nets_ = false; +} + +void FastRouteCore::reportRunMetrics(const RunTimings& timings, + const int num_vias, + const int final_length) +{ + logger_->metric("global_route__fastroute__run_s", timings.total); + logger_->metric("global_route__fastroute__initial_rsmt_s", + timings.initial_rsmt); + logger_->metric("global_route__fastroute__route_l_s", timings.route_l); + logger_->metric("global_route__fastroute__congestion_rsmt_s", + timings.congestion_rsmt); + logger_->metric("global_route__fastroute__new_route_l_s", + timings.new_route_l); + logger_->metric("global_route__fastroute__spiral_s", timings.spiral); + logger_->metric("global_route__fastroute__route_z_s", timings.route_z); + logger_->metric("global_route__fastroute__monotonic_s", timings.monotonic); + logger_->metric("global_route__fastroute__overflow_iterations_s", + timings.overflow_iterations); + logger_->metric("global_route__fastroute__finalization_s", + timings.finalization); + logger_->metric("global_route__fastroute__snapshot_batch_route_s", + snapshot_batch_route_time_); + logger_->metric("global_route__fastroute__snapshot_batch_apply_s", + snapshot_batch_apply_time_); + logger_->metric("global_route__fastroute__snapshot_batch_sync_s", + snapshot_batch_sync_time_); + logger_->metric("global_route__fastroute__snapshot_batch_count", + snapshot_batch_count_); + logger_->metric("global_route__fastroute__snapshot_batch_nets", + snapshot_batch_net_count_); + logger_->metric("global_route__fastroute__snapshot_batch_wave_count", + snapshot_batch_wave_count_); + if (snapshot_batch_count_ > 0) { + debugPrint(logger_, + GRT, + "timer", + 1, + "Snapshot batch totals: sync {} route {} apply {} waves {} " + "batches {} nets {}.", + snapshot_batch_sync_time_, + snapshot_batch_route_time_, + snapshot_batch_apply_time_, + snapshot_batch_wave_count_, + snapshot_batch_count_, + snapshot_batch_net_count_); + } + logger_->metric("global_route__vias", num_vias); + if (verbose_) { + logger_->info(GRT, 111, "Final number of vias: {}", num_vias); + logger_->info( + GRT, 112, "Final usage 3D: {}", (final_length + 3 * num_vias)); + } +} + +bool FastRouteCore::checkSnapshotConvergence( + const int past_cong, + int& bmfl, + int& bwcnt, + const int iter, + const int snapshot_batch_count_before) +{ + snapshot_cleanup_active_ + = snapshot_cleanup_active_ + || snapshot_batch_count_ > snapshot_batch_count_before; + + if (snapshot_cleanup_active_ && past_cong < bmfl) { + copyRS(); + bmfl = past_cong; + bwcnt = 0; + } + + if (snapshot_cleanup_active_ + && iter > resolveSnapshotBatchIterationLimit(net_ids_.size())) { + if (past_cong >= bmfl) { + bwcnt++; + } + return bwcnt > kSnapshotCleanupPatience; + } + + return false; } void FastRouteCore::clearNets() @@ -142,8 +242,10 @@ void FastRouteCore::clearNets() sttrees_.clear(); } - for (FrNet* net : nets_) { - delete net; + if (owns_nets_) { + for (FrNet* net : nets_) { + delete net; + } } nets_.clear(); net_ids_.clear(); @@ -194,12 +296,23 @@ void FastRouteCore::setGridsAndLayers(int x, int y, int nLayers) cost_v_test_.resize(x_range_); // Vertical segment cost cost_tb_test_.resize(x_range_); // Top and bottom boundary cost + // maze2D variables + int64 total_size = static_cast(y_grid_) * x_range_; + pop_heap2_2D_.resize(total_size, false); + + total_size = static_cast(y_grid_) * x_grid_; + src_heap_2D_.resize(total_size); + dest_heap_2D_.resize(total_size); + + d1_2D_.resize(boost::extents[y_range_][x_range_]); + d2_2D_.resize(boost::extents[y_range_][x_range_]); + // maze3D variables directions_3D_.resize(boost::extents[num_layers_][y_grid_][x_grid_]); corr_edge_3D_.resize(boost::extents[num_layers_][y_grid_][x_grid_]); pr_3D_.resize(boost::extents[num_layers_][y_grid_][x_grid_]); - int64 total_size = static_cast(num_layers_) * y_range_ * x_range_; + total_size = static_cast(num_layers_) * y_range_ * x_range_; pop_heap2_3D_.resize(total_size, false); // allocate memory for priority queue @@ -934,6 +1047,237 @@ void FastRouteCore::initAuxVar() parent_y3_.resize(boost::extents[y_grid_][x_grid_]); } +std::vector FastRouteCore::getMazeRouteNetOrder(const bool ordering, + float& slack_th) +{ + if (ordering) { + if (critical_nets_percentage_) { + slack_th = CalculatePartialSlack(); + } + StNetOrder(); + + std::vector ordered_net_ids; + ordered_net_ids.reserve(net_ids_.size()); + for (const auto& order_tree : tree_order_cong_) { + ordered_net_ids.push_back(order_tree.treeIndex); + } + return ordered_net_ids; + } + + return net_ids_; +} + +bool FastRouteCore::hasNonSoftNdrNets() const +{ + for (const int net_id : net_ids_) { + FrNet* net = nets_[net_id]; + if (net == nullptr) { + continue; + } + if (net->getDbNet()->getNonDefaultRule() != nullptr && !net->isSoftNDR()) { + return true; + } + } + return false; +} + +int FastRouteCore::resolveSnapshotExecutionThreads(const int work_items) const +{ + const int requested_threads = snapshot_batched_width_ > 0 ? num_threads_ : 1; + return std::min(work_items, std::max(1, requested_threads)); +} + +int FastRouteCore::resolveSnapshotWaveSize( + const int available_batch_count) const +{ + return std::min(available_batch_count, snapshot_batched_width_); +} + +int FastRouteCore::resolveSnapshotBaseBatchSize(const int net_count) const +{ + return std::min(net_count, 2 * snapshot_batched_width_); +} + +bool FastRouteCore::useSnapshotBatchRouting(const int net_count) const +{ + return snapshot_batched_width_ > 0 && !snapshot_batch_disabled_for_run_ + && !debug_->isOn() && net_count > 2 * snapshot_batched_width_ + && !has_non_soft_ndr_nets_; +} + +int FastRouteCore::resolveSnapshotBatchIterationLimit(const int net_count) const +{ + const int overflow_scaled_limit + = std::max(4, std::min(overflow_iterations_ / 24, 8)); + const int net_scaled_limit = std::max(4, std::min(net_count / 128, 16)); + return std::max(overflow_scaled_limit, net_scaled_limit); +} + +bool FastRouteCore::useSnapshotBatchRoutingForIteration( + const int iter, + const int net_count) const +{ + if (!useSnapshotBatchRouting(net_count)) { + return false; + } + + // Snapshot-batched routing is intentionally not exact-preserving, but late + // cleanup is still sensitive to route-choice drift. Keep the aggressive + // snapshot mode for the early/high-overflow phase and fall back to the + // serial kernel later. + return iter <= resolveSnapshotBatchIterationLimit(net_count); +} + +int FastRouteCore::resolveSnapshotNetsForBatch(const int iter, + const int net_count) const +{ + const int nets_for_batch = resolveSnapshotBaseBatchSize(net_count); + + const int early_iteration_limit + = resolveSnapshotBatchIterationLimit(net_count); + const int scaled_iter = iter * 100; + // Thresholds on iteration progress (% of early_iteration_limit) that + // progressively shrink the batch size for finer-grained convergence. + constexpr int kBatchHalfThreshold = 25; + constexpr int kBatchQuarterThreshold = 50; + constexpr int kBatchSingleThreshold = 75; + + if (scaled_iter > kBatchSingleThreshold * early_iteration_limit) { + return 1; + } + if (scaled_iter > kBatchQuarterThreshold * early_iteration_limit) { + return std::max(1, nets_for_batch / 4); + } + if (scaled_iter > kBatchHalfThreshold * early_iteration_limit) { + return std::max(1, nets_for_batch / 2); + } + return nets_for_batch; +} + +// Build a lightweight worker that shares read-only config and net pointers +// with the parent but owns its own routing state (graph2d_, sttrees_, etc.). +// NOTE: new members added to FastRouteCore may need to be copied here; +// consider grouping routing config into a struct if this list keeps growing. +std::unique_ptr FastRouteCore::buildSnapshotBatchWorker() const +{ + auto worker = std::make_unique( + db_, logger_, service_registry_, stt_builder_, sta_); + + worker->owns_nets_ = false; + worker->snapshot_batched_width_ = 0; + worker->num_threads_ = 1; + + worker->max_degree_ = max_degree_; + worker->cap_per_layer_ = cap_per_layer_; + worker->usage_per_layer_ = usage_per_layer_; + worker->overflow_per_layer_ = overflow_per_layer_; + worker->max_h_overflow_ = max_h_overflow_; + worker->max_v_overflow_ = max_v_overflow_; + worker->overflow_iterations_ = overflow_iterations_; + worker->congestion_report_iter_step_ = congestion_report_iter_step_; + worker->congestion_file_name_ = congestion_file_name_; + worker->layer_directions_ = layer_directions_; + worker->db_layers_ = db_layers_; + worker->en_estimate_parasitics_ = en_estimate_parasitics_; + worker->resistance_aware_ = resistance_aware_; + worker->enable_resistance_aware_ = enable_resistance_aware_; + worker->is_3d_step_ = is_3d_step_; + worker->is_incremental_grt_ = is_incremental_grt_; + worker->worst_slack_ = worst_slack_; + worker->worst_net_resistance_ = worst_net_resistance_; + worker->worst_net_length_ = worst_net_length_; + worker->worst_fanout_ = worst_fanout_; + worker->num_adjust_ = num_adjust_; + worker->v_capacity_ = v_capacity_; + worker->h_capacity_ = h_capacity_; + worker->x_corner_ = x_corner_; + worker->y_corner_ = y_corner_; + worker->tile_size_ = tile_size_; + worker->enlarge_ = enlarge_; + worker->costheight_ = costheight_; + worker->ahth_ = ahth_; + worker->total_overflow_ = total_overflow_; + worker->has_2D_overflow_ = has_2D_overflow_; + worker->verbose_ = verbose_; + worker->critical_nets_percentage_ = critical_nets_percentage_; + worker->via_cost_ = via_cost_; + worker->mazeedge_threshold_ = mazeedge_threshold_; + worker->v_capacity_lb_ = v_capacity_lb_; + worker->h_capacity_lb_ = h_capacity_lb_; + worker->regular_x_ = regular_x_; + worker->regular_y_ = regular_y_; + worker->detour_penalty_ = detour_penalty_; + + worker->setGridsAndLayers(x_grid_, y_grid_, num_layers_); + worker->setGridMax(x_grid_max_, y_grid_max_); + worker->v_capacity_3D_ = v_capacity_3D_; + worker->h_capacity_3D_ = h_capacity_3D_; + worker->last_col_v_capacity_3D_ = last_col_v_capacity_3D_; + worker->last_row_h_capacity_3D_ = last_row_h_capacity_3D_; + worker->initAuxVar(); + + worker->nets_ = nets_; + worker->db_net_id_map_ = db_net_id_map_; + worker->gxs_ = gxs_; + worker->gys_ = gys_; + worker->gs_ = gs_; + worker->xcor_.resize(xcor_.size()); + worker->ycor_.resize(ycor_.size()); + worker->dcor_.resize(dcor_.size()); + worker->sttrees_.resize(sttrees_.size()); + + return worker; +} + +void FastRouteCore::syncSnapshotBatchWorker( + const FastRouteCore& snapshot, + const std::vector& batch_net_ids) +{ + graph2d_.copyRoutingStateFrom(snapshot.graph2d_, false); + total_overflow_ = snapshot.total_overflow_; + has_2D_overflow_ = snapshot.has_2D_overflow_; + net_ids_ = batch_net_ids; + + for (const int net_id : batch_net_ids) { + sttrees_[net_id] = snapshot.sttrees_[net_id]; + } +} + +void FastRouteCore::updatePlanarNetUsage(const StTree& sttree, + FrNet* net, + const int edge_cost) +{ + for (const TreeEdge& treeedge : sttree.edges) { + if (treeedge.route.routelen <= 0 || treeedge.route.grids.empty()) { + continue; + } + + const auto& grids = treeedge.route.grids; + for (int i = 0; i < treeedge.route.routelen; i++) { + if (grids[i].x == grids[i + 1].x && grids[i].y == grids[i + 1].y) { + continue; + } + + if (grids[i].x == grids[i + 1].x) { + const int min_y = std::min(grids[i].y, grids[i + 1].y); + graph2d_.updateUsageV(grids[i].x, min_y, net, edge_cost); + } else if (grids[i].y == grids[i + 1].y) { + const int min_x = std::min(grids[i].x, grids[i + 1].x); + graph2d_.updateUsageH(min_x, grids[i].y, net, edge_cost); + } + } + } +} + +void FastRouteCore::applySnapshotBatchRoute(const int net_id, StTree&& sttree) +{ + FrNet* net = nets_[net_id]; + const int edge_cost = static_cast(net->getEdgeCost()); + updatePlanarNetUsage(sttrees_[net_id], net, -edge_cost); + sttrees_[net_id] = std::move(sttree); + updatePlanarNetUsage(sttrees_[net_id], net, edge_cost); +} + NetRouteMap FastRouteCore::getRoutes() { NetRouteMap routes; @@ -1434,6 +1778,13 @@ NetRouteMap FastRouteCore::run() return getRoutes(); } + resetSnapshotBatchStats(); + has_non_soft_ndr_nets_ = hasNonSoftNdrNets(); + + RunTimings timings; + const DebugScopedTimer total_timer( + timings.total, logger_, GRT, "timer", 1, "FastRoute run: {}"); + graph2d_.clearUsed(); // Rebuild used grids in graph2d during incremental GRT to account for // segments created during merge nets. @@ -1487,39 +1838,71 @@ NetRouteMap FastRouteCore::run() // call FLUTE to generate RSMT and break the nets into segments (2-pin nets) via_cost_ = 0; - gen_brk_RSMT(false, false, false, false, noADJ); + { + const DebugScopedTimer timer( + timings.initial_rsmt, logger_, GRT, "timer", 1, "Initial RSMT: {}"); + gen_brk_RSMT(false, false, false, false, noADJ); + } if (logger_->debugCheck(GRT, "grtSteps", 1)) { logger_->report("After RSMT"); } // First time L routing - routeLAll(true); + { + const DebugScopedTimer timer( + timings.route_l, logger_, GRT, "timer", 1, "Initial routeLAll: {}"); + routeLAll(true); + } if (logger_->debugCheck(GRT, "grtSteps", 1)) { logger_->report("After routeLAll"); } // Congestion-driven rip-up and reroute L - gen_brk_RSMT(true, true, true, false, noADJ); + { + const DebugScopedTimer timer(timings.congestion_rsmt, + logger_, + GRT, + "timer", + 1, + "Congestion-driven RSMT: {}"); + gen_brk_RSMT(true, true, true, false, noADJ); + } getOverflow2D(&maxOverflow); if (logger_->debugCheck(GRT, "grtSteps", 1)) { logger_->report("After congestion-driven RSMT"); } // New rip-up and reroute L via-guided - newrouteLAll(false, true); + { + const DebugScopedTimer timer(timings.new_route_l, + logger_, + GRT, + "timer", + 1, + "Via-guided routeLAll: {}"); + newrouteLAll(false, true); + } getOverflow2D(&maxOverflow); if (logger_->debugCheck(GRT, "grtSteps", 1)) { logger_->report("After newRouteLAll"); } // Rip-up and reroute using spiral route - spiralRouteAll(); + { + const DebugScopedTimer timer( + timings.spiral, logger_, GRT, "timer", 1, "Spiral routing: {}"); + spiralRouteAll(); + } if (logger_->debugCheck(GRT, "grtSteps", 1)) { logger_->report("After spiralRouteAll"); } // Rip-up a tree edge according to its ripup type and Z-route it - newrouteZAll(10); + { + const DebugScopedTimer timer( + timings.route_z, logger_, GRT, "timer", 1, "Initial routeZAll: {}"); + newrouteZAll(10); + } int past_cong = getOverflow2D(&maxOverflow); if (logger_->debugCheck(GRT, "grtSteps", 1)) { @@ -1543,6 +1926,8 @@ NetRouteMap FastRouteCore::run() } for (int i = 0; i < LVIter; i++) { + const DebugScopedTimer timer( + timings.monotonic, logger_, GRT, "timer", 1, "Monotonic routing: {}"); logistic_coef = 2.0 / (1 + log(maxOverflow)); debugPrint(logger_, GRT, @@ -1578,6 +1963,13 @@ NetRouteMap FastRouteCore::run() logger_->info(GRT, 101, "Running extra iterations to remove overflow."); } + if (useSnapshotBatchRouting(net_ids_.size()) + && ((total_overflow_ < kSnapshotLowOverflowForSerialCleanup + && maxOverflow < kSnapshotLowMaxOverflowForSerialCleanup) + || total_overflow_ < net_ids_.size())) { + snapshot_batch_disabled_for_run_ = true; + } + // debug mode Rectilinear Steiner Tree before overflow iterations if (debug_->isOn() && debug_->rectilinearSTree) { for (const int& netID : net_ids_) { @@ -1598,276 +1990,291 @@ NetRouteMap FastRouteCore::run() int overflow_increases = -1; int last_total_overflow = 0; float overflow_reduction_percent = -1; - while (total_overflow_ > 0 && i <= overflow_iterations_ - && overflow_increases <= max_overflow_increases) { - if (verbose_) { - logger_->info( - GRT, 102, "Start extra iteration {}/{}", i, overflow_iterations_); - } - - if (THRESH_M > 15) { - THRESH_M -= thStep1; - } else if (THRESH_M >= 2) { - THRESH_M -= thStep2; - } else { - THRESH_M = 0; - } - THRESH_M = std::max(THRESH_M, 0); - - if (total_overflow_ > 2000) { - enlarge_ += ESTEP1; // ENLARGE+(i-1)*ESTEP; - cost_step = CSTEP1; - } else if (total_overflow_ < 500) { - cost_step = CSTEP3; - enlarge_ += ESTEP3; - ripup_threshold = -1; - } else { - cost_step = CSTEP2; - enlarge_ += ESTEP2; - } - graph2d_.updateCongestionHistory(upType, ahth_, stopDEC, max_adj); + { + const DebugScopedTimer timer(timings.overflow_iterations, + logger_, + GRT, + "timer", + 1, + "Overflow iterations: {}"); + while (total_overflow_ > 0 && i <= overflow_iterations_ + && overflow_increases <= max_overflow_increases) { + if (verbose_) { + logger_->info( + GRT, 102, "Start extra iteration {}/{}", i, overflow_iterations_); + } - if (total_overflow_ > 15000 && maxOverflow > 400) { - enlarge_ = std::max(x_grid_, y_grid_) / 30; - slope = BIG_INT; - if (i == 5) { - VIA = 0; - logistic_coef = 1.33; + if (THRESH_M > 15) { + THRESH_M -= thStep1; + } else if (THRESH_M >= 2) { + THRESH_M -= thStep2; + } else { + THRESH_M = 0; + } + THRESH_M = std::max(THRESH_M, 0); + + if (total_overflow_ > 2000) { + enlarge_ += ESTEP1; // ENLARGE+(i-1)*ESTEP; + cost_step = CSTEP1; + } else if (total_overflow_ < 500) { + cost_step = CSTEP3; + enlarge_ += ESTEP3; ripup_threshold = -1; - } else if (i > 6) { - if (i % 2 == 0) { - logistic_coef += 0.5; - } + } else { + cost_step = CSTEP2; + enlarge_ += ESTEP2; } - if (i > 10) { - ripup_threshold = 0; + graph2d_.updateCongestionHistory(upType, ahth_, stopDEC, max_adj); + + if (total_overflow_ > 15000 && maxOverflow > 400) { + enlarge_ = std::max(x_grid_, y_grid_) / 30; + slope = BIG_INT; + if (i == 5) { + VIA = 0; + logistic_coef = 1.33; + ripup_threshold = -1; + } else if (i > 6) { + if (i % 2 == 0) { + logistic_coef += 0.5; + } + } + if (i > 10) { + ripup_threshold = 0; + } } - } - - enlarge_ = std::min(enlarge_, x_grid_ / 2); - costheight_ += cost_step; - mazeedge_threshold_ = THRESH_M; - if (upType == 3) { - logistic_coef = std::max(2.0 / (1 + log(maxOverflow + max_adj)), - logistic_coef); - } else { - logistic_coef - = std::max(2.0 / (1 + log(maxOverflow)), logistic_coef); - } + enlarge_ = std::min(enlarge_, x_grid_ / 2); + costheight_ += cost_step; + mazeedge_threshold_ = THRESH_M; - if (i == 8) { - L = 0; - upType = 2; - graph2d_.InitLastUsage(upType); - } - - if (maxOverflow == 1) { - ripup_threshold = -1; - slope = 5; - } + if (upType == 3) { + logistic_coef = std::max(2.0 / (1 + log(maxOverflow + max_adj)), + logistic_coef); + } else { + logistic_coef + = std::max(2.0 / (1 + log(maxOverflow)), logistic_coef); + } - if (maxOverflow > 300 && past_cong > 15000) { - L = 0; - } + if (i == 8) { + L = 0; + upType = 2; + graph2d_.InitLastUsage(upType); + } - auto cost_params = CostParams(logistic_coef, costheight_, slope); - mazeRouteMSMD(i, - enlarge_, - ripup_threshold, - mazeedge_threshold_, - !(i % 3), - VIA, - L, - cost_params, - slack_th); - - int last_cong = past_cong; - past_cong = getOverflow2Dmaze(&maxOverflow, &tUsage); + if (maxOverflow == 1) { + ripup_threshold = -1; + slope = 5; + } - if (minofl > past_cong) { - minofl = past_cong; - minoflrnd = i; - } + if (maxOverflow > 300 && past_cong > 15000) { + L = 0; + } - if (i == 8) { - L = 1; - } + const int snapshot_batch_count_before = snapshot_batch_count_; + auto cost_params = CostParams(logistic_coef, costheight_, slope); + mazeRouteMSMD(i, + enlarge_, + ripup_threshold, + mazeedge_threshold_, + !(i % 3), + VIA, + L, + cost_params, + slack_th); + + int last_cong = past_cong; + past_cong = getOverflow2Dmaze(&maxOverflow, &tUsage); + + if (minofl > past_cong) { + minofl = past_cong; + minoflrnd = i; + } - i++; + if (i == 8) { + L = 1; + } - if (past_cong < 200 && i > 30 && upType == 2 && max_adj <= 20) { - upType = 4; - stopDEC = true; - } + i++; - if (maxOverflow < 150) { - if (i == 20 && past_cong > 200) { - L = 0; - upType = 3; + if (past_cong < 200 && i > 30 && upType == 2 && max_adj <= 20) { + upType = 4; stopDEC = true; - slope = 5; - auto cost_params = CostParams(logistic_coef, costheight_, slope); - mazeRouteMSMD(i, - enlarge_, - ripup_threshold, - mazeedge_threshold_, - !(i % 3), - VIA, - L, - cost_params, - slack_th); - last_cong = past_cong; - past_cong = getOverflow2Dmaze(&maxOverflow, &tUsage); - - graph2d_.str_accu(12); - L = 1; - stopDEC = false; - slope = 3; - upType = 2; } - if (i == 35 && tUsage > 800000) { - graph2d_.str_accu(25); - } - if (i == 50 && tUsage > 800000) { - graph2d_.str_accu(40); + + if (maxOverflow < 150) { + if (i == 20 && past_cong > 200) { + L = 0; + slope = 5; + auto cost_params = CostParams(logistic_coef, costheight_, slope); + mazeRouteMSMD(i, + enlarge_, + ripup_threshold, + mazeedge_threshold_, + !(i % 3), + VIA, + L, + cost_params, + slack_th); + last_cong = past_cong; + past_cong = getOverflow2Dmaze(&maxOverflow, &tUsage); + + graph2d_.str_accu(12); + L = 1; + stopDEC = false; + slope = 3; + upType = 2; + } + if (i == 35 && tUsage > 800000) { + graph2d_.str_accu(25); + } + if (i == 50 && tUsage > 800000) { + graph2d_.str_accu(40); + } } - } - if (i > 50) { - upType = 4; - if (i > 70) { - stopDEC = true; + if (i > 50) { + upType = 4; + if (i > 70) { + stopDEC = true; + } } - } - if (past_cong > 0.7 * last_cong) { - costheight_ += CSTEP3; - } + if (past_cong > 0.7 * last_cong) { + costheight_ += CSTEP3; + } - if (past_cong >= last_cong) { - VIA = 0; - } + if (past_cong >= last_cong) { + VIA = 0; + } - if (past_cong < bmfl) { - bwcnt = 0; - if (i > 140 || (i > 80 && past_cong < 20)) { - copyRS(); - bmfl = past_cong; + if (checkSnapshotConvergence( + past_cong, bmfl, bwcnt, i, snapshot_batch_count_before)) { + break; + } - L = 0; - auto cost_params = CostParams(logistic_coef, costheight_, slope); - mazeRouteMSMD(i, - enlarge_, - ripup_threshold, - mazeedge_threshold_, - !(i % 3), - VIA, - L, - cost_params, - slack_th); - last_cong = past_cong; - past_cong = getOverflow2Dmaze(&maxOverflow, &tUsage); - if (past_cong < last_cong) { - copyRS(); - bmfl = past_cong; + if (!snapshot_cleanup_active_) { + if (past_cong < bmfl) { + bwcnt = 0; + if (i > 140 || (i > 80 && past_cong < 20)) { + copyRS(); + bmfl = past_cong; + + L = 0; + auto cost_params = CostParams(logistic_coef, costheight_, slope); + mazeRouteMSMD(i, + enlarge_, + ripup_threshold, + mazeedge_threshold_, + !(i % 3), + VIA, + L, + cost_params, + slack_th); + last_cong = past_cong; + past_cong = getOverflow2Dmaze(&maxOverflow, &tUsage); + if (past_cong < last_cong) { + copyRS(); + bmfl = past_cong; + } + L = 1; + if (minofl > past_cong) { + minofl = past_cong; + minoflrnd = i; + } + } + } else { + bwcnt++; } - L = 1; - if (minofl > past_cong) { - minofl = past_cong; - minoflrnd = i; + + if (bmfl > 10) { + if (bmfl > 30 && bmfl < 72 && bwcnt > 50) { + break; + } + if (bmfl < 30 && bwcnt > 50) { + break; + } } } - } else { - bwcnt++; - } - if (bmfl > 10) { - if (bmfl > 30 && bmfl < 72 && bwcnt > 50) { + if (i >= mazeRound) { + getOverflow2Dmaze(&maxOverflow, &tUsage); break; } - if (bmfl < 30 && bwcnt > 50) { - break; - } - } - if (i >= mazeRound) { - getOverflow2Dmaze(&maxOverflow, &tUsage); - break; - } - - if (total_overflow_ > last_total_overflow) { - overflow_increases++; - } - if (last_total_overflow > 0) { - overflow_reduction_percent - = std::max(overflow_reduction_percent, - 1 - ((float) total_overflow_ / last_total_overflow)); - } + if (total_overflow_ > last_total_overflow) { + overflow_increases++; + } + if (last_total_overflow > 0) { + overflow_reduction_percent + = std::max(overflow_reduction_percent, + 1 - ((float) total_overflow_ / last_total_overflow)); + } - last_total_overflow = total_overflow_; - - if (logger_->debugCheck(GRT, "congestionIterations", 1)) { - logger_->report( - "=== Overflow Iteration {} - TotalOverflow {} - OverflowIter {} - " - "OverflowIncreases {} - MaxOverIncr {} ===", - i, - total_overflow_, - overflow_iterations_, - overflow_increases, - max_overflow_increases); - } + last_total_overflow = total_overflow_; + + if (logger_->debugCheck(GRT, "congestionIterations", 1)) { + logger_->report( + "=== Overflow Iteration {} - TotalOverflow {} - OverflowIter {} - " + "OverflowIncreases {} - MaxOverIncr {} ===", + i, + total_overflow_, + overflow_iterations_, + overflow_increases, + max_overflow_increases); + } - // Try disabling NDR nets to fix congestion - if (total_overflow_ > 0 - && (i == overflow_iterations_ - || overflow_increases == max_overflow_increases)) { - // Compute all the NDR nets involved in congestion - computeCongestedNDRnets(); - - std::vector net_ids; - - // If the congestion is not that high (note that the overflow is inflated - // by 100x when there is no capacity available for a NDR net in a specific - // edge) - if (total_overflow_ < soft_ndr_overflow_th) { - // Select one NDR net to be disabled - int net_id = graph2d_.getOneCongestedNDRnet(); - if (net_id != -1) { - net_ids.push_back(net_id); + // Try disabling NDR nets to fix congestion + if (total_overflow_ > 0 + && (i == overflow_iterations_ + || overflow_increases == max_overflow_increases)) { + // Compute all the NDR nets involved in congestion + computeCongestedNDRnets(); + + std::vector net_ids; + + // If the congestion is not that high (note that the overflow is + // inflated by 100x when there is no capacity available for a NDR net in + // a specific edge) + if (total_overflow_ < soft_ndr_overflow_th) { + // Select one NDR net to be disabled + int net_id = graph2d_.getOneCongestedNDRnet(); + if (net_id != -1) { + net_ids.push_back(net_id); + } + } else { // Select multiple NDR nets + net_ids = graph2d_.getMultipleCongestedNDRnet(); } - } else { // Select multiple NDR nets - net_ids = graph2d_.getMultipleCongestedNDRnet(); - } - - // Only apply soft NDR if there is NDR nets involved in congestion - if (!net_ids.empty()) { - // Apply the soft NDR to the selected list of nets - applySoftNDR(net_ids); - - // Reset loop parameters - overflow_increases = 0; - i = 1; - costheight_ = COSHEIGHT; - enlarge_ = ENLARGE; - ripup_threshold = Ripvalue; - minofl = total_overflow_; - bmfl = minofl; - stopDEC = false; - - slope = 20; - L = 1; - // Increase maze route 3D threshold to fix bad routes - long_edge_len = BIG_INT; + // Only apply soft NDR if there is NDR nets involved in congestion + if (!net_ids.empty()) { + // Apply the soft NDR to the selected list of nets + applySoftNDR(net_ids); + + // Reset loop parameters + overflow_increases = 0; + i = 1; + costheight_ = COSHEIGHT; + enlarge_ = ENLARGE; + ripup_threshold = Ripvalue; + minofl = total_overflow_; + bmfl = minofl; + stopDEC = false; + + slope = 20; + L = 1; + + // Increase maze route 3D threshold to fix bad routes + long_edge_len = BIG_INT; + } } - } - // generate DRC report each interval - if (congestion_report_iter_step_ && i % congestion_report_iter_step_ == 0) { - saveCongestion(i); - } - } // end overflow iterations + // generate DRC report each interval + if (congestion_report_iter_step_ + && i % congestion_report_iter_step_ == 0) { + saveCongestion(i); + } + } // end overflow iterations + } // Debug mode Tree 2D after overflow iterations if (debug_->isOn() && debug_->tree2D) { @@ -1902,55 +2309,58 @@ NetRouteMap FastRouteCore::run() } } - freeRR(); + int finallength = 0; + int numVia = 0; + { + const DebugScopedTimer timer( + timings.finalization, logger_, GRT, "timer", 1, "Finalization: {}"); + freeRR(); - removeLoops(); + removeLoops(); - getOverflow2Dmaze(&maxOverflow, &tUsage); + getOverflow2Dmaze(&maxOverflow, &tUsage); - layerAssignment(); + layerAssignment(); - if (logger_->debugCheck(GRT, "grtSteps", 1)) { - getOverflow3D(); - logger_->report("After LayerAssignment - 2D/3D cong: {}/{}", - past_cong, - total_overflow_); - } + if (logger_->debugCheck(GRT, "grtSteps", 1)) { + getOverflow3D(); + logger_->report("After LayerAssignment - 2D/3D cong: {}/{}", + past_cong, + total_overflow_); + } - costheight_ = 3; - via_cost_ = 1; + costheight_ = 3; + via_cost_ = 1; - if (past_cong == 0) { - // Increase ripup threshold if res-aware is enabled - if (enable_resistance_aware_) { - long_edge_len = BIG_INT; - short_edge_len = BIG_INT; + if (past_cong == 0) { + // Increase ripup threshold if res-aware is enabled + if (enable_resistance_aware_) { + long_edge_len = BIG_INT; + short_edge_len = BIG_INT; + } + + mazeRouteMSMDOrder3D(enlarge_, 0, long_edge_len); + mazeRouteMSMDOrder3D(enlarge_, 0, short_edge_len); } - mazeRouteMSMDOrder3D(enlarge_, 0, long_edge_len); - mazeRouteMSMDOrder3D(enlarge_, 0, short_edge_len); - } + // Disable estimate parasitics for grt incremental steps with + // resistance-aware strategy to prevent issues during repair design and + // repair timing + en_estimate_parasitics_ = false; - // Disable estimate parasitics for grt incremental steps with resistance-aware - // strategy to prevent issues during repair design and repair timing - en_estimate_parasitics_ = false; + if (logger_->debugCheck(GRT, "grtSteps", 1)) { + getOverflow3D(); + logger_->report("After MazeRoute3D - 3Dcong: {}", total_overflow_); + } - if (logger_->debugCheck(GRT, "grtSteps", 1)) { - getOverflow3D(); - logger_->report("After MazeRoute3D - 3Dcong: {}", total_overflow_); + fillVIA(); + finallength = getOverflow3D(); + numVia = threeDVIA(); + checkRoute3D(); + ensurePinCoverage(); } - fillVIA(); - const int finallength = getOverflow3D(); - const int numVia = threeDVIA(); - checkRoute3D(); - ensurePinCoverage(); - - logger_->metric("global_route__vias", numVia); - if (verbose_) { - logger_->info(GRT, 111, "Final number of vias: {}", numVia); - logger_->info(GRT, 112, "Final usage 3D: {}", (finallength + 3 * numVia)); - } + reportRunMetrics(timings, numVia, finallength); // Debug mode Tree 3D after layer assignament if (debug_->isOn() && debug_->tree3D) { @@ -2055,31 +2465,7 @@ void FastRouteCore::computeCongestedNDRnets() void FastRouteCore::updateSoftNDRNetUsage(const int net_id, const int edge_cost) { - FrNet* net = nets_[net_id]; - // Access the routing tree edges for this net - std::vector& treeedges = sttrees_[net_id].edges; - const int num_edges = sttrees_[net_id].num_edges(); - - // Iterate through all edges in the net's routing tree - for (int edgeID = 0; edgeID < num_edges; edgeID++) { - TreeEdge* treeedge = &(treeedges[edgeID]); - // Only process edges that have actual routing - if (treeedge->len > 0 || treeedge->route.routelen > 0) { - int routeLen = treeedge->route.routelen; - std::vector& grids = treeedge->route.grids; - - // Update route usage - for (int i = 0; i < routeLen; i++) { - if (grids[i].x == grids[i + 1].x) { // vertical - const int min_y = std::min(grids[i].y, grids[i + 1].y); - graph2d_.updateUsageV(grids[i].x, min_y, net, edge_cost); - } else { // horizontal - const int min_x = std::min(grids[i].x, grids[i + 1].x); - graph2d_.updateUsageH(min_x, grids[i].y, net, edge_cost); - } - } - } - } + updatePlanarNetUsage(sttrees_[net_id], nets_[net_id], edge_cost); } void FastRouteCore::setVerbose(bool v) @@ -2127,22 +2513,25 @@ void FastRouteCore::setDetourPenalty(int penalty) std::vector FastRouteCore::getOriginalResources() { std::vector original_resources(num_layers_); +#pragma omp parallel for num_threads(num_threads_) for (int l = 0; l < num_layers_; l++) { + int original_resource = 0; bool is_horizontal = layer_directions_[l] == odb::dbTechLayerDir::HORIZONTAL; if (is_horizontal) { for (int i = 0; i < y_grid_; i++) { for (int j = 0; j < x_grid_ - 1; j++) { - original_resources[l] += h_edges_3D_[l][i][j].real_cap; + original_resource += h_edges_3D_[l][i][j].real_cap; } } } else { for (int i = 0; i < y_grid_ - 1; i++) { for (int j = 0; j < x_grid_; j++) { - original_resources[l] += v_edges_3D_[l][i][j].real_cap; + original_resource += v_edges_3D_[l][i][j].real_cap; } } } + original_resources[l] = original_resource; } return original_resources; @@ -2156,39 +2545,46 @@ void FastRouteCore::computeCongestionInformation() max_h_overflow_.resize(num_layers_); max_v_overflow_.resize(num_layers_); +#pragma omp parallel for num_threads(num_threads_) for (int l = 0; l < num_layers_; l++) { - cap_per_layer_[l] = 0; - usage_per_layer_[l] = 0; - overflow_per_layer_[l] = 0; - max_h_overflow_[l] = 0; - max_v_overflow_[l] = 0; + int cap_per_layer = 0; + int usage_per_layer = 0; + int overflow_per_layer = 0; + int max_h_overflow = 0; + int max_v_overflow = 0; for (int i = 0; i < y_grid_; i++) { for (int j = 0; j < x_grid_ - 1; j++) { - cap_per_layer_[l] += h_edges_3D_[l][i][j].cap; - usage_per_layer_[l] += h_edges_3D_[l][i][j].usage; + cap_per_layer += h_edges_3D_[l][i][j].cap; + usage_per_layer += h_edges_3D_[l][i][j].usage; const int overflow = h_edges_3D_[l][i][j].usage - h_edges_3D_[l][i][j].cap; if (overflow > 0) { - overflow_per_layer_[l] += overflow; - max_h_overflow_[l] = std::max(max_h_overflow_[l], overflow); + overflow_per_layer += overflow; + max_h_overflow = std::max(max_h_overflow, overflow); } } } for (int i = 0; i < y_grid_ - 1; i++) { for (int j = 0; j < x_grid_; j++) { - cap_per_layer_[l] += v_edges_3D_[l][i][j].cap; - usage_per_layer_[l] += v_edges_3D_[l][i][j].usage; + cap_per_layer += v_edges_3D_[l][i][j].cap; + usage_per_layer += v_edges_3D_[l][i][j].usage; const int overflow = v_edges_3D_[l][i][j].usage - v_edges_3D_[l][i][j].cap; if (overflow > 0) { - overflow_per_layer_[l] += overflow; - max_v_overflow_[l] = std::max(max_v_overflow_[l], overflow); + overflow_per_layer += overflow; + max_v_overflow = std::max(max_v_overflow, overflow); } } } + + cap_per_layer_[l] = cap_per_layer; + usage_per_layer_[l] = usage_per_layer; + overflow_per_layer_[l] = overflow_per_layer; + max_h_overflow_[l] = max_h_overflow; + max_v_overflow_[l] = max_v_overflow; } } diff --git a/src/grt/src/fastroute/src/graph2d.cpp b/src/grt/src/fastroute/src/graph2d.cpp index f937134899c..5cc3c54890a 100644 --- a/src/grt/src/fastroute/src/graph2d.cpp +++ b/src/grt/src/fastroute/src/graph2d.cpp @@ -74,6 +74,35 @@ void Graph2D::InitLastUsage(const int upType) } } +void Graph2D::copyRoutingStateFrom(const Graph2D& other, + const bool include_ndr_state) +{ + const bool needs_init = x_grid_ != other.x_grid_ || y_grid_ != other.y_grid_ + || num_layers_ != other.num_layers_ || !hasEdges(); + if (needs_init) { + init(other.x_grid_, other.y_grid_, other.num_layers_, other.logger_); + initCap3D(); + } + + h_edges_ = other.h_edges_; + v_edges_ = other.v_edges_; + h_cap_3D_ = other.h_cap_3D_; + v_cap_3D_ = other.v_cap_3D_; + h_used_ggrid_ = other.h_used_ggrid_; + v_used_ggrid_ = other.v_used_ggrid_; + + if (include_ndr_state) { + h_ndr_nets_ = other.h_ndr_nets_; + v_ndr_nets_ = other.v_ndr_nets_; + congested_ndrs_ = other.congested_ndrs_; + congestion_nets_ = other.congestion_nets_; + } else { + clearNDRnets(); + clearCongestedNDRnets(); + congestion_nets_.clear(); + } +} + // Clears all horizontal and vertical edges from the graph. void Graph2D::clear() { diff --git a/src/grt/src/fastroute/src/maze.cpp b/src/grt/src/fastroute/src/maze.cpp index cb7efa6cd3a..03c23811c96 100644 --- a/src/grt/src/fastroute/src/maze.cpp +++ b/src/grt/src/fastroute/src/maze.cpp @@ -3,8 +3,10 @@ #include #include +#include #include #include +#include #include #include #include @@ -17,10 +19,12 @@ #include "odb/geom.h" #include "stt/SteinerTreeBuilder.h" #include "utl/Logger.h" +#include "utl/timer.h" namespace grt { using utl::GRT; +using utl::Timer; static int parent_index(int i) { @@ -511,8 +515,10 @@ void FastRouteCore::setupHeap(const int netID, } else { // net with more than 2 pins const int numNodes = sttrees_[netID].num_nodes(); - std::vector visited(numNodes, false); - std::vector queue(numNodes); + visited_2D_.assign(numNodes, false); + queue_2D_.resize(numNodes); + auto& visited = visited_2D_; + auto& queue = queue_2D_; // find all the grids on tree edges in subtree t1 (connecting to n1) and put // them into src_heap @@ -775,12 +781,7 @@ bool FastRouteCore::updateRouteType1(const int net_id, } // reallocate memory for route.gridsX and route.gridsY - if (treeedges[edge_n1A1].route.type - == RouteType::MazeRoute) // if originally allocated, free them first - { - treeedges[edge_n1A1].route.grids.clear(); - } - treeedges[edge_n1A1].route.grids.resize(E1_pos + 1); + treeedges[edge_n1A1].route.grids.assign(E1_pos + 1, GPoint3D{}); if (A1x <= E1x) { int cnt = 0; @@ -807,12 +808,8 @@ bool FastRouteCore::updateRouteType1(const int net_id, treeedges[edge_n1A1].len = abs(A1x - E1x) + abs(A1y - E1y); // reallocate memory for route.gridsX and route.gridsY - if (treeedges[edge_n1A2].route.type - == RouteType::MazeRoute) // if originally allocated, free them first - { - treeedges[edge_n1A2].route.grids.clear(); - } - treeedges[edge_n1A2].route.grids.resize(cnt_n1A1 + cnt_n1A2 - E1_pos - 1); + treeedges[edge_n1A2].route.grids.assign(cnt_n1A1 + cnt_n1A2 - E1_pos - 1, + GPoint3D{}); int cnt = 0; if (E1x <= A2x) { @@ -900,12 +897,9 @@ bool FastRouteCore::updateRouteType2(const int net_id, // combine grids on original (A1, n1) and (n1, A2) to new (A1, A2) // allocate memory for grids[].x and grids[].y of edge_A1A2 - if (treeedges[edge_A1A2].route.type == RouteType::MazeRoute) { - treeedges[edge_A1A2].route.grids.clear(); - } const int len_A1A2 = cnt_n1A1 + cnt_n1A2 - 1; - treeedges[edge_A1A2].route.grids.resize(len_A1A2); + treeedges[edge_A1A2].route.grids.assign(len_A1A2, GPoint3D{}); treeedges[edge_A1A2].route.routelen = len_A1A2 - 1; treeedges[edge_A1A2].len = abs(A1x - A2x) + abs(A1y - A2y); @@ -947,19 +941,13 @@ bool FastRouteCore::updateRouteType2(const int net_id, } // allocate memory for grids[].x and grids[].y of edge_n1C1 and edge_n1C2 - if (treeedges[edge_n1C1].route.type == RouteType::MazeRoute) { - treeedges[edge_n1C1].route.grids.clear(); - } const int len_n1C1 = E1_pos + 1; - treeedges[edge_n1C1].route.grids.resize(len_n1C1); + treeedges[edge_n1C1].route.grids.assign(len_n1C1, GPoint3D{}); treeedges[edge_n1C1].route.routelen = len_n1C1 - 1; treeedges[edge_n1C1].len = abs(C1x - E1x) + abs(C1y - E1y); - if (treeedges[edge_n1C2].route.type == RouteType::MazeRoute) { - treeedges[edge_n1C2].route.grids.clear(); - } const int len_n1C2 = cnt_C1C2 - E1_pos; - treeedges[edge_n1C2].route.grids.resize(len_n1C2); + treeedges[edge_n1C2].route.grids.assign(len_n1C2, GPoint3D{}); treeedges[edge_n1C2].route.routelen = len_n1C2 - 1; treeedges[edge_n1C2].len = abs(C2x - E1x) + abs(C2y - E1y); @@ -1047,16 +1035,193 @@ void FastRouteCore::mazeRouteMSMD(const int iter, const int L, const CostParams& cost_params, float& slack_th) +{ + if (!runSnapshotBatchedMazeRoute(iter, + expand, + ripup_threshold, + maze_edge_threshold, + ordering, + via, + L, + cost_params, + slack_th)) { + mazeRouteMSMDSequential(iter, + expand, + ripup_threshold, + maze_edge_threshold, + ordering, + via, + L, + cost_params, + slack_th); + } +} + +bool FastRouteCore::runSnapshotBatchedMazeRoute(const int iter, + const int expand, + const int ripup_threshold, + const int maze_edge_threshold, + const bool ordering, + const int via, + const int L, + const CostParams& cost_params, + float& slack_th) +{ + if (!useSnapshotBatchRoutingForIteration(iter, net_ids_.size())) { + return false; + } + + // If this iteration cannot form multiple snapshot batches, stay entirely on + // the sequential path instead of doing snapshot-batched ordering work first. + const int initial_nets_for_batch + = resolveSnapshotNetsForBatch(iter, net_ids_.size()); + if (initial_nets_for_batch <= 1 + || static_cast(net_ids_.size()) <= initial_nets_for_batch) { + return false; + } + + std::vector ordered_net_ids = getMazeRouteNetOrder(ordering, slack_th); + if (!useSnapshotBatchRoutingForIteration(iter, ordered_net_ids.size())) { + return false; + } + + const int nets_for_batch + = resolveSnapshotNetsForBatch(iter, ordered_net_ids.size()); + if (nets_for_batch <= 1 + || static_cast(ordered_net_ids.size()) <= nets_for_batch) { + return false; + } + + std::vector> batch_net_ids; + batch_net_ids.reserve((ordered_net_ids.size() + nets_for_batch - 1) + / nets_for_batch); + for (const int net_id : ordered_net_ids) { + if (batch_net_ids.empty() + || static_cast(batch_net_ids.back().size()) == nets_for_batch) { + batch_net_ids.emplace_back(); + } + batch_net_ids.back().push_back(net_id); + } + + if (batch_net_ids.size() < 2) { + return false; + } + + double snapshot_sync_time = 0.0; + double snapshot_route_time = 0.0; + double snapshot_apply_time = 0.0; + int wave_count = 0; + { + struct BatchResult + { + std::vector net_ids; + std::vector sttrees; + }; + const int semantic_wave_size + = resolveSnapshotWaveSize(batch_net_ids.size()); + std::vector> workers; + workers.reserve(semantic_wave_size); + for (int worker_idx = 0; worker_idx < semantic_wave_size; worker_idx++) { + workers.push_back(buildSnapshotBatchWorker()); + } + + // Snapshot-batched routing intentionally allows route-choice drift + // inside a wave. Route fixed contiguous batches against one snapshot, + // then commit them in the original batch order before advancing to the + // next wave. + for (size_t wave_begin = 0; wave_begin < batch_net_ids.size(); + wave_begin += semantic_wave_size) { + const int batches_in_wave + = std::min(semantic_wave_size, + static_cast(batch_net_ids.size()) + - static_cast(wave_begin)); + const int active_threads + = resolveSnapshotExecutionThreads(batches_in_wave); + std::vector batch_results(batches_in_wave); + wave_count++; + + { + Timer timer; +#pragma omp parallel for num_threads(active_threads) schedule(static) + for (int wave_batch = 0; wave_batch < batches_in_wave; wave_batch++) { + workers[wave_batch]->syncSnapshotBatchWorker( + *this, batch_net_ids[wave_begin + wave_batch]); + } + snapshot_sync_time += timer.elapsed(); + } + + { + Timer timer; +#pragma omp parallel for num_threads(active_threads) schedule(static) + for (int wave_batch = 0; wave_batch < batches_in_wave; wave_batch++) { + auto& worker = workers[wave_batch]; + float batch_slack_th = slack_th; + worker->mazeRouteMSMDSequential(iter, + expand, + ripup_threshold, + maze_edge_threshold, + false, + via, + L, + cost_params, + batch_slack_th); + + BatchResult result; + result.net_ids = worker->net_ids_; + result.sttrees.reserve(result.net_ids.size()); + for (const int net_id : result.net_ids) { + result.sttrees.push_back(std::move(worker->sttrees_[net_id])); + } + batch_results[wave_batch] = std::move(result); + } + snapshot_route_time += timer.elapsed(); + } + + { + Timer timer; + for (BatchResult& result : batch_results) { + for (size_t i = 0; i < result.net_ids.size(); i++) { + applySnapshotBatchRoute(result.net_ids[i], + std::move(result.sttrees[i])); + } + } + snapshot_apply_time += timer.elapsed(); + } + } + } + + snapshot_batch_sync_time_ += snapshot_sync_time; + snapshot_batch_route_time_ += snapshot_route_time; + snapshot_batch_apply_time_ += snapshot_apply_time; + snapshot_batch_count_ += batch_net_ids.size(); + snapshot_batch_net_count_ += ordered_net_ids.size(); + snapshot_batch_wave_count_ += wave_count; + return true; +} + +void FastRouteCore::mazeRouteMSMDSequential(const int iter, + const int expand, + const int ripup_threshold, + const int maze_edge_threshold, + const bool ordering, + const int via, + const int L, + const CostParams& cost_params, + float& slack_th) { // maze routing for multi-source, multi-destination int tmpX, tmpY; const int max_usage_multiplier = 40; - for (int i = 0; i < max_usage_multiplier * h_capacity_; i++) { + const int max_h_usage = max_usage_multiplier * h_capacity_; + h_cost_table_.reserve(max_h_usage); + for (int i = 0; i < max_h_usage; i++) { h_cost_table_.push_back(getCost(i, true, cost_params)); } - for (int i = 0; i < max_usage_multiplier * v_capacity_; i++) { + const int max_v_usage = max_usage_multiplier * v_capacity_; + v_cost_table_.reserve(max_v_usage); + for (int i = 0; i < max_v_usage; i++) { v_cost_table_.push_back(getCost(i, false, cost_params)); } @@ -1073,15 +1238,15 @@ void FastRouteCore::mazeRouteMSMD(const int iter, StNetOrder(); } - std::vector src_heap; - std::vector dest_heap; - src_heap.reserve(y_grid_ * x_grid_); - dest_heap.reserve(y_grid_ * x_grid_); - - multi_array d1(boost::extents[y_range_][x_range_]); - multi_array d2(boost::extents[y_range_][x_range_]); + auto& src_heap = src_heap_2D_; + auto& dest_heap = dest_heap_2D_; + auto& d1 = d1_2D_; + auto& d2 = d2_2D_; + auto& pop_heap2 = pop_heap2_2D_; - std::vector pop_heap2(y_grid_ * x_range_, false); + src_heap.clear(); + dest_heap.clear(); + std::fill(pop_heap2.begin(), pop_heap2.end(), false); /** * @brief Updates the cost of an adjacent grid if the new cost is lower, @@ -1687,10 +1852,7 @@ void FastRouteCore::mazeRouteMSMD(const int iter, } // n2 is not a pin and E2!=n2 // update route for edge (n1, n2) and edge usage - if (treeedges[edge_n1n2].route.type == RouteType::MazeRoute) { - treeedges[edge_n1n2].route.grids.clear(); - } - treeedges[edge_n1n2].route.grids.resize(cnt_n1n2); + treeedges[edge_n1n2].route.grids.assign(cnt_n1n2, GPoint3D{}); treeedges[edge_n1n2].route.type = RouteType::MazeRoute; treeedges[edge_n1n2].route.routelen = cnt_n1n2 - 1; treeedges[edge_n1n2].len = abs(E1x - E2x) + abs(E1y - E2y); diff --git a/src/grt/test/BUILD b/src/grt/test/BUILD index df84e59055c..b3fed501f4f 100644 --- a/src/grt/test/BUILD +++ b/src/grt/test/BUILD @@ -133,6 +133,44 @@ MANUAL_FOR_BAZEL_TESTS = [ tags = ["manual"] if test_name in MANUAL_FOR_BAZEL_TESTS else [], ) for test_name in TESTS] +regression_test( + name = "snapshot_batched_bus_route", + check_log = False, + check_passfail = True, + data = [ + "bus_route.tcl", + ":test_resources", + ], +) + +regression_test( + name = "snapshot_batched_incremental_state", + check_log = False, + check_passfail = True, + data = [":test_resources"], +) + +regression_test( + name = "snapshot_batched_smoke", + check_log = False, + check_passfail = True, + data = [":test_resources"], +) + +regression_test( + name = "snapshot_batched_single_thread_smoke", + check_log = False, + check_passfail = True, + data = [":test_resources"], +) + +regression_test( + name = "thread_count_reports", + check_log = False, + check_passfail = True, + data = [":test_resources"], +) + py_test( name = "grt_man_tcl_check", srcs = ["grt_man_tcl_check.py"], diff --git a/src/grt/test/CMakeLists.txt b/src/grt/test/CMakeLists.txt index 400eb29ba19..379e3f6a7d5 100644 --- a/src/grt/test/CMakeLists.txt +++ b/src/grt/test/CMakeLists.txt @@ -100,5 +100,10 @@ or_integration_tests( upper_layer_net write_segments1 write_segments2 + PASSFAIL_TESTS + snapshot_batched_bus_route + snapshot_batched_incremental_state + snapshot_batched_smoke + snapshot_batched_single_thread_smoke + thread_count_reports ) - diff --git a/src/grt/test/shuffle_stress.def b/src/grt/test/shuffle_stress.def new file mode 100644 index 00000000000..620f465552b --- /dev/null +++ b/src/grt/test/shuffle_stress.def @@ -0,0 +1,2153 @@ +VERSION 5.8 ; +DIVIDERCHAR "/" ; +BUSBITCHARS "[]" ; +DESIGN shuffle_stress ; +UNITS DISTANCE MICRONS 1000 ; +DIEAREA ( 0 0 ) ( 18000 142800 ) ; +ROW ROW_0 FreePDK45_38x28_10R_NP_162NW_34O 2090 2800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_1 FreePDK45_38x28_10R_NP_162NW_34O 2090 4200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_2 FreePDK45_38x28_10R_NP_162NW_34O 2090 5600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_3 FreePDK45_38x28_10R_NP_162NW_34O 2090 7000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_4 FreePDK45_38x28_10R_NP_162NW_34O 2090 8400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_5 FreePDK45_38x28_10R_NP_162NW_34O 2090 9800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_6 FreePDK45_38x28_10R_NP_162NW_34O 2090 11200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_7 FreePDK45_38x28_10R_NP_162NW_34O 2090 12600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_8 FreePDK45_38x28_10R_NP_162NW_34O 2090 14000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_9 FreePDK45_38x28_10R_NP_162NW_34O 2090 15400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_10 FreePDK45_38x28_10R_NP_162NW_34O 2090 16800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_11 FreePDK45_38x28_10R_NP_162NW_34O 2090 18200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_12 FreePDK45_38x28_10R_NP_162NW_34O 2090 19600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_13 FreePDK45_38x28_10R_NP_162NW_34O 2090 21000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_14 FreePDK45_38x28_10R_NP_162NW_34O 2090 22400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_15 FreePDK45_38x28_10R_NP_162NW_34O 2090 23800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_16 FreePDK45_38x28_10R_NP_162NW_34O 2090 25200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_17 FreePDK45_38x28_10R_NP_162NW_34O 2090 26600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_18 FreePDK45_38x28_10R_NP_162NW_34O 2090 28000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_19 FreePDK45_38x28_10R_NP_162NW_34O 2090 29400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_20 FreePDK45_38x28_10R_NP_162NW_34O 2090 30800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_21 FreePDK45_38x28_10R_NP_162NW_34O 2090 32200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_22 FreePDK45_38x28_10R_NP_162NW_34O 2090 33600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_23 FreePDK45_38x28_10R_NP_162NW_34O 2090 35000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_24 FreePDK45_38x28_10R_NP_162NW_34O 2090 36400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_25 FreePDK45_38x28_10R_NP_162NW_34O 2090 37800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_26 FreePDK45_38x28_10R_NP_162NW_34O 2090 39200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_27 FreePDK45_38x28_10R_NP_162NW_34O 2090 40600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_28 FreePDK45_38x28_10R_NP_162NW_34O 2090 42000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_29 FreePDK45_38x28_10R_NP_162NW_34O 2090 43400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_30 FreePDK45_38x28_10R_NP_162NW_34O 2090 44800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_31 FreePDK45_38x28_10R_NP_162NW_34O 2090 46200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_32 FreePDK45_38x28_10R_NP_162NW_34O 2090 47600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_33 FreePDK45_38x28_10R_NP_162NW_34O 2090 49000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_34 FreePDK45_38x28_10R_NP_162NW_34O 2090 50400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_35 FreePDK45_38x28_10R_NP_162NW_34O 2090 51800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_36 FreePDK45_38x28_10R_NP_162NW_34O 2090 53200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_37 FreePDK45_38x28_10R_NP_162NW_34O 2090 54600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_38 FreePDK45_38x28_10R_NP_162NW_34O 2090 56000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_39 FreePDK45_38x28_10R_NP_162NW_34O 2090 57400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_40 FreePDK45_38x28_10R_NP_162NW_34O 2090 58800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_41 FreePDK45_38x28_10R_NP_162NW_34O 2090 60200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_42 FreePDK45_38x28_10R_NP_162NW_34O 2090 61600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_43 FreePDK45_38x28_10R_NP_162NW_34O 2090 63000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_44 FreePDK45_38x28_10R_NP_162NW_34O 2090 64400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_45 FreePDK45_38x28_10R_NP_162NW_34O 2090 65800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_46 FreePDK45_38x28_10R_NP_162NW_34O 2090 67200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_47 FreePDK45_38x28_10R_NP_162NW_34O 2090 68600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_48 FreePDK45_38x28_10R_NP_162NW_34O 2090 70000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_49 FreePDK45_38x28_10R_NP_162NW_34O 2090 71400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_50 FreePDK45_38x28_10R_NP_162NW_34O 2090 72800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_51 FreePDK45_38x28_10R_NP_162NW_34O 2090 74200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_52 FreePDK45_38x28_10R_NP_162NW_34O 2090 75600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_53 FreePDK45_38x28_10R_NP_162NW_34O 2090 77000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_54 FreePDK45_38x28_10R_NP_162NW_34O 2090 78400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_55 FreePDK45_38x28_10R_NP_162NW_34O 2090 79800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_56 FreePDK45_38x28_10R_NP_162NW_34O 2090 81200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_57 FreePDK45_38x28_10R_NP_162NW_34O 2090 82600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_58 FreePDK45_38x28_10R_NP_162NW_34O 2090 84000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_59 FreePDK45_38x28_10R_NP_162NW_34O 2090 85400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_60 FreePDK45_38x28_10R_NP_162NW_34O 2090 86800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_61 FreePDK45_38x28_10R_NP_162NW_34O 2090 88200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_62 FreePDK45_38x28_10R_NP_162NW_34O 2090 89600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_63 FreePDK45_38x28_10R_NP_162NW_34O 2090 91000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_64 FreePDK45_38x28_10R_NP_162NW_34O 2090 92400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_65 FreePDK45_38x28_10R_NP_162NW_34O 2090 93800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_66 FreePDK45_38x28_10R_NP_162NW_34O 2090 95200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_67 FreePDK45_38x28_10R_NP_162NW_34O 2090 96600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_68 FreePDK45_38x28_10R_NP_162NW_34O 2090 98000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_69 FreePDK45_38x28_10R_NP_162NW_34O 2090 99400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_70 FreePDK45_38x28_10R_NP_162NW_34O 2090 100800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_71 FreePDK45_38x28_10R_NP_162NW_34O 2090 102200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_72 FreePDK45_38x28_10R_NP_162NW_34O 2090 103600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_73 FreePDK45_38x28_10R_NP_162NW_34O 2090 105000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_74 FreePDK45_38x28_10R_NP_162NW_34O 2090 106400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_75 FreePDK45_38x28_10R_NP_162NW_34O 2090 107800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_76 FreePDK45_38x28_10R_NP_162NW_34O 2090 109200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_77 FreePDK45_38x28_10R_NP_162NW_34O 2090 110600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_78 FreePDK45_38x28_10R_NP_162NW_34O 2090 112000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_79 FreePDK45_38x28_10R_NP_162NW_34O 2090 113400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_80 FreePDK45_38x28_10R_NP_162NW_34O 2090 114800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_81 FreePDK45_38x28_10R_NP_162NW_34O 2090 116200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_82 FreePDK45_38x28_10R_NP_162NW_34O 2090 117600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_83 FreePDK45_38x28_10R_NP_162NW_34O 2090 119000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_84 FreePDK45_38x28_10R_NP_162NW_34O 2090 120400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_85 FreePDK45_38x28_10R_NP_162NW_34O 2090 121800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_86 FreePDK45_38x28_10R_NP_162NW_34O 2090 123200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_87 FreePDK45_38x28_10R_NP_162NW_34O 2090 124600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_88 FreePDK45_38x28_10R_NP_162NW_34O 2090 126000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_89 FreePDK45_38x28_10R_NP_162NW_34O 2090 127400 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_90 FreePDK45_38x28_10R_NP_162NW_34O 2090 128800 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_91 FreePDK45_38x28_10R_NP_162NW_34O 2090 130200 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_92 FreePDK45_38x28_10R_NP_162NW_34O 2090 131600 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_93 FreePDK45_38x28_10R_NP_162NW_34O 2090 133000 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_94 FreePDK45_38x28_10R_NP_162NW_34O 2090 134400 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_95 FreePDK45_38x28_10R_NP_162NW_34O 2090 135800 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_96 FreePDK45_38x28_10R_NP_162NW_34O 2090 137200 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_97 FreePDK45_38x28_10R_NP_162NW_34O 2090 138600 FS DO 72 BY 1 STEP 190 0 ; +ROW ROW_98 FreePDK45_38x28_10R_NP_162NW_34O 2090 140000 N DO 72 BY 1 STEP 190 0 ; +ROW ROW_99 FreePDK45_38x28_10R_NP_162NW_34O 2090 141400 FS DO 72 BY 1 STEP 190 0 ; +TRACKS X 95 DO 127 STEP 140 LAYER metal1 ; +TRACKS Y 70 DO 1019 STEP 140 LAYER metal1 ; +TRACKS X 95 DO 94 STEP 190 LAYER metal2 ; +TRACKS Y 70 DO 751 STEP 190 LAYER metal2 ; +TRACKS X 95 DO 127 STEP 140 LAYER metal3 ; +TRACKS Y 70 DO 1019 STEP 140 LAYER metal3 ; +TRACKS X 95 DO 63 STEP 280 LAYER metal4 ; +TRACKS Y 70 DO 509 STEP 280 LAYER metal4 ; +TRACKS X 95 DO 63 STEP 280 LAYER metal5 ; +TRACKS Y 70 DO 509 STEP 280 LAYER metal5 ; +TRACKS X 95 DO 63 STEP 280 LAYER metal6 ; +TRACKS Y 70 DO 509 STEP 280 LAYER metal6 ; +TRACKS X 895 DO 21 STEP 800 LAYER metal7 ; +TRACKS Y 870 DO 177 STEP 800 LAYER metal7 ; +TRACKS X 895 DO 21 STEP 800 LAYER metal8 ; +TRACKS Y 870 DO 177 STEP 800 LAYER metal8 ; +TRACKS X 1695 DO 10 STEP 1600 LAYER metal9 ; +TRACKS Y 1670 DO 88 STEP 1600 LAYER metal9 ; +TRACKS X 1695 DO 10 STEP 1600 LAYER metal10 ; +TRACKS Y 1670 DO 88 STEP 1600 LAYER metal10 ; +COMPONENTS 576 ; + - u_s0_l0 BUF_X1 + FIXED ( 3230 2800 ) N ; + - u_s0_l1 BUF_X1 + FIXED ( 3230 4200 ) FS ; + - u_s0_l2 BUF_X1 + FIXED ( 3230 5600 ) N ; + - u_s0_l3 BUF_X1 + FIXED ( 3230 7000 ) FS ; + - u_s0_l4 BUF_X1 + FIXED ( 3230 8400 ) N ; + - u_s0_l5 BUF_X1 + FIXED ( 3230 9800 ) FS ; + - u_s0_l6 BUF_X1 + FIXED ( 3230 11200 ) N ; + - u_s0_l7 BUF_X1 + FIXED ( 3230 12600 ) FS ; + - u_s0_l8 BUF_X1 + FIXED ( 3230 14000 ) N ; + - u_s0_l9 BUF_X1 + FIXED ( 3230 15400 ) FS ; + - u_s0_l10 BUF_X1 + FIXED ( 3230 16800 ) N ; + - u_s0_l11 BUF_X1 + FIXED ( 3230 18200 ) FS ; + - u_s0_l12 BUF_X1 + FIXED ( 3230 19600 ) N ; + - u_s0_l13 BUF_X1 + FIXED ( 3230 21000 ) FS ; + - u_s0_l14 BUF_X1 + FIXED ( 3230 22400 ) N ; + - u_s0_l15 BUF_X1 + FIXED ( 3230 23800 ) FS ; + - u_s0_l16 BUF_X1 + FIXED ( 3230 25200 ) N ; + - u_s0_l17 BUF_X1 + FIXED ( 3230 26600 ) FS ; + - u_s0_l18 BUF_X1 + FIXED ( 3230 28000 ) N ; + - u_s0_l19 BUF_X1 + FIXED ( 3230 29400 ) FS ; + - u_s0_l20 BUF_X1 + FIXED ( 3230 30800 ) N ; + - u_s0_l21 BUF_X1 + FIXED ( 3230 32200 ) FS ; + - u_s0_l22 BUF_X1 + FIXED ( 3230 33600 ) N ; + - u_s0_l23 BUF_X1 + FIXED ( 3230 35000 ) FS ; + - u_s0_l24 BUF_X1 + FIXED ( 3230 36400 ) N ; + - u_s0_l25 BUF_X1 + FIXED ( 3230 37800 ) FS ; + - u_s0_l26 BUF_X1 + FIXED ( 3230 39200 ) N ; + - u_s0_l27 BUF_X1 + FIXED ( 3230 40600 ) FS ; + - u_s0_l28 BUF_X1 + FIXED ( 3230 42000 ) N ; + - u_s0_l29 BUF_X1 + FIXED ( 3230 43400 ) FS ; + - u_s0_l30 BUF_X1 + FIXED ( 3230 44800 ) N ; + - u_s0_l31 BUF_X1 + FIXED ( 3230 46200 ) FS ; + - u_s0_l32 BUF_X1 + FIXED ( 3230 47600 ) N ; + - u_s0_l33 BUF_X1 + FIXED ( 3230 49000 ) FS ; + - u_s0_l34 BUF_X1 + FIXED ( 3230 50400 ) N ; + - u_s0_l35 BUF_X1 + FIXED ( 3230 51800 ) FS ; + - u_s0_l36 BUF_X1 + FIXED ( 3230 53200 ) N ; + - u_s0_l37 BUF_X1 + FIXED ( 3230 54600 ) FS ; + - u_s0_l38 BUF_X1 + FIXED ( 3230 56000 ) N ; + - u_s0_l39 BUF_X1 + FIXED ( 3230 57400 ) FS ; + - u_s0_l40 BUF_X1 + FIXED ( 3230 58800 ) N ; + - u_s0_l41 BUF_X1 + FIXED ( 3230 60200 ) FS ; + - u_s0_l42 BUF_X1 + FIXED ( 3230 61600 ) N ; + - u_s0_l43 BUF_X1 + FIXED ( 3230 63000 ) FS ; + - u_s0_l44 BUF_X1 + FIXED ( 3230 64400 ) N ; + - u_s0_l45 BUF_X1 + FIXED ( 3230 65800 ) FS ; + - u_s0_l46 BUF_X1 + FIXED ( 3230 67200 ) N ; + - u_s0_l47 BUF_X1 + FIXED ( 3230 68600 ) FS ; + - u_s0_l48 BUF_X1 + FIXED ( 3230 70000 ) N ; + - u_s0_l49 BUF_X1 + FIXED ( 3230 71400 ) FS ; + - u_s0_l50 BUF_X1 + FIXED ( 3230 72800 ) N ; + - u_s0_l51 BUF_X1 + FIXED ( 3230 74200 ) FS ; + - u_s0_l52 BUF_X1 + FIXED ( 3230 75600 ) N ; + - u_s0_l53 BUF_X1 + FIXED ( 3230 77000 ) FS ; + - u_s0_l54 BUF_X1 + FIXED ( 3230 78400 ) N ; + - u_s0_l55 BUF_X1 + FIXED ( 3230 79800 ) FS ; + - u_s0_l56 BUF_X1 + FIXED ( 3230 81200 ) N ; + - u_s0_l57 BUF_X1 + FIXED ( 3230 82600 ) FS ; + - u_s0_l58 BUF_X1 + FIXED ( 3230 84000 ) N ; + - u_s0_l59 BUF_X1 + FIXED ( 3230 85400 ) FS ; + - u_s0_l60 BUF_X1 + FIXED ( 3230 86800 ) N ; + - u_s0_l61 BUF_X1 + FIXED ( 3230 88200 ) FS ; + - u_s0_l62 BUF_X1 + FIXED ( 3230 89600 ) N ; + - u_s0_l63 BUF_X1 + FIXED ( 3230 91000 ) FS ; + - u_s0_l64 BUF_X1 + FIXED ( 3230 92400 ) N ; + - u_s0_l65 BUF_X1 + FIXED ( 3230 93800 ) FS ; + - u_s0_l66 BUF_X1 + FIXED ( 3230 95200 ) N ; + - u_s0_l67 BUF_X1 + FIXED ( 3230 96600 ) FS ; + - u_s0_l68 BUF_X1 + FIXED ( 3230 98000 ) N ; + - u_s0_l69 BUF_X1 + FIXED ( 3230 99400 ) FS ; + - u_s0_l70 BUF_X1 + FIXED ( 3230 100800 ) N ; + - u_s0_l71 BUF_X1 + FIXED ( 3230 102200 ) FS ; + - u_s0_l72 BUF_X1 + FIXED ( 3230 103600 ) N ; + - u_s0_l73 BUF_X1 + FIXED ( 3230 105000 ) FS ; + - u_s0_l74 BUF_X1 + FIXED ( 3230 106400 ) N ; + - u_s0_l75 BUF_X1 + FIXED ( 3230 107800 ) FS ; + - u_s0_l76 BUF_X1 + FIXED ( 3230 109200 ) N ; + - u_s0_l77 BUF_X1 + FIXED ( 3230 110600 ) FS ; + - u_s0_l78 BUF_X1 + FIXED ( 3230 112000 ) N ; + - u_s0_l79 BUF_X1 + FIXED ( 3230 113400 ) FS ; + - u_s0_l80 BUF_X1 + FIXED ( 3230 114800 ) N ; + - u_s0_l81 BUF_X1 + FIXED ( 3230 116200 ) FS ; + - u_s0_l82 BUF_X1 + FIXED ( 3230 117600 ) N ; + - u_s0_l83 BUF_X1 + FIXED ( 3230 119000 ) FS ; + - u_s0_l84 BUF_X1 + FIXED ( 3230 120400 ) N ; + - u_s0_l85 BUF_X1 + FIXED ( 3230 121800 ) FS ; + - u_s0_l86 BUF_X1 + FIXED ( 3230 123200 ) N ; + - u_s0_l87 BUF_X1 + FIXED ( 3230 124600 ) FS ; + - u_s0_l88 BUF_X1 + FIXED ( 3230 126000 ) N ; + - u_s0_l89 BUF_X1 + FIXED ( 3230 127400 ) FS ; + - u_s0_l90 BUF_X1 + FIXED ( 3230 128800 ) N ; + - u_s0_l91 BUF_X1 + FIXED ( 3230 130200 ) FS ; + - u_s0_l92 BUF_X1 + FIXED ( 3230 131600 ) N ; + - u_s0_l93 BUF_X1 + FIXED ( 3230 133000 ) FS ; + - u_s0_l94 BUF_X1 + FIXED ( 3230 134400 ) N ; + - u_s0_l95 BUF_X1 + FIXED ( 3230 135800 ) FS ; + - u_s1_l0 BUF_X1 + FIXED ( 4370 2800 ) N ; + - u_s1_l1 BUF_X1 + FIXED ( 4370 4200 ) FS ; + - u_s1_l2 BUF_X1 + FIXED ( 4370 5600 ) N ; + - u_s1_l3 BUF_X1 + FIXED ( 4370 7000 ) FS ; + - u_s1_l4 BUF_X1 + FIXED ( 4370 8400 ) N ; + - u_s1_l5 BUF_X1 + FIXED ( 4370 9800 ) FS ; + - u_s1_l6 BUF_X1 + FIXED ( 4370 11200 ) N ; + - u_s1_l7 BUF_X1 + FIXED ( 4370 12600 ) FS ; + - u_s1_l8 BUF_X1 + FIXED ( 4370 14000 ) N ; + - u_s1_l9 BUF_X1 + FIXED ( 4370 15400 ) FS ; + - u_s1_l10 BUF_X1 + FIXED ( 4370 16800 ) N ; + - u_s1_l11 BUF_X1 + FIXED ( 4370 18200 ) FS ; + - u_s1_l12 BUF_X1 + FIXED ( 4370 19600 ) N ; + - u_s1_l13 BUF_X1 + FIXED ( 4370 21000 ) FS ; + - u_s1_l14 BUF_X1 + FIXED ( 4370 22400 ) N ; + - u_s1_l15 BUF_X1 + FIXED ( 4370 23800 ) FS ; + - u_s1_l16 BUF_X1 + FIXED ( 4370 25200 ) N ; + - u_s1_l17 BUF_X1 + FIXED ( 4370 26600 ) FS ; + - u_s1_l18 BUF_X1 + FIXED ( 4370 28000 ) N ; + - u_s1_l19 BUF_X1 + FIXED ( 4370 29400 ) FS ; + - u_s1_l20 BUF_X1 + FIXED ( 4370 30800 ) N ; + - u_s1_l21 BUF_X1 + FIXED ( 4370 32200 ) FS ; + - u_s1_l22 BUF_X1 + FIXED ( 4370 33600 ) N ; + - u_s1_l23 BUF_X1 + FIXED ( 4370 35000 ) FS ; + - u_s1_l24 BUF_X1 + FIXED ( 4370 36400 ) N ; + - u_s1_l25 BUF_X1 + FIXED ( 4370 37800 ) FS ; + - u_s1_l26 BUF_X1 + FIXED ( 4370 39200 ) N ; + - u_s1_l27 BUF_X1 + FIXED ( 4370 40600 ) FS ; + - u_s1_l28 BUF_X1 + FIXED ( 4370 42000 ) N ; + - u_s1_l29 BUF_X1 + FIXED ( 4370 43400 ) FS ; + - u_s1_l30 BUF_X1 + FIXED ( 4370 44800 ) N ; + - u_s1_l31 BUF_X1 + FIXED ( 4370 46200 ) FS ; + - u_s1_l32 BUF_X1 + FIXED ( 4370 47600 ) N ; + - u_s1_l33 BUF_X1 + FIXED ( 4370 49000 ) FS ; + - u_s1_l34 BUF_X1 + FIXED ( 4370 50400 ) N ; + - u_s1_l35 BUF_X1 + FIXED ( 4370 51800 ) FS ; + - u_s1_l36 BUF_X1 + FIXED ( 4370 53200 ) N ; + - u_s1_l37 BUF_X1 + FIXED ( 4370 54600 ) FS ; + - u_s1_l38 BUF_X1 + FIXED ( 4370 56000 ) N ; + - u_s1_l39 BUF_X1 + FIXED ( 4370 57400 ) FS ; + - u_s1_l40 BUF_X1 + FIXED ( 4370 58800 ) N ; + - u_s1_l41 BUF_X1 + FIXED ( 4370 60200 ) FS ; + - u_s1_l42 BUF_X1 + FIXED ( 4370 61600 ) N ; + - u_s1_l43 BUF_X1 + FIXED ( 4370 63000 ) FS ; + - u_s1_l44 BUF_X1 + FIXED ( 4370 64400 ) N ; + - u_s1_l45 BUF_X1 + FIXED ( 4370 65800 ) FS ; + - u_s1_l46 BUF_X1 + FIXED ( 4370 67200 ) N ; + - u_s1_l47 BUF_X1 + FIXED ( 4370 68600 ) FS ; + - u_s1_l48 BUF_X1 + FIXED ( 4370 70000 ) N ; + - u_s1_l49 BUF_X1 + FIXED ( 4370 71400 ) FS ; + - u_s1_l50 BUF_X1 + FIXED ( 4370 72800 ) N ; + - u_s1_l51 BUF_X1 + FIXED ( 4370 74200 ) FS ; + - u_s1_l52 BUF_X1 + FIXED ( 4370 75600 ) N ; + - u_s1_l53 BUF_X1 + FIXED ( 4370 77000 ) FS ; + - u_s1_l54 BUF_X1 + FIXED ( 4370 78400 ) N ; + - u_s1_l55 BUF_X1 + FIXED ( 4370 79800 ) FS ; + - u_s1_l56 BUF_X1 + FIXED ( 4370 81200 ) N ; + - u_s1_l57 BUF_X1 + FIXED ( 4370 82600 ) FS ; + - u_s1_l58 BUF_X1 + FIXED ( 4370 84000 ) N ; + - u_s1_l59 BUF_X1 + FIXED ( 4370 85400 ) FS ; + - u_s1_l60 BUF_X1 + FIXED ( 4370 86800 ) N ; + - u_s1_l61 BUF_X1 + FIXED ( 4370 88200 ) FS ; + - u_s1_l62 BUF_X1 + FIXED ( 4370 89600 ) N ; + - u_s1_l63 BUF_X1 + FIXED ( 4370 91000 ) FS ; + - u_s1_l64 BUF_X1 + FIXED ( 4370 92400 ) N ; + - u_s1_l65 BUF_X1 + FIXED ( 4370 93800 ) FS ; + - u_s1_l66 BUF_X1 + FIXED ( 4370 95200 ) N ; + - u_s1_l67 BUF_X1 + FIXED ( 4370 96600 ) FS ; + - u_s1_l68 BUF_X1 + FIXED ( 4370 98000 ) N ; + - u_s1_l69 BUF_X1 + FIXED ( 4370 99400 ) FS ; + - u_s1_l70 BUF_X1 + FIXED ( 4370 100800 ) N ; + - u_s1_l71 BUF_X1 + FIXED ( 4370 102200 ) FS ; + - u_s1_l72 BUF_X1 + FIXED ( 4370 103600 ) N ; + - u_s1_l73 BUF_X1 + FIXED ( 4370 105000 ) FS ; + - u_s1_l74 BUF_X1 + FIXED ( 4370 106400 ) N ; + - u_s1_l75 BUF_X1 + FIXED ( 4370 107800 ) FS ; + - u_s1_l76 BUF_X1 + FIXED ( 4370 109200 ) N ; + - u_s1_l77 BUF_X1 + FIXED ( 4370 110600 ) FS ; + - u_s1_l78 BUF_X1 + FIXED ( 4370 112000 ) N ; + - u_s1_l79 BUF_X1 + FIXED ( 4370 113400 ) FS ; + - u_s1_l80 BUF_X1 + FIXED ( 4370 114800 ) N ; + - u_s1_l81 BUF_X1 + FIXED ( 4370 116200 ) FS ; + - u_s1_l82 BUF_X1 + FIXED ( 4370 117600 ) N ; + - u_s1_l83 BUF_X1 + FIXED ( 4370 119000 ) FS ; + - u_s1_l84 BUF_X1 + FIXED ( 4370 120400 ) N ; + - u_s1_l85 BUF_X1 + FIXED ( 4370 121800 ) FS ; + - u_s1_l86 BUF_X1 + FIXED ( 4370 123200 ) N ; + - u_s1_l87 BUF_X1 + FIXED ( 4370 124600 ) FS ; + - u_s1_l88 BUF_X1 + FIXED ( 4370 126000 ) N ; + - u_s1_l89 BUF_X1 + FIXED ( 4370 127400 ) FS ; + - u_s1_l90 BUF_X1 + FIXED ( 4370 128800 ) N ; + - u_s1_l91 BUF_X1 + FIXED ( 4370 130200 ) FS ; + - u_s1_l92 BUF_X1 + FIXED ( 4370 131600 ) N ; + - u_s1_l93 BUF_X1 + FIXED ( 4370 133000 ) FS ; + - u_s1_l94 BUF_X1 + FIXED ( 4370 134400 ) N ; + - u_s1_l95 BUF_X1 + FIXED ( 4370 135800 ) FS ; + - u_s2_l0 BUF_X1 + FIXED ( 5510 2800 ) N ; + - u_s2_l1 BUF_X1 + FIXED ( 5510 4200 ) FS ; + - u_s2_l2 BUF_X1 + FIXED ( 5510 5600 ) N ; + - u_s2_l3 BUF_X1 + FIXED ( 5510 7000 ) FS ; + - u_s2_l4 BUF_X1 + FIXED ( 5510 8400 ) N ; + - u_s2_l5 BUF_X1 + FIXED ( 5510 9800 ) FS ; + - u_s2_l6 BUF_X1 + FIXED ( 5510 11200 ) N ; + - u_s2_l7 BUF_X1 + FIXED ( 5510 12600 ) FS ; + - u_s2_l8 BUF_X1 + FIXED ( 5510 14000 ) N ; + - u_s2_l9 BUF_X1 + FIXED ( 5510 15400 ) FS ; + - u_s2_l10 BUF_X1 + FIXED ( 5510 16800 ) N ; + - u_s2_l11 BUF_X1 + FIXED ( 5510 18200 ) FS ; + - u_s2_l12 BUF_X1 + FIXED ( 5510 19600 ) N ; + - u_s2_l13 BUF_X1 + FIXED ( 5510 21000 ) FS ; + - u_s2_l14 BUF_X1 + FIXED ( 5510 22400 ) N ; + - u_s2_l15 BUF_X1 + FIXED ( 5510 23800 ) FS ; + - u_s2_l16 BUF_X1 + FIXED ( 5510 25200 ) N ; + - u_s2_l17 BUF_X1 + FIXED ( 5510 26600 ) FS ; + - u_s2_l18 BUF_X1 + FIXED ( 5510 28000 ) N ; + - u_s2_l19 BUF_X1 + FIXED ( 5510 29400 ) FS ; + - u_s2_l20 BUF_X1 + FIXED ( 5510 30800 ) N ; + - u_s2_l21 BUF_X1 + FIXED ( 5510 32200 ) FS ; + - u_s2_l22 BUF_X1 + FIXED ( 5510 33600 ) N ; + - u_s2_l23 BUF_X1 + FIXED ( 5510 35000 ) FS ; + - u_s2_l24 BUF_X1 + FIXED ( 5510 36400 ) N ; + - u_s2_l25 BUF_X1 + FIXED ( 5510 37800 ) FS ; + - u_s2_l26 BUF_X1 + FIXED ( 5510 39200 ) N ; + - u_s2_l27 BUF_X1 + FIXED ( 5510 40600 ) FS ; + - u_s2_l28 BUF_X1 + FIXED ( 5510 42000 ) N ; + - u_s2_l29 BUF_X1 + FIXED ( 5510 43400 ) FS ; + - u_s2_l30 BUF_X1 + FIXED ( 5510 44800 ) N ; + - u_s2_l31 BUF_X1 + FIXED ( 5510 46200 ) FS ; + - u_s2_l32 BUF_X1 + FIXED ( 5510 47600 ) N ; + - u_s2_l33 BUF_X1 + FIXED ( 5510 49000 ) FS ; + - u_s2_l34 BUF_X1 + FIXED ( 5510 50400 ) N ; + - u_s2_l35 BUF_X1 + FIXED ( 5510 51800 ) FS ; + - u_s2_l36 BUF_X1 + FIXED ( 5510 53200 ) N ; + - u_s2_l37 BUF_X1 + FIXED ( 5510 54600 ) FS ; + - u_s2_l38 BUF_X1 + FIXED ( 5510 56000 ) N ; + - u_s2_l39 BUF_X1 + FIXED ( 5510 57400 ) FS ; + - u_s2_l40 BUF_X1 + FIXED ( 5510 58800 ) N ; + - u_s2_l41 BUF_X1 + FIXED ( 5510 60200 ) FS ; + - u_s2_l42 BUF_X1 + FIXED ( 5510 61600 ) N ; + - u_s2_l43 BUF_X1 + FIXED ( 5510 63000 ) FS ; + - u_s2_l44 BUF_X1 + FIXED ( 5510 64400 ) N ; + - u_s2_l45 BUF_X1 + FIXED ( 5510 65800 ) FS ; + - u_s2_l46 BUF_X1 + FIXED ( 5510 67200 ) N ; + - u_s2_l47 BUF_X1 + FIXED ( 5510 68600 ) FS ; + - u_s2_l48 BUF_X1 + FIXED ( 5510 70000 ) N ; + - u_s2_l49 BUF_X1 + FIXED ( 5510 71400 ) FS ; + - u_s2_l50 BUF_X1 + FIXED ( 5510 72800 ) N ; + - u_s2_l51 BUF_X1 + FIXED ( 5510 74200 ) FS ; + - u_s2_l52 BUF_X1 + FIXED ( 5510 75600 ) N ; + - u_s2_l53 BUF_X1 + FIXED ( 5510 77000 ) FS ; + - u_s2_l54 BUF_X1 + FIXED ( 5510 78400 ) N ; + - u_s2_l55 BUF_X1 + FIXED ( 5510 79800 ) FS ; + - u_s2_l56 BUF_X1 + FIXED ( 5510 81200 ) N ; + - u_s2_l57 BUF_X1 + FIXED ( 5510 82600 ) FS ; + - u_s2_l58 BUF_X1 + FIXED ( 5510 84000 ) N ; + - u_s2_l59 BUF_X1 + FIXED ( 5510 85400 ) FS ; + - u_s2_l60 BUF_X1 + FIXED ( 5510 86800 ) N ; + - u_s2_l61 BUF_X1 + FIXED ( 5510 88200 ) FS ; + - u_s2_l62 BUF_X1 + FIXED ( 5510 89600 ) N ; + - u_s2_l63 BUF_X1 + FIXED ( 5510 91000 ) FS ; + - u_s2_l64 BUF_X1 + FIXED ( 5510 92400 ) N ; + - u_s2_l65 BUF_X1 + FIXED ( 5510 93800 ) FS ; + - u_s2_l66 BUF_X1 + FIXED ( 5510 95200 ) N ; + - u_s2_l67 BUF_X1 + FIXED ( 5510 96600 ) FS ; + - u_s2_l68 BUF_X1 + FIXED ( 5510 98000 ) N ; + - u_s2_l69 BUF_X1 + FIXED ( 5510 99400 ) FS ; + - u_s2_l70 BUF_X1 + FIXED ( 5510 100800 ) N ; + - u_s2_l71 BUF_X1 + FIXED ( 5510 102200 ) FS ; + - u_s2_l72 BUF_X1 + FIXED ( 5510 103600 ) N ; + - u_s2_l73 BUF_X1 + FIXED ( 5510 105000 ) FS ; + - u_s2_l74 BUF_X1 + FIXED ( 5510 106400 ) N ; + - u_s2_l75 BUF_X1 + FIXED ( 5510 107800 ) FS ; + - u_s2_l76 BUF_X1 + FIXED ( 5510 109200 ) N ; + - u_s2_l77 BUF_X1 + FIXED ( 5510 110600 ) FS ; + - u_s2_l78 BUF_X1 + FIXED ( 5510 112000 ) N ; + - u_s2_l79 BUF_X1 + FIXED ( 5510 113400 ) FS ; + - u_s2_l80 BUF_X1 + FIXED ( 5510 114800 ) N ; + - u_s2_l81 BUF_X1 + FIXED ( 5510 116200 ) FS ; + - u_s2_l82 BUF_X1 + FIXED ( 5510 117600 ) N ; + - u_s2_l83 BUF_X1 + FIXED ( 5510 119000 ) FS ; + - u_s2_l84 BUF_X1 + FIXED ( 5510 120400 ) N ; + - u_s2_l85 BUF_X1 + FIXED ( 5510 121800 ) FS ; + - u_s2_l86 BUF_X1 + FIXED ( 5510 123200 ) N ; + - u_s2_l87 BUF_X1 + FIXED ( 5510 124600 ) FS ; + - u_s2_l88 BUF_X1 + FIXED ( 5510 126000 ) N ; + - u_s2_l89 BUF_X1 + FIXED ( 5510 127400 ) FS ; + - u_s2_l90 BUF_X1 + FIXED ( 5510 128800 ) N ; + - u_s2_l91 BUF_X1 + FIXED ( 5510 130200 ) FS ; + - u_s2_l92 BUF_X1 + FIXED ( 5510 131600 ) N ; + - u_s2_l93 BUF_X1 + FIXED ( 5510 133000 ) FS ; + - u_s2_l94 BUF_X1 + FIXED ( 5510 134400 ) N ; + - u_s2_l95 BUF_X1 + FIXED ( 5510 135800 ) FS ; + - u_s3_l0 BUF_X1 + FIXED ( 6650 2800 ) N ; + - u_s3_l1 BUF_X1 + FIXED ( 6650 4200 ) FS ; + - u_s3_l2 BUF_X1 + FIXED ( 6650 5600 ) N ; + - u_s3_l3 BUF_X1 + FIXED ( 6650 7000 ) FS ; + - u_s3_l4 BUF_X1 + FIXED ( 6650 8400 ) N ; + - u_s3_l5 BUF_X1 + FIXED ( 6650 9800 ) FS ; + - u_s3_l6 BUF_X1 + FIXED ( 6650 11200 ) N ; + - u_s3_l7 BUF_X1 + FIXED ( 6650 12600 ) FS ; + - u_s3_l8 BUF_X1 + FIXED ( 6650 14000 ) N ; + - u_s3_l9 BUF_X1 + FIXED ( 6650 15400 ) FS ; + - u_s3_l10 BUF_X1 + FIXED ( 6650 16800 ) N ; + - u_s3_l11 BUF_X1 + FIXED ( 6650 18200 ) FS ; + - u_s3_l12 BUF_X1 + FIXED ( 6650 19600 ) N ; + - u_s3_l13 BUF_X1 + FIXED ( 6650 21000 ) FS ; + - u_s3_l14 BUF_X1 + FIXED ( 6650 22400 ) N ; + - u_s3_l15 BUF_X1 + FIXED ( 6650 23800 ) FS ; + - u_s3_l16 BUF_X1 + FIXED ( 6650 25200 ) N ; + - u_s3_l17 BUF_X1 + FIXED ( 6650 26600 ) FS ; + - u_s3_l18 BUF_X1 + FIXED ( 6650 28000 ) N ; + - u_s3_l19 BUF_X1 + FIXED ( 6650 29400 ) FS ; + - u_s3_l20 BUF_X1 + FIXED ( 6650 30800 ) N ; + - u_s3_l21 BUF_X1 + FIXED ( 6650 32200 ) FS ; + - u_s3_l22 BUF_X1 + FIXED ( 6650 33600 ) N ; + - u_s3_l23 BUF_X1 + FIXED ( 6650 35000 ) FS ; + - u_s3_l24 BUF_X1 + FIXED ( 6650 36400 ) N ; + - u_s3_l25 BUF_X1 + FIXED ( 6650 37800 ) FS ; + - u_s3_l26 BUF_X1 + FIXED ( 6650 39200 ) N ; + - u_s3_l27 BUF_X1 + FIXED ( 6650 40600 ) FS ; + - u_s3_l28 BUF_X1 + FIXED ( 6650 42000 ) N ; + - u_s3_l29 BUF_X1 + FIXED ( 6650 43400 ) FS ; + - u_s3_l30 BUF_X1 + FIXED ( 6650 44800 ) N ; + - u_s3_l31 BUF_X1 + FIXED ( 6650 46200 ) FS ; + - u_s3_l32 BUF_X1 + FIXED ( 6650 47600 ) N ; + - u_s3_l33 BUF_X1 + FIXED ( 6650 49000 ) FS ; + - u_s3_l34 BUF_X1 + FIXED ( 6650 50400 ) N ; + - u_s3_l35 BUF_X1 + FIXED ( 6650 51800 ) FS ; + - u_s3_l36 BUF_X1 + FIXED ( 6650 53200 ) N ; + - u_s3_l37 BUF_X1 + FIXED ( 6650 54600 ) FS ; + - u_s3_l38 BUF_X1 + FIXED ( 6650 56000 ) N ; + - u_s3_l39 BUF_X1 + FIXED ( 6650 57400 ) FS ; + - u_s3_l40 BUF_X1 + FIXED ( 6650 58800 ) N ; + - u_s3_l41 BUF_X1 + FIXED ( 6650 60200 ) FS ; + - u_s3_l42 BUF_X1 + FIXED ( 6650 61600 ) N ; + - u_s3_l43 BUF_X1 + FIXED ( 6650 63000 ) FS ; + - u_s3_l44 BUF_X1 + FIXED ( 6650 64400 ) N ; + - u_s3_l45 BUF_X1 + FIXED ( 6650 65800 ) FS ; + - u_s3_l46 BUF_X1 + FIXED ( 6650 67200 ) N ; + - u_s3_l47 BUF_X1 + FIXED ( 6650 68600 ) FS ; + - u_s3_l48 BUF_X1 + FIXED ( 6650 70000 ) N ; + - u_s3_l49 BUF_X1 + FIXED ( 6650 71400 ) FS ; + - u_s3_l50 BUF_X1 + FIXED ( 6650 72800 ) N ; + - u_s3_l51 BUF_X1 + FIXED ( 6650 74200 ) FS ; + - u_s3_l52 BUF_X1 + FIXED ( 6650 75600 ) N ; + - u_s3_l53 BUF_X1 + FIXED ( 6650 77000 ) FS ; + - u_s3_l54 BUF_X1 + FIXED ( 6650 78400 ) N ; + - u_s3_l55 BUF_X1 + FIXED ( 6650 79800 ) FS ; + - u_s3_l56 BUF_X1 + FIXED ( 6650 81200 ) N ; + - u_s3_l57 BUF_X1 + FIXED ( 6650 82600 ) FS ; + - u_s3_l58 BUF_X1 + FIXED ( 6650 84000 ) N ; + - u_s3_l59 BUF_X1 + FIXED ( 6650 85400 ) FS ; + - u_s3_l60 BUF_X1 + FIXED ( 6650 86800 ) N ; + - u_s3_l61 BUF_X1 + FIXED ( 6650 88200 ) FS ; + - u_s3_l62 BUF_X1 + FIXED ( 6650 89600 ) N ; + - u_s3_l63 BUF_X1 + FIXED ( 6650 91000 ) FS ; + - u_s3_l64 BUF_X1 + FIXED ( 6650 92400 ) N ; + - u_s3_l65 BUF_X1 + FIXED ( 6650 93800 ) FS ; + - u_s3_l66 BUF_X1 + FIXED ( 6650 95200 ) N ; + - u_s3_l67 BUF_X1 + FIXED ( 6650 96600 ) FS ; + - u_s3_l68 BUF_X1 + FIXED ( 6650 98000 ) N ; + - u_s3_l69 BUF_X1 + FIXED ( 6650 99400 ) FS ; + - u_s3_l70 BUF_X1 + FIXED ( 6650 100800 ) N ; + - u_s3_l71 BUF_X1 + FIXED ( 6650 102200 ) FS ; + - u_s3_l72 BUF_X1 + FIXED ( 6650 103600 ) N ; + - u_s3_l73 BUF_X1 + FIXED ( 6650 105000 ) FS ; + - u_s3_l74 BUF_X1 + FIXED ( 6650 106400 ) N ; + - u_s3_l75 BUF_X1 + FIXED ( 6650 107800 ) FS ; + - u_s3_l76 BUF_X1 + FIXED ( 6650 109200 ) N ; + - u_s3_l77 BUF_X1 + FIXED ( 6650 110600 ) FS ; + - u_s3_l78 BUF_X1 + FIXED ( 6650 112000 ) N ; + - u_s3_l79 BUF_X1 + FIXED ( 6650 113400 ) FS ; + - u_s3_l80 BUF_X1 + FIXED ( 6650 114800 ) N ; + - u_s3_l81 BUF_X1 + FIXED ( 6650 116200 ) FS ; + - u_s3_l82 BUF_X1 + FIXED ( 6650 117600 ) N ; + - u_s3_l83 BUF_X1 + FIXED ( 6650 119000 ) FS ; + - u_s3_l84 BUF_X1 + FIXED ( 6650 120400 ) N ; + - u_s3_l85 BUF_X1 + FIXED ( 6650 121800 ) FS ; + - u_s3_l86 BUF_X1 + FIXED ( 6650 123200 ) N ; + - u_s3_l87 BUF_X1 + FIXED ( 6650 124600 ) FS ; + - u_s3_l88 BUF_X1 + FIXED ( 6650 126000 ) N ; + - u_s3_l89 BUF_X1 + FIXED ( 6650 127400 ) FS ; + - u_s3_l90 BUF_X1 + FIXED ( 6650 128800 ) N ; + - u_s3_l91 BUF_X1 + FIXED ( 6650 130200 ) FS ; + - u_s3_l92 BUF_X1 + FIXED ( 6650 131600 ) N ; + - u_s3_l93 BUF_X1 + FIXED ( 6650 133000 ) FS ; + - u_s3_l94 BUF_X1 + FIXED ( 6650 134400 ) N ; + - u_s3_l95 BUF_X1 + FIXED ( 6650 135800 ) FS ; + - u_s4_l0 BUF_X1 + FIXED ( 7790 2800 ) N ; + - u_s4_l1 BUF_X1 + FIXED ( 7790 4200 ) FS ; + - u_s4_l2 BUF_X1 + FIXED ( 7790 5600 ) N ; + - u_s4_l3 BUF_X1 + FIXED ( 7790 7000 ) FS ; + - u_s4_l4 BUF_X1 + FIXED ( 7790 8400 ) N ; + - u_s4_l5 BUF_X1 + FIXED ( 7790 9800 ) FS ; + - u_s4_l6 BUF_X1 + FIXED ( 7790 11200 ) N ; + - u_s4_l7 BUF_X1 + FIXED ( 7790 12600 ) FS ; + - u_s4_l8 BUF_X1 + FIXED ( 7790 14000 ) N ; + - u_s4_l9 BUF_X1 + FIXED ( 7790 15400 ) FS ; + - u_s4_l10 BUF_X1 + FIXED ( 7790 16800 ) N ; + - u_s4_l11 BUF_X1 + FIXED ( 7790 18200 ) FS ; + - u_s4_l12 BUF_X1 + FIXED ( 7790 19600 ) N ; + - u_s4_l13 BUF_X1 + FIXED ( 7790 21000 ) FS ; + - u_s4_l14 BUF_X1 + FIXED ( 7790 22400 ) N ; + - u_s4_l15 BUF_X1 + FIXED ( 7790 23800 ) FS ; + - u_s4_l16 BUF_X1 + FIXED ( 7790 25200 ) N ; + - u_s4_l17 BUF_X1 + FIXED ( 7790 26600 ) FS ; + - u_s4_l18 BUF_X1 + FIXED ( 7790 28000 ) N ; + - u_s4_l19 BUF_X1 + FIXED ( 7790 29400 ) FS ; + - u_s4_l20 BUF_X1 + FIXED ( 7790 30800 ) N ; + - u_s4_l21 BUF_X1 + FIXED ( 7790 32200 ) FS ; + - u_s4_l22 BUF_X1 + FIXED ( 7790 33600 ) N ; + - u_s4_l23 BUF_X1 + FIXED ( 7790 35000 ) FS ; + - u_s4_l24 BUF_X1 + FIXED ( 7790 36400 ) N ; + - u_s4_l25 BUF_X1 + FIXED ( 7790 37800 ) FS ; + - u_s4_l26 BUF_X1 + FIXED ( 7790 39200 ) N ; + - u_s4_l27 BUF_X1 + FIXED ( 7790 40600 ) FS ; + - u_s4_l28 BUF_X1 + FIXED ( 7790 42000 ) N ; + - u_s4_l29 BUF_X1 + FIXED ( 7790 43400 ) FS ; + - u_s4_l30 BUF_X1 + FIXED ( 7790 44800 ) N ; + - u_s4_l31 BUF_X1 + FIXED ( 7790 46200 ) FS ; + - u_s4_l32 BUF_X1 + FIXED ( 7790 47600 ) N ; + - u_s4_l33 BUF_X1 + FIXED ( 7790 49000 ) FS ; + - u_s4_l34 BUF_X1 + FIXED ( 7790 50400 ) N ; + - u_s4_l35 BUF_X1 + FIXED ( 7790 51800 ) FS ; + - u_s4_l36 BUF_X1 + FIXED ( 7790 53200 ) N ; + - u_s4_l37 BUF_X1 + FIXED ( 7790 54600 ) FS ; + - u_s4_l38 BUF_X1 + FIXED ( 7790 56000 ) N ; + - u_s4_l39 BUF_X1 + FIXED ( 7790 57400 ) FS ; + - u_s4_l40 BUF_X1 + FIXED ( 7790 58800 ) N ; + - u_s4_l41 BUF_X1 + FIXED ( 7790 60200 ) FS ; + - u_s4_l42 BUF_X1 + FIXED ( 7790 61600 ) N ; + - u_s4_l43 BUF_X1 + FIXED ( 7790 63000 ) FS ; + - u_s4_l44 BUF_X1 + FIXED ( 7790 64400 ) N ; + - u_s4_l45 BUF_X1 + FIXED ( 7790 65800 ) FS ; + - u_s4_l46 BUF_X1 + FIXED ( 7790 67200 ) N ; + - u_s4_l47 BUF_X1 + FIXED ( 7790 68600 ) FS ; + - u_s4_l48 BUF_X1 + FIXED ( 7790 70000 ) N ; + - u_s4_l49 BUF_X1 + FIXED ( 7790 71400 ) FS ; + - u_s4_l50 BUF_X1 + FIXED ( 7790 72800 ) N ; + - u_s4_l51 BUF_X1 + FIXED ( 7790 74200 ) FS ; + - u_s4_l52 BUF_X1 + FIXED ( 7790 75600 ) N ; + - u_s4_l53 BUF_X1 + FIXED ( 7790 77000 ) FS ; + - u_s4_l54 BUF_X1 + FIXED ( 7790 78400 ) N ; + - u_s4_l55 BUF_X1 + FIXED ( 7790 79800 ) FS ; + - u_s4_l56 BUF_X1 + FIXED ( 7790 81200 ) N ; + - u_s4_l57 BUF_X1 + FIXED ( 7790 82600 ) FS ; + - u_s4_l58 BUF_X1 + FIXED ( 7790 84000 ) N ; + - u_s4_l59 BUF_X1 + FIXED ( 7790 85400 ) FS ; + - u_s4_l60 BUF_X1 + FIXED ( 7790 86800 ) N ; + - u_s4_l61 BUF_X1 + FIXED ( 7790 88200 ) FS ; + - u_s4_l62 BUF_X1 + FIXED ( 7790 89600 ) N ; + - u_s4_l63 BUF_X1 + FIXED ( 7790 91000 ) FS ; + - u_s4_l64 BUF_X1 + FIXED ( 7790 92400 ) N ; + - u_s4_l65 BUF_X1 + FIXED ( 7790 93800 ) FS ; + - u_s4_l66 BUF_X1 + FIXED ( 7790 95200 ) N ; + - u_s4_l67 BUF_X1 + FIXED ( 7790 96600 ) FS ; + - u_s4_l68 BUF_X1 + FIXED ( 7790 98000 ) N ; + - u_s4_l69 BUF_X1 + FIXED ( 7790 99400 ) FS ; + - u_s4_l70 BUF_X1 + FIXED ( 7790 100800 ) N ; + - u_s4_l71 BUF_X1 + FIXED ( 7790 102200 ) FS ; + - u_s4_l72 BUF_X1 + FIXED ( 7790 103600 ) N ; + - u_s4_l73 BUF_X1 + FIXED ( 7790 105000 ) FS ; + - u_s4_l74 BUF_X1 + FIXED ( 7790 106400 ) N ; + - u_s4_l75 BUF_X1 + FIXED ( 7790 107800 ) FS ; + - u_s4_l76 BUF_X1 + FIXED ( 7790 109200 ) N ; + - u_s4_l77 BUF_X1 + FIXED ( 7790 110600 ) FS ; + - u_s4_l78 BUF_X1 + FIXED ( 7790 112000 ) N ; + - u_s4_l79 BUF_X1 + FIXED ( 7790 113400 ) FS ; + - u_s4_l80 BUF_X1 + FIXED ( 7790 114800 ) N ; + - u_s4_l81 BUF_X1 + FIXED ( 7790 116200 ) FS ; + - u_s4_l82 BUF_X1 + FIXED ( 7790 117600 ) N ; + - u_s4_l83 BUF_X1 + FIXED ( 7790 119000 ) FS ; + - u_s4_l84 BUF_X1 + FIXED ( 7790 120400 ) N ; + - u_s4_l85 BUF_X1 + FIXED ( 7790 121800 ) FS ; + - u_s4_l86 BUF_X1 + FIXED ( 7790 123200 ) N ; + - u_s4_l87 BUF_X1 + FIXED ( 7790 124600 ) FS ; + - u_s4_l88 BUF_X1 + FIXED ( 7790 126000 ) N ; + - u_s4_l89 BUF_X1 + FIXED ( 7790 127400 ) FS ; + - u_s4_l90 BUF_X1 + FIXED ( 7790 128800 ) N ; + - u_s4_l91 BUF_X1 + FIXED ( 7790 130200 ) FS ; + - u_s4_l92 BUF_X1 + FIXED ( 7790 131600 ) N ; + - u_s4_l93 BUF_X1 + FIXED ( 7790 133000 ) FS ; + - u_s4_l94 BUF_X1 + FIXED ( 7790 134400 ) N ; + - u_s4_l95 BUF_X1 + FIXED ( 7790 135800 ) FS ; + - u_s5_l0 BUF_X1 + FIXED ( 8930 2800 ) N ; + - u_s5_l1 BUF_X1 + FIXED ( 8930 4200 ) FS ; + - u_s5_l2 BUF_X1 + FIXED ( 8930 5600 ) N ; + - u_s5_l3 BUF_X1 + FIXED ( 8930 7000 ) FS ; + - u_s5_l4 BUF_X1 + FIXED ( 8930 8400 ) N ; + - u_s5_l5 BUF_X1 + FIXED ( 8930 9800 ) FS ; + - u_s5_l6 BUF_X1 + FIXED ( 8930 11200 ) N ; + - u_s5_l7 BUF_X1 + FIXED ( 8930 12600 ) FS ; + - u_s5_l8 BUF_X1 + FIXED ( 8930 14000 ) N ; + - u_s5_l9 BUF_X1 + FIXED ( 8930 15400 ) FS ; + - u_s5_l10 BUF_X1 + FIXED ( 8930 16800 ) N ; + - u_s5_l11 BUF_X1 + FIXED ( 8930 18200 ) FS ; + - u_s5_l12 BUF_X1 + FIXED ( 8930 19600 ) N ; + - u_s5_l13 BUF_X1 + FIXED ( 8930 21000 ) FS ; + - u_s5_l14 BUF_X1 + FIXED ( 8930 22400 ) N ; + - u_s5_l15 BUF_X1 + FIXED ( 8930 23800 ) FS ; + - u_s5_l16 BUF_X1 + FIXED ( 8930 25200 ) N ; + - u_s5_l17 BUF_X1 + FIXED ( 8930 26600 ) FS ; + - u_s5_l18 BUF_X1 + FIXED ( 8930 28000 ) N ; + - u_s5_l19 BUF_X1 + FIXED ( 8930 29400 ) FS ; + - u_s5_l20 BUF_X1 + FIXED ( 8930 30800 ) N ; + - u_s5_l21 BUF_X1 + FIXED ( 8930 32200 ) FS ; + - u_s5_l22 BUF_X1 + FIXED ( 8930 33600 ) N ; + - u_s5_l23 BUF_X1 + FIXED ( 8930 35000 ) FS ; + - u_s5_l24 BUF_X1 + FIXED ( 8930 36400 ) N ; + - u_s5_l25 BUF_X1 + FIXED ( 8930 37800 ) FS ; + - u_s5_l26 BUF_X1 + FIXED ( 8930 39200 ) N ; + - u_s5_l27 BUF_X1 + FIXED ( 8930 40600 ) FS ; + - u_s5_l28 BUF_X1 + FIXED ( 8930 42000 ) N ; + - u_s5_l29 BUF_X1 + FIXED ( 8930 43400 ) FS ; + - u_s5_l30 BUF_X1 + FIXED ( 8930 44800 ) N ; + - u_s5_l31 BUF_X1 + FIXED ( 8930 46200 ) FS ; + - u_s5_l32 BUF_X1 + FIXED ( 8930 47600 ) N ; + - u_s5_l33 BUF_X1 + FIXED ( 8930 49000 ) FS ; + - u_s5_l34 BUF_X1 + FIXED ( 8930 50400 ) N ; + - u_s5_l35 BUF_X1 + FIXED ( 8930 51800 ) FS ; + - u_s5_l36 BUF_X1 + FIXED ( 8930 53200 ) N ; + - u_s5_l37 BUF_X1 + FIXED ( 8930 54600 ) FS ; + - u_s5_l38 BUF_X1 + FIXED ( 8930 56000 ) N ; + - u_s5_l39 BUF_X1 + FIXED ( 8930 57400 ) FS ; + - u_s5_l40 BUF_X1 + FIXED ( 8930 58800 ) N ; + - u_s5_l41 BUF_X1 + FIXED ( 8930 60200 ) FS ; + - u_s5_l42 BUF_X1 + FIXED ( 8930 61600 ) N ; + - u_s5_l43 BUF_X1 + FIXED ( 8930 63000 ) FS ; + - u_s5_l44 BUF_X1 + FIXED ( 8930 64400 ) N ; + - u_s5_l45 BUF_X1 + FIXED ( 8930 65800 ) FS ; + - u_s5_l46 BUF_X1 + FIXED ( 8930 67200 ) N ; + - u_s5_l47 BUF_X1 + FIXED ( 8930 68600 ) FS ; + - u_s5_l48 BUF_X1 + FIXED ( 8930 70000 ) N ; + - u_s5_l49 BUF_X1 + FIXED ( 8930 71400 ) FS ; + - u_s5_l50 BUF_X1 + FIXED ( 8930 72800 ) N ; + - u_s5_l51 BUF_X1 + FIXED ( 8930 74200 ) FS ; + - u_s5_l52 BUF_X1 + FIXED ( 8930 75600 ) N ; + - u_s5_l53 BUF_X1 + FIXED ( 8930 77000 ) FS ; + - u_s5_l54 BUF_X1 + FIXED ( 8930 78400 ) N ; + - u_s5_l55 BUF_X1 + FIXED ( 8930 79800 ) FS ; + - u_s5_l56 BUF_X1 + FIXED ( 8930 81200 ) N ; + - u_s5_l57 BUF_X1 + FIXED ( 8930 82600 ) FS ; + - u_s5_l58 BUF_X1 + FIXED ( 8930 84000 ) N ; + - u_s5_l59 BUF_X1 + FIXED ( 8930 85400 ) FS ; + - u_s5_l60 BUF_X1 + FIXED ( 8930 86800 ) N ; + - u_s5_l61 BUF_X1 + FIXED ( 8930 88200 ) FS ; + - u_s5_l62 BUF_X1 + FIXED ( 8930 89600 ) N ; + - u_s5_l63 BUF_X1 + FIXED ( 8930 91000 ) FS ; + - u_s5_l64 BUF_X1 + FIXED ( 8930 92400 ) N ; + - u_s5_l65 BUF_X1 + FIXED ( 8930 93800 ) FS ; + - u_s5_l66 BUF_X1 + FIXED ( 8930 95200 ) N ; + - u_s5_l67 BUF_X1 + FIXED ( 8930 96600 ) FS ; + - u_s5_l68 BUF_X1 + FIXED ( 8930 98000 ) N ; + - u_s5_l69 BUF_X1 + FIXED ( 8930 99400 ) FS ; + - u_s5_l70 BUF_X1 + FIXED ( 8930 100800 ) N ; + - u_s5_l71 BUF_X1 + FIXED ( 8930 102200 ) FS ; + - u_s5_l72 BUF_X1 + FIXED ( 8930 103600 ) N ; + - u_s5_l73 BUF_X1 + FIXED ( 8930 105000 ) FS ; + - u_s5_l74 BUF_X1 + FIXED ( 8930 106400 ) N ; + - u_s5_l75 BUF_X1 + FIXED ( 8930 107800 ) FS ; + - u_s5_l76 BUF_X1 + FIXED ( 8930 109200 ) N ; + - u_s5_l77 BUF_X1 + FIXED ( 8930 110600 ) FS ; + - u_s5_l78 BUF_X1 + FIXED ( 8930 112000 ) N ; + - u_s5_l79 BUF_X1 + FIXED ( 8930 113400 ) FS ; + - u_s5_l80 BUF_X1 + FIXED ( 8930 114800 ) N ; + - u_s5_l81 BUF_X1 + FIXED ( 8930 116200 ) FS ; + - u_s5_l82 BUF_X1 + FIXED ( 8930 117600 ) N ; + - u_s5_l83 BUF_X1 + FIXED ( 8930 119000 ) FS ; + - u_s5_l84 BUF_X1 + FIXED ( 8930 120400 ) N ; + - u_s5_l85 BUF_X1 + FIXED ( 8930 121800 ) FS ; + - u_s5_l86 BUF_X1 + FIXED ( 8930 123200 ) N ; + - u_s5_l87 BUF_X1 + FIXED ( 8930 124600 ) FS ; + - u_s5_l88 BUF_X1 + FIXED ( 8930 126000 ) N ; + - u_s5_l89 BUF_X1 + FIXED ( 8930 127400 ) FS ; + - u_s5_l90 BUF_X1 + FIXED ( 8930 128800 ) N ; + - u_s5_l91 BUF_X1 + FIXED ( 8930 130200 ) FS ; + - u_s5_l92 BUF_X1 + FIXED ( 8930 131600 ) N ; + - u_s5_l93 BUF_X1 + FIXED ( 8930 133000 ) FS ; + - u_s5_l94 BUF_X1 + FIXED ( 8930 134400 ) N ; + - u_s5_l95 BUF_X1 + FIXED ( 8930 135800 ) FS ; +END COMPONENTS +PINS 192 ; + - in[0] + NET in[0] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 3430 ) N ; + - in[1] + NET in[1] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 4830 ) N ; + - in[2] + NET in[2] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 6230 ) N ; + - in[3] + NET in[3] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 7630 ) N ; + - in[4] + NET in[4] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 9030 ) N ; + - in[5] + NET in[5] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 10430 ) N ; + - in[6] + NET in[6] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 11830 ) N ; + - in[7] + NET in[7] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 13230 ) N ; + - in[8] + NET in[8] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 14630 ) N ; + - in[9] + NET in[9] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 16030 ) N ; + - in[10] + NET in[10] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 17430 ) N ; + - in[11] + NET in[11] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 18830 ) N ; + - in[12] + NET in[12] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 20230 ) N ; + - in[13] + NET in[13] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 21630 ) N ; + - in[14] + NET in[14] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 23030 ) N ; + - in[15] + NET in[15] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 24430 ) N ; + - in[16] + NET in[16] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 25830 ) N ; + - in[17] + NET in[17] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 27230 ) N ; + - in[18] + NET in[18] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 28630 ) N ; + - in[19] + NET in[19] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 30030 ) N ; + - in[20] + NET in[20] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 31430 ) N ; + - in[21] + NET in[21] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 32830 ) N ; + - in[22] + NET in[22] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 34230 ) N ; + - in[23] + NET in[23] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 35630 ) N ; + - in[24] + NET in[24] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 37030 ) N ; + - in[25] + NET in[25] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 38430 ) N ; + - in[26] + NET in[26] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 39830 ) N ; + - in[27] + NET in[27] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 41230 ) N ; + - in[28] + NET in[28] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 42630 ) N ; + - in[29] + NET in[29] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 44030 ) N ; + - in[30] + NET in[30] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 45430 ) N ; + - in[31] + NET in[31] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 46830 ) N ; + - in[32] + NET in[32] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 48230 ) N ; + - in[33] + NET in[33] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 49630 ) N ; + - in[34] + NET in[34] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 51030 ) N ; + - in[35] + NET in[35] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 52430 ) N ; + - in[36] + NET in[36] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 53830 ) N ; + - in[37] + NET in[37] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 55230 ) N ; + - in[38] + NET in[38] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 56630 ) N ; + - in[39] + NET in[39] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 58030 ) N ; + - in[40] + NET in[40] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 59430 ) N ; + - in[41] + NET in[41] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 60830 ) N ; + - in[42] + NET in[42] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 62230 ) N ; + - in[43] + NET in[43] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 63630 ) N ; + - in[44] + NET in[44] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 65030 ) N ; + - in[45] + NET in[45] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 66430 ) N ; + - in[46] + NET in[46] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 67830 ) N ; + - in[47] + NET in[47] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 69230 ) N ; + - in[48] + NET in[48] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 70630 ) N ; + - in[49] + NET in[49] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 72030 ) N ; + - in[50] + NET in[50] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 73430 ) N ; + - in[51] + NET in[51] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 74830 ) N ; + - in[52] + NET in[52] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 76230 ) N ; + - in[53] + NET in[53] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 77630 ) N ; + - in[54] + NET in[54] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 79030 ) N ; + - in[55] + NET in[55] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 80430 ) N ; + - in[56] + NET in[56] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 81830 ) N ; + - in[57] + NET in[57] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 83230 ) N ; + - in[58] + NET in[58] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 84630 ) N ; + - in[59] + NET in[59] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 86030 ) N ; + - in[60] + NET in[60] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 87430 ) N ; + - in[61] + NET in[61] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 88830 ) N ; + - in[62] + NET in[62] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 90230 ) N ; + - in[63] + NET in[63] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 91630 ) N ; + - in[64] + NET in[64] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 93030 ) N ; + - in[65] + NET in[65] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 94430 ) N ; + - in[66] + NET in[66] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 95830 ) N ; + - in[67] + NET in[67] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 97230 ) N ; + - in[68] + NET in[68] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 98630 ) N ; + - in[69] + NET in[69] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 100030 ) N ; + - in[70] + NET in[70] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 101430 ) N ; + - in[71] + NET in[71] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 102830 ) N ; + - in[72] + NET in[72] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 104230 ) N ; + - in[73] + NET in[73] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 105630 ) N ; + - in[74] + NET in[74] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 107030 ) N ; + - in[75] + NET in[75] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 108430 ) N ; + - in[76] + NET in[76] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 109830 ) N ; + - in[77] + NET in[77] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 111230 ) N ; + - in[78] + NET in[78] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 112630 ) N ; + - in[79] + NET in[79] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 114030 ) N ; + - in[80] + NET in[80] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 115430 ) N ; + - in[81] + NET in[81] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 116830 ) N ; + - in[82] + NET in[82] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 118230 ) N ; + - in[83] + NET in[83] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 119630 ) N ; + - in[84] + NET in[84] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 121030 ) N ; + - in[85] + NET in[85] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 122430 ) N ; + - in[86] + NET in[86] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 123830 ) N ; + - in[87] + NET in[87] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 125230 ) N ; + - in[88] + NET in[88] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 126630 ) N ; + - in[89] + NET in[89] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 128030 ) N ; + - in[90] + NET in[90] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 129430 ) N ; + - in[91] + NET in[91] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 130830 ) N ; + - in[92] + NET in[92] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 132230 ) N ; + - in[93] + NET in[93] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 133630 ) N ; + - in[94] + NET in[94] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 135030 ) N ; + - in[95] + NET in[95] + DIRECTION INPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 297 136430 ) N ; + - out[0] + NET out[0] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 3430 ) N ; + - out[1] + NET out[1] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 4830 ) N ; + - out[2] + NET out[2] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 6230 ) N ; + - out[3] + NET out[3] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 7630 ) N ; + - out[4] + NET out[4] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 9030 ) N ; + - out[5] + NET out[5] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 10430 ) N ; + - out[6] + NET out[6] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 11830 ) N ; + - out[7] + NET out[7] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 13230 ) N ; + - out[8] + NET out[8] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 14630 ) N ; + - out[9] + NET out[9] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 16030 ) N ; + - out[10] + NET out[10] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 17430 ) N ; + - out[11] + NET out[11] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 18830 ) N ; + - out[12] + NET out[12] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 20230 ) N ; + - out[13] + NET out[13] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 21630 ) N ; + - out[14] + NET out[14] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 23030 ) N ; + - out[15] + NET out[15] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 24430 ) N ; + - out[16] + NET out[16] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 25830 ) N ; + - out[17] + NET out[17] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 27230 ) N ; + - out[18] + NET out[18] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 28630 ) N ; + - out[19] + NET out[19] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 30030 ) N ; + - out[20] + NET out[20] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 31430 ) N ; + - out[21] + NET out[21] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 32830 ) N ; + - out[22] + NET out[22] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 34230 ) N ; + - out[23] + NET out[23] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 35630 ) N ; + - out[24] + NET out[24] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 37030 ) N ; + - out[25] + NET out[25] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 38430 ) N ; + - out[26] + NET out[26] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 39830 ) N ; + - out[27] + NET out[27] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 41230 ) N ; + - out[28] + NET out[28] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 42630 ) N ; + - out[29] + NET out[29] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 44030 ) N ; + - out[30] + NET out[30] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 45430 ) N ; + - out[31] + NET out[31] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 46830 ) N ; + - out[32] + NET out[32] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 48230 ) N ; + - out[33] + NET out[33] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 49630 ) N ; + - out[34] + NET out[34] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 51030 ) N ; + - out[35] + NET out[35] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 52430 ) N ; + - out[36] + NET out[36] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 53830 ) N ; + - out[37] + NET out[37] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 55230 ) N ; + - out[38] + NET out[38] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 56630 ) N ; + - out[39] + NET out[39] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 58030 ) N ; + - out[40] + NET out[40] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 59430 ) N ; + - out[41] + NET out[41] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 60830 ) N ; + - out[42] + NET out[42] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 62230 ) N ; + - out[43] + NET out[43] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 63630 ) N ; + - out[44] + NET out[44] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 65030 ) N ; + - out[45] + NET out[45] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 66430 ) N ; + - out[46] + NET out[46] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 67830 ) N ; + - out[47] + NET out[47] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 69230 ) N ; + - out[48] + NET out[48] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 70630 ) N ; + - out[49] + NET out[49] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 72030 ) N ; + - out[50] + NET out[50] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 73430 ) N ; + - out[51] + NET out[51] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 74830 ) N ; + - out[52] + NET out[52] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 76230 ) N ; + - out[53] + NET out[53] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 77630 ) N ; + - out[54] + NET out[54] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 79030 ) N ; + - out[55] + NET out[55] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 80430 ) N ; + - out[56] + NET out[56] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 81830 ) N ; + - out[57] + NET out[57] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 83230 ) N ; + - out[58] + NET out[58] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 84630 ) N ; + - out[59] + NET out[59] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 86030 ) N ; + - out[60] + NET out[60] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 87430 ) N ; + - out[61] + NET out[61] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 88830 ) N ; + - out[62] + NET out[62] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 90230 ) N ; + - out[63] + NET out[63] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 91630 ) N ; + - out[64] + NET out[64] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 93030 ) N ; + - out[65] + NET out[65] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 94430 ) N ; + - out[66] + NET out[66] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 95830 ) N ; + - out[67] + NET out[67] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 97230 ) N ; + - out[68] + NET out[68] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 98630 ) N ; + - out[69] + NET out[69] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 100030 ) N ; + - out[70] + NET out[70] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 101430 ) N ; + - out[71] + NET out[71] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 102830 ) N ; + - out[72] + NET out[72] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 104230 ) N ; + - out[73] + NET out[73] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 105630 ) N ; + - out[74] + NET out[74] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 107030 ) N ; + - out[75] + NET out[75] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 108430 ) N ; + - out[76] + NET out[76] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 109830 ) N ; + - out[77] + NET out[77] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 111230 ) N ; + - out[78] + NET out[78] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 112630 ) N ; + - out[79] + NET out[79] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 114030 ) N ; + - out[80] + NET out[80] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 115430 ) N ; + - out[81] + NET out[81] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 116830 ) N ; + - out[82] + NET out[82] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 118230 ) N ; + - out[83] + NET out[83] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 119630 ) N ; + - out[84] + NET out[84] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 121030 ) N ; + - out[85] + NET out[85] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 122430 ) N ; + - out[86] + NET out[86] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 123830 ) N ; + - out[87] + NET out[87] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 125230 ) N ; + - out[88] + NET out[88] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 126630 ) N ; + - out[89] + NET out[89] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 128030 ) N ; + - out[90] + NET out[90] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 129430 ) N ; + - out[91] + NET out[91] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 130830 ) N ; + - out[92] + NET out[92] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 132230 ) N ; + - out[93] + NET out[93] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 133630 ) N ; + - out[94] + NET out[94] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 135030 ) N ; + - out[95] + NET out[95] + DIRECTION OUTPUT + USE SIGNAL + + PORT + + LAYER metal4 ( -70 -70 ) ( 70 70 ) + + FIXED ( 17703 136430 ) N ; +END PINS +SPECIALNETS 2 ; + - VDD ( * VDD ) + USE POWER ; + - VSS ( * VSS ) + USE GROUND ; +END SPECIALNETS +NETS 672 ; + - in[0] ( PIN in[0] ) ( u_s0_l0 A ) + USE SIGNAL ; + - in[1] ( PIN in[1] ) ( u_s0_l1 A ) + USE SIGNAL ; + - in[2] ( PIN in[2] ) ( u_s0_l2 A ) + USE SIGNAL ; + - in[3] ( PIN in[3] ) ( u_s0_l3 A ) + USE SIGNAL ; + - in[4] ( PIN in[4] ) ( u_s0_l4 A ) + USE SIGNAL ; + - in[5] ( PIN in[5] ) ( u_s0_l5 A ) + USE SIGNAL ; + - in[6] ( PIN in[6] ) ( u_s0_l6 A ) + USE SIGNAL ; + - in[7] ( PIN in[7] ) ( u_s0_l7 A ) + USE SIGNAL ; + - in[8] ( PIN in[8] ) ( u_s0_l8 A ) + USE SIGNAL ; + - in[9] ( PIN in[9] ) ( u_s0_l9 A ) + USE SIGNAL ; + - in[10] ( PIN in[10] ) ( u_s0_l10 A ) + USE SIGNAL ; + - in[11] ( PIN in[11] ) ( u_s0_l11 A ) + USE SIGNAL ; + - in[12] ( PIN in[12] ) ( u_s0_l12 A ) + USE SIGNAL ; + - in[13] ( PIN in[13] ) ( u_s0_l13 A ) + USE SIGNAL ; + - in[14] ( PIN in[14] ) ( u_s0_l14 A ) + USE SIGNAL ; + - in[15] ( PIN in[15] ) ( u_s0_l15 A ) + USE SIGNAL ; + - in[16] ( PIN in[16] ) ( u_s0_l16 A ) + USE SIGNAL ; + - in[17] ( PIN in[17] ) ( u_s0_l17 A ) + USE SIGNAL ; + - in[18] ( PIN in[18] ) ( u_s0_l18 A ) + USE SIGNAL ; + - in[19] ( PIN in[19] ) ( u_s0_l19 A ) + USE SIGNAL ; + - in[20] ( PIN in[20] ) ( u_s0_l20 A ) + USE SIGNAL ; + - in[21] ( PIN in[21] ) ( u_s0_l21 A ) + USE SIGNAL ; + - in[22] ( PIN in[22] ) ( u_s0_l22 A ) + USE SIGNAL ; + - in[23] ( PIN in[23] ) ( u_s0_l23 A ) + USE SIGNAL ; + - in[24] ( PIN in[24] ) ( u_s0_l24 A ) + USE SIGNAL ; + - in[25] ( PIN in[25] ) ( u_s0_l25 A ) + USE SIGNAL ; + - in[26] ( PIN in[26] ) ( u_s0_l26 A ) + USE SIGNAL ; + - in[27] ( PIN in[27] ) ( u_s0_l27 A ) + USE SIGNAL ; + - in[28] ( PIN in[28] ) ( u_s0_l28 A ) + USE SIGNAL ; + - in[29] ( PIN in[29] ) ( u_s0_l29 A ) + USE SIGNAL ; + - in[30] ( PIN in[30] ) ( u_s0_l30 A ) + USE SIGNAL ; + - in[31] ( PIN in[31] ) ( u_s0_l31 A ) + USE SIGNAL ; + - in[32] ( PIN in[32] ) ( u_s0_l32 A ) + USE SIGNAL ; + - in[33] ( PIN in[33] ) ( u_s0_l33 A ) + USE SIGNAL ; + - in[34] ( PIN in[34] ) ( u_s0_l34 A ) + USE SIGNAL ; + - in[35] ( PIN in[35] ) ( u_s0_l35 A ) + USE SIGNAL ; + - in[36] ( PIN in[36] ) ( u_s0_l36 A ) + USE SIGNAL ; + - in[37] ( PIN in[37] ) ( u_s0_l37 A ) + USE SIGNAL ; + - in[38] ( PIN in[38] ) ( u_s0_l38 A ) + USE SIGNAL ; + - in[39] ( PIN in[39] ) ( u_s0_l39 A ) + USE SIGNAL ; + - in[40] ( PIN in[40] ) ( u_s0_l40 A ) + USE SIGNAL ; + - in[41] ( PIN in[41] ) ( u_s0_l41 A ) + USE SIGNAL ; + - in[42] ( PIN in[42] ) ( u_s0_l42 A ) + USE SIGNAL ; + - in[43] ( PIN in[43] ) ( u_s0_l43 A ) + USE SIGNAL ; + - in[44] ( PIN in[44] ) ( u_s0_l44 A ) + USE SIGNAL ; + - in[45] ( PIN in[45] ) ( u_s0_l45 A ) + USE SIGNAL ; + - in[46] ( PIN in[46] ) ( u_s0_l46 A ) + USE SIGNAL ; + - in[47] ( PIN in[47] ) ( u_s0_l47 A ) + USE SIGNAL ; + - in[48] ( PIN in[48] ) ( u_s0_l48 A ) + USE SIGNAL ; + - in[49] ( PIN in[49] ) ( u_s0_l49 A ) + USE SIGNAL ; + - in[50] ( PIN in[50] ) ( u_s0_l50 A ) + USE SIGNAL ; + - in[51] ( PIN in[51] ) ( u_s0_l51 A ) + USE SIGNAL ; + - in[52] ( PIN in[52] ) ( u_s0_l52 A ) + USE SIGNAL ; + - in[53] ( PIN in[53] ) ( u_s0_l53 A ) + USE SIGNAL ; + - in[54] ( PIN in[54] ) ( u_s0_l54 A ) + USE SIGNAL ; + - in[55] ( PIN in[55] ) ( u_s0_l55 A ) + USE SIGNAL ; + - in[56] ( PIN in[56] ) ( u_s0_l56 A ) + USE SIGNAL ; + - in[57] ( PIN in[57] ) ( u_s0_l57 A ) + USE SIGNAL ; + - in[58] ( PIN in[58] ) ( u_s0_l58 A ) + USE SIGNAL ; + - in[59] ( PIN in[59] ) ( u_s0_l59 A ) + USE SIGNAL ; + - in[60] ( PIN in[60] ) ( u_s0_l60 A ) + USE SIGNAL ; + - in[61] ( PIN in[61] ) ( u_s0_l61 A ) + USE SIGNAL ; + - in[62] ( PIN in[62] ) ( u_s0_l62 A ) + USE SIGNAL ; + - in[63] ( PIN in[63] ) ( u_s0_l63 A ) + USE SIGNAL ; + - in[64] ( PIN in[64] ) ( u_s0_l64 A ) + USE SIGNAL ; + - in[65] ( PIN in[65] ) ( u_s0_l65 A ) + USE SIGNAL ; + - in[66] ( PIN in[66] ) ( u_s0_l66 A ) + USE SIGNAL ; + - in[67] ( PIN in[67] ) ( u_s0_l67 A ) + USE SIGNAL ; + - in[68] ( PIN in[68] ) ( u_s0_l68 A ) + USE SIGNAL ; + - in[69] ( PIN in[69] ) ( u_s0_l69 A ) + USE SIGNAL ; + - in[70] ( PIN in[70] ) ( u_s0_l70 A ) + USE SIGNAL ; + - in[71] ( PIN in[71] ) ( u_s0_l71 A ) + USE SIGNAL ; + - in[72] ( PIN in[72] ) ( u_s0_l72 A ) + USE SIGNAL ; + - in[73] ( PIN in[73] ) ( u_s0_l73 A ) + USE SIGNAL ; + - in[74] ( PIN in[74] ) ( u_s0_l74 A ) + USE SIGNAL ; + - in[75] ( PIN in[75] ) ( u_s0_l75 A ) + USE SIGNAL ; + - in[76] ( PIN in[76] ) ( u_s0_l76 A ) + USE SIGNAL ; + - in[77] ( PIN in[77] ) ( u_s0_l77 A ) + USE SIGNAL ; + - in[78] ( PIN in[78] ) ( u_s0_l78 A ) + USE SIGNAL ; + - in[79] ( PIN in[79] ) ( u_s0_l79 A ) + USE SIGNAL ; + - in[80] ( PIN in[80] ) ( u_s0_l80 A ) + USE SIGNAL ; + - in[81] ( PIN in[81] ) ( u_s0_l81 A ) + USE SIGNAL ; + - in[82] ( PIN in[82] ) ( u_s0_l82 A ) + USE SIGNAL ; + - in[83] ( PIN in[83] ) ( u_s0_l83 A ) + USE SIGNAL ; + - in[84] ( PIN in[84] ) ( u_s0_l84 A ) + USE SIGNAL ; + - in[85] ( PIN in[85] ) ( u_s0_l85 A ) + USE SIGNAL ; + - in[86] ( PIN in[86] ) ( u_s0_l86 A ) + USE SIGNAL ; + - in[87] ( PIN in[87] ) ( u_s0_l87 A ) + USE SIGNAL ; + - in[88] ( PIN in[88] ) ( u_s0_l88 A ) + USE SIGNAL ; + - in[89] ( PIN in[89] ) ( u_s0_l89 A ) + USE SIGNAL ; + - in[90] ( PIN in[90] ) ( u_s0_l90 A ) + USE SIGNAL ; + - in[91] ( PIN in[91] ) ( u_s0_l91 A ) + USE SIGNAL ; + - in[92] ( PIN in[92] ) ( u_s0_l92 A ) + USE SIGNAL ; + - in[93] ( PIN in[93] ) ( u_s0_l93 A ) + USE SIGNAL ; + - in[94] ( PIN in[94] ) ( u_s0_l94 A ) + USE SIGNAL ; + - in[95] ( PIN in[95] ) ( u_s0_l95 A ) + USE SIGNAL ; + - n_s0_l0 ( u_s0_l0 Z ) ( u_s1_l0 A ) + USE SIGNAL ; + - n_s0_l1 ( u_s0_l1 Z ) ( u_s1_l5 A ) + USE SIGNAL ; + - n_s0_l2 ( u_s0_l2 Z ) ( u_s1_l10 A ) + USE SIGNAL ; + - n_s0_l3 ( u_s0_l3 Z ) ( u_s1_l15 A ) + USE SIGNAL ; + - n_s0_l4 ( u_s0_l4 Z ) ( u_s1_l20 A ) + USE SIGNAL ; + - n_s0_l5 ( u_s0_l5 Z ) ( u_s1_l25 A ) + USE SIGNAL ; + - n_s0_l6 ( u_s0_l6 Z ) ( u_s1_l30 A ) + USE SIGNAL ; + - n_s0_l7 ( u_s0_l7 Z ) ( u_s1_l35 A ) + USE SIGNAL ; + - n_s0_l8 ( u_s0_l8 Z ) ( u_s1_l40 A ) + USE SIGNAL ; + - n_s0_l9 ( u_s0_l9 Z ) ( u_s1_l45 A ) + USE SIGNAL ; + - n_s0_l10 ( u_s0_l10 Z ) ( u_s1_l50 A ) + USE SIGNAL ; + - n_s0_l11 ( u_s0_l11 Z ) ( u_s1_l55 A ) + USE SIGNAL ; + - n_s0_l12 ( u_s0_l12 Z ) ( u_s1_l60 A ) + USE SIGNAL ; + - n_s0_l13 ( u_s0_l13 Z ) ( u_s1_l65 A ) + USE SIGNAL ; + - n_s0_l14 ( u_s0_l14 Z ) ( u_s1_l70 A ) + USE SIGNAL ; + - n_s0_l15 ( u_s0_l15 Z ) ( u_s1_l75 A ) + USE SIGNAL ; + - n_s0_l16 ( u_s0_l16 Z ) ( u_s1_l80 A ) + USE SIGNAL ; + - n_s0_l17 ( u_s0_l17 Z ) ( u_s1_l85 A ) + USE SIGNAL ; + - n_s0_l18 ( u_s0_l18 Z ) ( u_s1_l90 A ) + USE SIGNAL ; + - n_s0_l19 ( u_s0_l19 Z ) ( u_s1_l95 A ) + USE SIGNAL ; + - n_s0_l20 ( u_s0_l20 Z ) ( u_s1_l4 A ) + USE SIGNAL ; + - n_s0_l21 ( u_s0_l21 Z ) ( u_s1_l9 A ) + USE SIGNAL ; + - n_s0_l22 ( u_s0_l22 Z ) ( u_s1_l14 A ) + USE SIGNAL ; + - n_s0_l23 ( u_s0_l23 Z ) ( u_s1_l19 A ) + USE SIGNAL ; + - n_s0_l24 ( u_s0_l24 Z ) ( u_s1_l24 A ) + USE SIGNAL ; + - n_s0_l25 ( u_s0_l25 Z ) ( u_s1_l29 A ) + USE SIGNAL ; + - n_s0_l26 ( u_s0_l26 Z ) ( u_s1_l34 A ) + USE SIGNAL ; + - n_s0_l27 ( u_s0_l27 Z ) ( u_s1_l39 A ) + USE SIGNAL ; + - n_s0_l28 ( u_s0_l28 Z ) ( u_s1_l44 A ) + USE SIGNAL ; + - n_s0_l29 ( u_s0_l29 Z ) ( u_s1_l49 A ) + USE SIGNAL ; + - n_s0_l30 ( u_s0_l30 Z ) ( u_s1_l54 A ) + USE SIGNAL ; + - n_s0_l31 ( u_s0_l31 Z ) ( u_s1_l59 A ) + USE SIGNAL ; + - n_s0_l32 ( u_s0_l32 Z ) ( u_s1_l64 A ) + USE SIGNAL ; + - n_s0_l33 ( u_s0_l33 Z ) ( u_s1_l69 A ) + USE SIGNAL ; + - n_s0_l34 ( u_s0_l34 Z ) ( u_s1_l74 A ) + USE SIGNAL ; + - n_s0_l35 ( u_s0_l35 Z ) ( u_s1_l79 A ) + USE SIGNAL ; + - n_s0_l36 ( u_s0_l36 Z ) ( u_s1_l84 A ) + USE SIGNAL ; + - n_s0_l37 ( u_s0_l37 Z ) ( u_s1_l89 A ) + USE SIGNAL ; + - n_s0_l38 ( u_s0_l38 Z ) ( u_s1_l94 A ) + USE SIGNAL ; + - n_s0_l39 ( u_s0_l39 Z ) ( u_s1_l3 A ) + USE SIGNAL ; + - n_s0_l40 ( u_s0_l40 Z ) ( u_s1_l8 A ) + USE SIGNAL ; + - n_s0_l41 ( u_s0_l41 Z ) ( u_s1_l13 A ) + USE SIGNAL ; + - n_s0_l42 ( u_s0_l42 Z ) ( u_s1_l18 A ) + USE SIGNAL ; + - n_s0_l43 ( u_s0_l43 Z ) ( u_s1_l23 A ) + USE SIGNAL ; + - n_s0_l44 ( u_s0_l44 Z ) ( u_s1_l28 A ) + USE SIGNAL ; + - n_s0_l45 ( u_s0_l45 Z ) ( u_s1_l33 A ) + USE SIGNAL ; + - n_s0_l46 ( u_s0_l46 Z ) ( u_s1_l38 A ) + USE SIGNAL ; + - n_s0_l47 ( u_s0_l47 Z ) ( u_s1_l43 A ) + USE SIGNAL ; + - n_s0_l48 ( u_s0_l48 Z ) ( u_s1_l48 A ) + USE SIGNAL ; + - n_s0_l49 ( u_s0_l49 Z ) ( u_s1_l53 A ) + USE SIGNAL ; + - n_s0_l50 ( u_s0_l50 Z ) ( u_s1_l58 A ) + USE SIGNAL ; + - n_s0_l51 ( u_s0_l51 Z ) ( u_s1_l63 A ) + USE SIGNAL ; + - n_s0_l52 ( u_s0_l52 Z ) ( u_s1_l68 A ) + USE SIGNAL ; + - n_s0_l53 ( u_s0_l53 Z ) ( u_s1_l73 A ) + USE SIGNAL ; + - n_s0_l54 ( u_s0_l54 Z ) ( u_s1_l78 A ) + USE SIGNAL ; + - n_s0_l55 ( u_s0_l55 Z ) ( u_s1_l83 A ) + USE SIGNAL ; + - n_s0_l56 ( u_s0_l56 Z ) ( u_s1_l88 A ) + USE SIGNAL ; + - n_s0_l57 ( u_s0_l57 Z ) ( u_s1_l93 A ) + USE SIGNAL ; + - n_s0_l58 ( u_s0_l58 Z ) ( u_s1_l2 A ) + USE SIGNAL ; + - n_s0_l59 ( u_s0_l59 Z ) ( u_s1_l7 A ) + USE SIGNAL ; + - n_s0_l60 ( u_s0_l60 Z ) ( u_s1_l12 A ) + USE SIGNAL ; + - n_s0_l61 ( u_s0_l61 Z ) ( u_s1_l17 A ) + USE SIGNAL ; + - n_s0_l62 ( u_s0_l62 Z ) ( u_s1_l22 A ) + USE SIGNAL ; + - n_s0_l63 ( u_s0_l63 Z ) ( u_s1_l27 A ) + USE SIGNAL ; + - n_s0_l64 ( u_s0_l64 Z ) ( u_s1_l32 A ) + USE SIGNAL ; + - n_s0_l65 ( u_s0_l65 Z ) ( u_s1_l37 A ) + USE SIGNAL ; + - n_s0_l66 ( u_s0_l66 Z ) ( u_s1_l42 A ) + USE SIGNAL ; + - n_s0_l67 ( u_s0_l67 Z ) ( u_s1_l47 A ) + USE SIGNAL ; + - n_s0_l68 ( u_s0_l68 Z ) ( u_s1_l52 A ) + USE SIGNAL ; + - n_s0_l69 ( u_s0_l69 Z ) ( u_s1_l57 A ) + USE SIGNAL ; + - n_s0_l70 ( u_s0_l70 Z ) ( u_s1_l62 A ) + USE SIGNAL ; + - n_s0_l71 ( u_s0_l71 Z ) ( u_s1_l67 A ) + USE SIGNAL ; + - n_s0_l72 ( u_s0_l72 Z ) ( u_s1_l72 A ) + USE SIGNAL ; + - n_s0_l73 ( u_s0_l73 Z ) ( u_s1_l77 A ) + USE SIGNAL ; + - n_s0_l74 ( u_s0_l74 Z ) ( u_s1_l82 A ) + USE SIGNAL ; + - n_s0_l75 ( u_s0_l75 Z ) ( u_s1_l87 A ) + USE SIGNAL ; + - n_s0_l76 ( u_s0_l76 Z ) ( u_s1_l92 A ) + USE SIGNAL ; + - n_s0_l77 ( u_s0_l77 Z ) ( u_s1_l1 A ) + USE SIGNAL ; + - n_s0_l78 ( u_s0_l78 Z ) ( u_s1_l6 A ) + USE SIGNAL ; + - n_s0_l79 ( u_s0_l79 Z ) ( u_s1_l11 A ) + USE SIGNAL ; + - n_s0_l80 ( u_s0_l80 Z ) ( u_s1_l16 A ) + USE SIGNAL ; + - n_s0_l81 ( u_s0_l81 Z ) ( u_s1_l21 A ) + USE SIGNAL ; + - n_s0_l82 ( u_s0_l82 Z ) ( u_s1_l26 A ) + USE SIGNAL ; + - n_s0_l83 ( u_s0_l83 Z ) ( u_s1_l31 A ) + USE SIGNAL ; + - n_s0_l84 ( u_s0_l84 Z ) ( u_s1_l36 A ) + USE SIGNAL ; + - n_s0_l85 ( u_s0_l85 Z ) ( u_s1_l41 A ) + USE SIGNAL ; + - n_s0_l86 ( u_s0_l86 Z ) ( u_s1_l46 A ) + USE SIGNAL ; + - n_s0_l87 ( u_s0_l87 Z ) ( u_s1_l51 A ) + USE SIGNAL ; + - n_s0_l88 ( u_s0_l88 Z ) ( u_s1_l56 A ) + USE SIGNAL ; + - n_s0_l89 ( u_s0_l89 Z ) ( u_s1_l61 A ) + USE SIGNAL ; + - n_s0_l90 ( u_s0_l90 Z ) ( u_s1_l66 A ) + USE SIGNAL ; + - n_s0_l91 ( u_s0_l91 Z ) ( u_s1_l71 A ) + USE SIGNAL ; + - n_s0_l92 ( u_s0_l92 Z ) ( u_s1_l76 A ) + USE SIGNAL ; + - n_s0_l93 ( u_s0_l93 Z ) ( u_s1_l81 A ) + USE SIGNAL ; + - n_s0_l94 ( u_s0_l94 Z ) ( u_s1_l86 A ) + USE SIGNAL ; + - n_s0_l95 ( u_s0_l95 Z ) ( u_s1_l91 A ) + USE SIGNAL ; + - n_s1_l0 ( u_s1_l0 Z ) ( u_s2_l7 A ) + USE SIGNAL ; + - n_s1_l1 ( u_s1_l1 Z ) ( u_s2_l14 A ) + USE SIGNAL ; + - n_s1_l2 ( u_s1_l2 Z ) ( u_s2_l21 A ) + USE SIGNAL ; + - n_s1_l3 ( u_s1_l3 Z ) ( u_s2_l28 A ) + USE SIGNAL ; + - n_s1_l4 ( u_s1_l4 Z ) ( u_s2_l35 A ) + USE SIGNAL ; + - n_s1_l5 ( u_s1_l5 Z ) ( u_s2_l42 A ) + USE SIGNAL ; + - n_s1_l6 ( u_s1_l6 Z ) ( u_s2_l49 A ) + USE SIGNAL ; + - n_s1_l7 ( u_s1_l7 Z ) ( u_s2_l56 A ) + USE SIGNAL ; + - n_s1_l8 ( u_s1_l8 Z ) ( u_s2_l63 A ) + USE SIGNAL ; + - n_s1_l9 ( u_s1_l9 Z ) ( u_s2_l70 A ) + USE SIGNAL ; + - n_s1_l10 ( u_s1_l10 Z ) ( u_s2_l77 A ) + USE SIGNAL ; + - n_s1_l11 ( u_s1_l11 Z ) ( u_s2_l84 A ) + USE SIGNAL ; + - n_s1_l12 ( u_s1_l12 Z ) ( u_s2_l91 A ) + USE SIGNAL ; + - n_s1_l13 ( u_s1_l13 Z ) ( u_s2_l2 A ) + USE SIGNAL ; + - n_s1_l14 ( u_s1_l14 Z ) ( u_s2_l9 A ) + USE SIGNAL ; + - n_s1_l15 ( u_s1_l15 Z ) ( u_s2_l16 A ) + USE SIGNAL ; + - n_s1_l16 ( u_s1_l16 Z ) ( u_s2_l23 A ) + USE SIGNAL ; + - n_s1_l17 ( u_s1_l17 Z ) ( u_s2_l30 A ) + USE SIGNAL ; + - n_s1_l18 ( u_s1_l18 Z ) ( u_s2_l37 A ) + USE SIGNAL ; + - n_s1_l19 ( u_s1_l19 Z ) ( u_s2_l44 A ) + USE SIGNAL ; + - n_s1_l20 ( u_s1_l20 Z ) ( u_s2_l51 A ) + USE SIGNAL ; + - n_s1_l21 ( u_s1_l21 Z ) ( u_s2_l58 A ) + USE SIGNAL ; + - n_s1_l22 ( u_s1_l22 Z ) ( u_s2_l65 A ) + USE SIGNAL ; + - n_s1_l23 ( u_s1_l23 Z ) ( u_s2_l72 A ) + USE SIGNAL ; + - n_s1_l24 ( u_s1_l24 Z ) ( u_s2_l79 A ) + USE SIGNAL ; + - n_s1_l25 ( u_s1_l25 Z ) ( u_s2_l86 A ) + USE SIGNAL ; + - n_s1_l26 ( u_s1_l26 Z ) ( u_s2_l93 A ) + USE SIGNAL ; + - n_s1_l27 ( u_s1_l27 Z ) ( u_s2_l4 A ) + USE SIGNAL ; + - n_s1_l28 ( u_s1_l28 Z ) ( u_s2_l11 A ) + USE SIGNAL ; + - n_s1_l29 ( u_s1_l29 Z ) ( u_s2_l18 A ) + USE SIGNAL ; + - n_s1_l30 ( u_s1_l30 Z ) ( u_s2_l25 A ) + USE SIGNAL ; + - n_s1_l31 ( u_s1_l31 Z ) ( u_s2_l32 A ) + USE SIGNAL ; + - n_s1_l32 ( u_s1_l32 Z ) ( u_s2_l39 A ) + USE SIGNAL ; + - n_s1_l33 ( u_s1_l33 Z ) ( u_s2_l46 A ) + USE SIGNAL ; + - n_s1_l34 ( u_s1_l34 Z ) ( u_s2_l53 A ) + USE SIGNAL ; + - n_s1_l35 ( u_s1_l35 Z ) ( u_s2_l60 A ) + USE SIGNAL ; + - n_s1_l36 ( u_s1_l36 Z ) ( u_s2_l67 A ) + USE SIGNAL ; + - n_s1_l37 ( u_s1_l37 Z ) ( u_s2_l74 A ) + USE SIGNAL ; + - n_s1_l38 ( u_s1_l38 Z ) ( u_s2_l81 A ) + USE SIGNAL ; + - n_s1_l39 ( u_s1_l39 Z ) ( u_s2_l88 A ) + USE SIGNAL ; + - n_s1_l40 ( u_s1_l40 Z ) ( u_s2_l95 A ) + USE SIGNAL ; + - n_s1_l41 ( u_s1_l41 Z ) ( u_s2_l6 A ) + USE SIGNAL ; + - n_s1_l42 ( u_s1_l42 Z ) ( u_s2_l13 A ) + USE SIGNAL ; + - n_s1_l43 ( u_s1_l43 Z ) ( u_s2_l20 A ) + USE SIGNAL ; + - n_s1_l44 ( u_s1_l44 Z ) ( u_s2_l27 A ) + USE SIGNAL ; + - n_s1_l45 ( u_s1_l45 Z ) ( u_s2_l34 A ) + USE SIGNAL ; + - n_s1_l46 ( u_s1_l46 Z ) ( u_s2_l41 A ) + USE SIGNAL ; + - n_s1_l47 ( u_s1_l47 Z ) ( u_s2_l48 A ) + USE SIGNAL ; + - n_s1_l48 ( u_s1_l48 Z ) ( u_s2_l55 A ) + USE SIGNAL ; + - n_s1_l49 ( u_s1_l49 Z ) ( u_s2_l62 A ) + USE SIGNAL ; + - n_s1_l50 ( u_s1_l50 Z ) ( u_s2_l69 A ) + USE SIGNAL ; + - n_s1_l51 ( u_s1_l51 Z ) ( u_s2_l76 A ) + USE SIGNAL ; + - n_s1_l52 ( u_s1_l52 Z ) ( u_s2_l83 A ) + USE SIGNAL ; + - n_s1_l53 ( u_s1_l53 Z ) ( u_s2_l90 A ) + USE SIGNAL ; + - n_s1_l54 ( u_s1_l54 Z ) ( u_s2_l1 A ) + USE SIGNAL ; + - n_s1_l55 ( u_s1_l55 Z ) ( u_s2_l8 A ) + USE SIGNAL ; + - n_s1_l56 ( u_s1_l56 Z ) ( u_s2_l15 A ) + USE SIGNAL ; + - n_s1_l57 ( u_s1_l57 Z ) ( u_s2_l22 A ) + USE SIGNAL ; + - n_s1_l58 ( u_s1_l58 Z ) ( u_s2_l29 A ) + USE SIGNAL ; + - n_s1_l59 ( u_s1_l59 Z ) ( u_s2_l36 A ) + USE SIGNAL ; + - n_s1_l60 ( u_s1_l60 Z ) ( u_s2_l43 A ) + USE SIGNAL ; + - n_s1_l61 ( u_s1_l61 Z ) ( u_s2_l50 A ) + USE SIGNAL ; + - n_s1_l62 ( u_s1_l62 Z ) ( u_s2_l57 A ) + USE SIGNAL ; + - n_s1_l63 ( u_s1_l63 Z ) ( u_s2_l64 A ) + USE SIGNAL ; + - n_s1_l64 ( u_s1_l64 Z ) ( u_s2_l71 A ) + USE SIGNAL ; + - n_s1_l65 ( u_s1_l65 Z ) ( u_s2_l78 A ) + USE SIGNAL ; + - n_s1_l66 ( u_s1_l66 Z ) ( u_s2_l85 A ) + USE SIGNAL ; + - n_s1_l67 ( u_s1_l67 Z ) ( u_s2_l92 A ) + USE SIGNAL ; + - n_s1_l68 ( u_s1_l68 Z ) ( u_s2_l3 A ) + USE SIGNAL ; + - n_s1_l69 ( u_s1_l69 Z ) ( u_s2_l10 A ) + USE SIGNAL ; + - n_s1_l70 ( u_s1_l70 Z ) ( u_s2_l17 A ) + USE SIGNAL ; + - n_s1_l71 ( u_s1_l71 Z ) ( u_s2_l24 A ) + USE SIGNAL ; + - n_s1_l72 ( u_s1_l72 Z ) ( u_s2_l31 A ) + USE SIGNAL ; + - n_s1_l73 ( u_s1_l73 Z ) ( u_s2_l38 A ) + USE SIGNAL ; + - n_s1_l74 ( u_s1_l74 Z ) ( u_s2_l45 A ) + USE SIGNAL ; + - n_s1_l75 ( u_s1_l75 Z ) ( u_s2_l52 A ) + USE SIGNAL ; + - n_s1_l76 ( u_s1_l76 Z ) ( u_s2_l59 A ) + USE SIGNAL ; + - n_s1_l77 ( u_s1_l77 Z ) ( u_s2_l66 A ) + USE SIGNAL ; + - n_s1_l78 ( u_s1_l78 Z ) ( u_s2_l73 A ) + USE SIGNAL ; + - n_s1_l79 ( u_s1_l79 Z ) ( u_s2_l80 A ) + USE SIGNAL ; + - n_s1_l80 ( u_s1_l80 Z ) ( u_s2_l87 A ) + USE SIGNAL ; + - n_s1_l81 ( u_s1_l81 Z ) ( u_s2_l94 A ) + USE SIGNAL ; + - n_s1_l82 ( u_s1_l82 Z ) ( u_s2_l5 A ) + USE SIGNAL ; + - n_s1_l83 ( u_s1_l83 Z ) ( u_s2_l12 A ) + USE SIGNAL ; + - n_s1_l84 ( u_s1_l84 Z ) ( u_s2_l19 A ) + USE SIGNAL ; + - n_s1_l85 ( u_s1_l85 Z ) ( u_s2_l26 A ) + USE SIGNAL ; + - n_s1_l86 ( u_s1_l86 Z ) ( u_s2_l33 A ) + USE SIGNAL ; + - n_s1_l87 ( u_s1_l87 Z ) ( u_s2_l40 A ) + USE SIGNAL ; + - n_s1_l88 ( u_s1_l88 Z ) ( u_s2_l47 A ) + USE SIGNAL ; + - n_s1_l89 ( u_s1_l89 Z ) ( u_s2_l54 A ) + USE SIGNAL ; + - n_s1_l90 ( u_s1_l90 Z ) ( u_s2_l61 A ) + USE SIGNAL ; + - n_s1_l91 ( u_s1_l91 Z ) ( u_s2_l68 A ) + USE SIGNAL ; + - n_s1_l92 ( u_s1_l92 Z ) ( u_s2_l75 A ) + USE SIGNAL ; + - n_s1_l93 ( u_s1_l93 Z ) ( u_s2_l82 A ) + USE SIGNAL ; + - n_s1_l94 ( u_s1_l94 Z ) ( u_s2_l89 A ) + USE SIGNAL ; + - n_s1_l95 ( u_s1_l95 Z ) ( u_s2_l0 A ) + USE SIGNAL ; + - n_s2_l0 ( u_s2_l0 Z ) ( u_s3_l14 A ) + USE SIGNAL ; + - n_s2_l1 ( u_s2_l1 Z ) ( u_s3_l25 A ) + USE SIGNAL ; + - n_s2_l2 ( u_s2_l2 Z ) ( u_s3_l36 A ) + USE SIGNAL ; + - n_s2_l3 ( u_s2_l3 Z ) ( u_s3_l47 A ) + USE SIGNAL ; + - n_s2_l4 ( u_s2_l4 Z ) ( u_s3_l58 A ) + USE SIGNAL ; + - n_s2_l5 ( u_s2_l5 Z ) ( u_s3_l69 A ) + USE SIGNAL ; + - n_s2_l6 ( u_s2_l6 Z ) ( u_s3_l80 A ) + USE SIGNAL ; + - n_s2_l7 ( u_s2_l7 Z ) ( u_s3_l91 A ) + USE SIGNAL ; + - n_s2_l8 ( u_s2_l8 Z ) ( u_s3_l6 A ) + USE SIGNAL ; + - n_s2_l9 ( u_s2_l9 Z ) ( u_s3_l17 A ) + USE SIGNAL ; + - n_s2_l10 ( u_s2_l10 Z ) ( u_s3_l28 A ) + USE SIGNAL ; + - n_s2_l11 ( u_s2_l11 Z ) ( u_s3_l39 A ) + USE SIGNAL ; + - n_s2_l12 ( u_s2_l12 Z ) ( u_s3_l50 A ) + USE SIGNAL ; + - n_s2_l13 ( u_s2_l13 Z ) ( u_s3_l61 A ) + USE SIGNAL ; + - n_s2_l14 ( u_s2_l14 Z ) ( u_s3_l72 A ) + USE SIGNAL ; + - n_s2_l15 ( u_s2_l15 Z ) ( u_s3_l83 A ) + USE SIGNAL ; + - n_s2_l16 ( u_s2_l16 Z ) ( u_s3_l94 A ) + USE SIGNAL ; + - n_s2_l17 ( u_s2_l17 Z ) ( u_s3_l9 A ) + USE SIGNAL ; + - n_s2_l18 ( u_s2_l18 Z ) ( u_s3_l20 A ) + USE SIGNAL ; + - n_s2_l19 ( u_s2_l19 Z ) ( u_s3_l31 A ) + USE SIGNAL ; + - n_s2_l20 ( u_s2_l20 Z ) ( u_s3_l42 A ) + USE SIGNAL ; + - n_s2_l21 ( u_s2_l21 Z ) ( u_s3_l53 A ) + USE SIGNAL ; + - n_s2_l22 ( u_s2_l22 Z ) ( u_s3_l64 A ) + USE SIGNAL ; + - n_s2_l23 ( u_s2_l23 Z ) ( u_s3_l75 A ) + USE SIGNAL ; + - n_s2_l24 ( u_s2_l24 Z ) ( u_s3_l86 A ) + USE SIGNAL ; + - n_s2_l25 ( u_s2_l25 Z ) ( u_s3_l1 A ) + USE SIGNAL ; + - n_s2_l26 ( u_s2_l26 Z ) ( u_s3_l12 A ) + USE SIGNAL ; + - n_s2_l27 ( u_s2_l27 Z ) ( u_s3_l23 A ) + USE SIGNAL ; + - n_s2_l28 ( u_s2_l28 Z ) ( u_s3_l34 A ) + USE SIGNAL ; + - n_s2_l29 ( u_s2_l29 Z ) ( u_s3_l45 A ) + USE SIGNAL ; + - n_s2_l30 ( u_s2_l30 Z ) ( u_s3_l56 A ) + USE SIGNAL ; + - n_s2_l31 ( u_s2_l31 Z ) ( u_s3_l67 A ) + USE SIGNAL ; + - n_s2_l32 ( u_s2_l32 Z ) ( u_s3_l78 A ) + USE SIGNAL ; + - n_s2_l33 ( u_s2_l33 Z ) ( u_s3_l89 A ) + USE SIGNAL ; + - n_s2_l34 ( u_s2_l34 Z ) ( u_s3_l4 A ) + USE SIGNAL ; + - n_s2_l35 ( u_s2_l35 Z ) ( u_s3_l15 A ) + USE SIGNAL ; + - n_s2_l36 ( u_s2_l36 Z ) ( u_s3_l26 A ) + USE SIGNAL ; + - n_s2_l37 ( u_s2_l37 Z ) ( u_s3_l37 A ) + USE SIGNAL ; + - n_s2_l38 ( u_s2_l38 Z ) ( u_s3_l48 A ) + USE SIGNAL ; + - n_s2_l39 ( u_s2_l39 Z ) ( u_s3_l59 A ) + USE SIGNAL ; + - n_s2_l40 ( u_s2_l40 Z ) ( u_s3_l70 A ) + USE SIGNAL ; + - n_s2_l41 ( u_s2_l41 Z ) ( u_s3_l81 A ) + USE SIGNAL ; + - n_s2_l42 ( u_s2_l42 Z ) ( u_s3_l92 A ) + USE SIGNAL ; + - n_s2_l43 ( u_s2_l43 Z ) ( u_s3_l7 A ) + USE SIGNAL ; + - n_s2_l44 ( u_s2_l44 Z ) ( u_s3_l18 A ) + USE SIGNAL ; + - n_s2_l45 ( u_s2_l45 Z ) ( u_s3_l29 A ) + USE SIGNAL ; + - n_s2_l46 ( u_s2_l46 Z ) ( u_s3_l40 A ) + USE SIGNAL ; + - n_s2_l47 ( u_s2_l47 Z ) ( u_s3_l51 A ) + USE SIGNAL ; + - n_s2_l48 ( u_s2_l48 Z ) ( u_s3_l62 A ) + USE SIGNAL ; + - n_s2_l49 ( u_s2_l49 Z ) ( u_s3_l73 A ) + USE SIGNAL ; + - n_s2_l50 ( u_s2_l50 Z ) ( u_s3_l84 A ) + USE SIGNAL ; + - n_s2_l51 ( u_s2_l51 Z ) ( u_s3_l95 A ) + USE SIGNAL ; + - n_s2_l52 ( u_s2_l52 Z ) ( u_s3_l10 A ) + USE SIGNAL ; + - n_s2_l53 ( u_s2_l53 Z ) ( u_s3_l21 A ) + USE SIGNAL ; + - n_s2_l54 ( u_s2_l54 Z ) ( u_s3_l32 A ) + USE SIGNAL ; + - n_s2_l55 ( u_s2_l55 Z ) ( u_s3_l43 A ) + USE SIGNAL ; + - n_s2_l56 ( u_s2_l56 Z ) ( u_s3_l54 A ) + USE SIGNAL ; + - n_s2_l57 ( u_s2_l57 Z ) ( u_s3_l65 A ) + USE SIGNAL ; + - n_s2_l58 ( u_s2_l58 Z ) ( u_s3_l76 A ) + USE SIGNAL ; + - n_s2_l59 ( u_s2_l59 Z ) ( u_s3_l87 A ) + USE SIGNAL ; + - n_s2_l60 ( u_s2_l60 Z ) ( u_s3_l2 A ) + USE SIGNAL ; + - n_s2_l61 ( u_s2_l61 Z ) ( u_s3_l13 A ) + USE SIGNAL ; + - n_s2_l62 ( u_s2_l62 Z ) ( u_s3_l24 A ) + USE SIGNAL ; + - n_s2_l63 ( u_s2_l63 Z ) ( u_s3_l35 A ) + USE SIGNAL ; + - n_s2_l64 ( u_s2_l64 Z ) ( u_s3_l46 A ) + USE SIGNAL ; + - n_s2_l65 ( u_s2_l65 Z ) ( u_s3_l57 A ) + USE SIGNAL ; + - n_s2_l66 ( u_s2_l66 Z ) ( u_s3_l68 A ) + USE SIGNAL ; + - n_s2_l67 ( u_s2_l67 Z ) ( u_s3_l79 A ) + USE SIGNAL ; + - n_s2_l68 ( u_s2_l68 Z ) ( u_s3_l90 A ) + USE SIGNAL ; + - n_s2_l69 ( u_s2_l69 Z ) ( u_s3_l5 A ) + USE SIGNAL ; + - n_s2_l70 ( u_s2_l70 Z ) ( u_s3_l16 A ) + USE SIGNAL ; + - n_s2_l71 ( u_s2_l71 Z ) ( u_s3_l27 A ) + USE SIGNAL ; + - n_s2_l72 ( u_s2_l72 Z ) ( u_s3_l38 A ) + USE SIGNAL ; + - n_s2_l73 ( u_s2_l73 Z ) ( u_s3_l49 A ) + USE SIGNAL ; + - n_s2_l74 ( u_s2_l74 Z ) ( u_s3_l60 A ) + USE SIGNAL ; + - n_s2_l75 ( u_s2_l75 Z ) ( u_s3_l71 A ) + USE SIGNAL ; + - n_s2_l76 ( u_s2_l76 Z ) ( u_s3_l82 A ) + USE SIGNAL ; + - n_s2_l77 ( u_s2_l77 Z ) ( u_s3_l93 A ) + USE SIGNAL ; + - n_s2_l78 ( u_s2_l78 Z ) ( u_s3_l8 A ) + USE SIGNAL ; + - n_s2_l79 ( u_s2_l79 Z ) ( u_s3_l19 A ) + USE SIGNAL ; + - n_s2_l80 ( u_s2_l80 Z ) ( u_s3_l30 A ) + USE SIGNAL ; + - n_s2_l81 ( u_s2_l81 Z ) ( u_s3_l41 A ) + USE SIGNAL ; + - n_s2_l82 ( u_s2_l82 Z ) ( u_s3_l52 A ) + USE SIGNAL ; + - n_s2_l83 ( u_s2_l83 Z ) ( u_s3_l63 A ) + USE SIGNAL ; + - n_s2_l84 ( u_s2_l84 Z ) ( u_s3_l74 A ) + USE SIGNAL ; + - n_s2_l85 ( u_s2_l85 Z ) ( u_s3_l85 A ) + USE SIGNAL ; + - n_s2_l86 ( u_s2_l86 Z ) ( u_s3_l0 A ) + USE SIGNAL ; + - n_s2_l87 ( u_s2_l87 Z ) ( u_s3_l11 A ) + USE SIGNAL ; + - n_s2_l88 ( u_s2_l88 Z ) ( u_s3_l22 A ) + USE SIGNAL ; + - n_s2_l89 ( u_s2_l89 Z ) ( u_s3_l33 A ) + USE SIGNAL ; + - n_s2_l90 ( u_s2_l90 Z ) ( u_s3_l44 A ) + USE SIGNAL ; + - n_s2_l91 ( u_s2_l91 Z ) ( u_s3_l55 A ) + USE SIGNAL ; + - n_s2_l92 ( u_s2_l92 Z ) ( u_s3_l66 A ) + USE SIGNAL ; + - n_s2_l93 ( u_s2_l93 Z ) ( u_s3_l77 A ) + USE SIGNAL ; + - n_s2_l94 ( u_s2_l94 Z ) ( u_s3_l88 A ) + USE SIGNAL ; + - n_s2_l95 ( u_s2_l95 Z ) ( u_s3_l3 A ) + USE SIGNAL ; + - n_s3_l0 ( u_s3_l0 Z ) ( u_s4_l21 A ) + USE SIGNAL ; + - n_s3_l1 ( u_s3_l1 Z ) ( u_s4_l34 A ) + USE SIGNAL ; + - n_s3_l2 ( u_s3_l2 Z ) ( u_s4_l47 A ) + USE SIGNAL ; + - n_s3_l3 ( u_s3_l3 Z ) ( u_s4_l60 A ) + USE SIGNAL ; + - n_s3_l4 ( u_s3_l4 Z ) ( u_s4_l73 A ) + USE SIGNAL ; + - n_s3_l5 ( u_s3_l5 Z ) ( u_s4_l86 A ) + USE SIGNAL ; + - n_s3_l6 ( u_s3_l6 Z ) ( u_s4_l3 A ) + USE SIGNAL ; + - n_s3_l7 ( u_s3_l7 Z ) ( u_s4_l16 A ) + USE SIGNAL ; + - n_s3_l8 ( u_s3_l8 Z ) ( u_s4_l29 A ) + USE SIGNAL ; + - n_s3_l9 ( u_s3_l9 Z ) ( u_s4_l42 A ) + USE SIGNAL ; + - n_s3_l10 ( u_s3_l10 Z ) ( u_s4_l55 A ) + USE SIGNAL ; + - n_s3_l11 ( u_s3_l11 Z ) ( u_s4_l68 A ) + USE SIGNAL ; + - n_s3_l12 ( u_s3_l12 Z ) ( u_s4_l81 A ) + USE SIGNAL ; + - n_s3_l13 ( u_s3_l13 Z ) ( u_s4_l94 A ) + USE SIGNAL ; + - n_s3_l14 ( u_s3_l14 Z ) ( u_s4_l11 A ) + USE SIGNAL ; + - n_s3_l15 ( u_s3_l15 Z ) ( u_s4_l24 A ) + USE SIGNAL ; + - n_s3_l16 ( u_s3_l16 Z ) ( u_s4_l37 A ) + USE SIGNAL ; + - n_s3_l17 ( u_s3_l17 Z ) ( u_s4_l50 A ) + USE SIGNAL ; + - n_s3_l18 ( u_s3_l18 Z ) ( u_s4_l63 A ) + USE SIGNAL ; + - n_s3_l19 ( u_s3_l19 Z ) ( u_s4_l76 A ) + USE SIGNAL ; + - n_s3_l20 ( u_s3_l20 Z ) ( u_s4_l89 A ) + USE SIGNAL ; + - n_s3_l21 ( u_s3_l21 Z ) ( u_s4_l6 A ) + USE SIGNAL ; + - n_s3_l22 ( u_s3_l22 Z ) ( u_s4_l19 A ) + USE SIGNAL ; + - n_s3_l23 ( u_s3_l23 Z ) ( u_s4_l32 A ) + USE SIGNAL ; + - n_s3_l24 ( u_s3_l24 Z ) ( u_s4_l45 A ) + USE SIGNAL ; + - n_s3_l25 ( u_s3_l25 Z ) ( u_s4_l58 A ) + USE SIGNAL ; + - n_s3_l26 ( u_s3_l26 Z ) ( u_s4_l71 A ) + USE SIGNAL ; + - n_s3_l27 ( u_s3_l27 Z ) ( u_s4_l84 A ) + USE SIGNAL ; + - n_s3_l28 ( u_s3_l28 Z ) ( u_s4_l1 A ) + USE SIGNAL ; + - n_s3_l29 ( u_s3_l29 Z ) ( u_s4_l14 A ) + USE SIGNAL ; + - n_s3_l30 ( u_s3_l30 Z ) ( u_s4_l27 A ) + USE SIGNAL ; + - n_s3_l31 ( u_s3_l31 Z ) ( u_s4_l40 A ) + USE SIGNAL ; + - n_s3_l32 ( u_s3_l32 Z ) ( u_s4_l53 A ) + USE SIGNAL ; + - n_s3_l33 ( u_s3_l33 Z ) ( u_s4_l66 A ) + USE SIGNAL ; + - n_s3_l34 ( u_s3_l34 Z ) ( u_s4_l79 A ) + USE SIGNAL ; + - n_s3_l35 ( u_s3_l35 Z ) ( u_s4_l92 A ) + USE SIGNAL ; + - n_s3_l36 ( u_s3_l36 Z ) ( u_s4_l9 A ) + USE SIGNAL ; + - n_s3_l37 ( u_s3_l37 Z ) ( u_s4_l22 A ) + USE SIGNAL ; + - n_s3_l38 ( u_s3_l38 Z ) ( u_s4_l35 A ) + USE SIGNAL ; + - n_s3_l39 ( u_s3_l39 Z ) ( u_s4_l48 A ) + USE SIGNAL ; + - n_s3_l40 ( u_s3_l40 Z ) ( u_s4_l61 A ) + USE SIGNAL ; + - n_s3_l41 ( u_s3_l41 Z ) ( u_s4_l74 A ) + USE SIGNAL ; + - n_s3_l42 ( u_s3_l42 Z ) ( u_s4_l87 A ) + USE SIGNAL ; + - n_s3_l43 ( u_s3_l43 Z ) ( u_s4_l4 A ) + USE SIGNAL ; + - n_s3_l44 ( u_s3_l44 Z ) ( u_s4_l17 A ) + USE SIGNAL ; + - n_s3_l45 ( u_s3_l45 Z ) ( u_s4_l30 A ) + USE SIGNAL ; + - n_s3_l46 ( u_s3_l46 Z ) ( u_s4_l43 A ) + USE SIGNAL ; + - n_s3_l47 ( u_s3_l47 Z ) ( u_s4_l56 A ) + USE SIGNAL ; + - n_s3_l48 ( u_s3_l48 Z ) ( u_s4_l69 A ) + USE SIGNAL ; + - n_s3_l49 ( u_s3_l49 Z ) ( u_s4_l82 A ) + USE SIGNAL ; + - n_s3_l50 ( u_s3_l50 Z ) ( u_s4_l95 A ) + USE SIGNAL ; + - n_s3_l51 ( u_s3_l51 Z ) ( u_s4_l12 A ) + USE SIGNAL ; + - n_s3_l52 ( u_s3_l52 Z ) ( u_s4_l25 A ) + USE SIGNAL ; + - n_s3_l53 ( u_s3_l53 Z ) ( u_s4_l38 A ) + USE SIGNAL ; + - n_s3_l54 ( u_s3_l54 Z ) ( u_s4_l51 A ) + USE SIGNAL ; + - n_s3_l55 ( u_s3_l55 Z ) ( u_s4_l64 A ) + USE SIGNAL ; + - n_s3_l56 ( u_s3_l56 Z ) ( u_s4_l77 A ) + USE SIGNAL ; + - n_s3_l57 ( u_s3_l57 Z ) ( u_s4_l90 A ) + USE SIGNAL ; + - n_s3_l58 ( u_s3_l58 Z ) ( u_s4_l7 A ) + USE SIGNAL ; + - n_s3_l59 ( u_s3_l59 Z ) ( u_s4_l20 A ) + USE SIGNAL ; + - n_s3_l60 ( u_s3_l60 Z ) ( u_s4_l33 A ) + USE SIGNAL ; + - n_s3_l61 ( u_s3_l61 Z ) ( u_s4_l46 A ) + USE SIGNAL ; + - n_s3_l62 ( u_s3_l62 Z ) ( u_s4_l59 A ) + USE SIGNAL ; + - n_s3_l63 ( u_s3_l63 Z ) ( u_s4_l72 A ) + USE SIGNAL ; + - n_s3_l64 ( u_s3_l64 Z ) ( u_s4_l85 A ) + USE SIGNAL ; + - n_s3_l65 ( u_s3_l65 Z ) ( u_s4_l2 A ) + USE SIGNAL ; + - n_s3_l66 ( u_s3_l66 Z ) ( u_s4_l15 A ) + USE SIGNAL ; + - n_s3_l67 ( u_s3_l67 Z ) ( u_s4_l28 A ) + USE SIGNAL ; + - n_s3_l68 ( u_s3_l68 Z ) ( u_s4_l41 A ) + USE SIGNAL ; + - n_s3_l69 ( u_s3_l69 Z ) ( u_s4_l54 A ) + USE SIGNAL ; + - n_s3_l70 ( u_s3_l70 Z ) ( u_s4_l67 A ) + USE SIGNAL ; + - n_s3_l71 ( u_s3_l71 Z ) ( u_s4_l80 A ) + USE SIGNAL ; + - n_s3_l72 ( u_s3_l72 Z ) ( u_s4_l93 A ) + USE SIGNAL ; + - n_s3_l73 ( u_s3_l73 Z ) ( u_s4_l10 A ) + USE SIGNAL ; + - n_s3_l74 ( u_s3_l74 Z ) ( u_s4_l23 A ) + USE SIGNAL ; + - n_s3_l75 ( u_s3_l75 Z ) ( u_s4_l36 A ) + USE SIGNAL ; + - n_s3_l76 ( u_s3_l76 Z ) ( u_s4_l49 A ) + USE SIGNAL ; + - n_s3_l77 ( u_s3_l77 Z ) ( u_s4_l62 A ) + USE SIGNAL ; + - n_s3_l78 ( u_s3_l78 Z ) ( u_s4_l75 A ) + USE SIGNAL ; + - n_s3_l79 ( u_s3_l79 Z ) ( u_s4_l88 A ) + USE SIGNAL ; + - n_s3_l80 ( u_s3_l80 Z ) ( u_s4_l5 A ) + USE SIGNAL ; + - n_s3_l81 ( u_s3_l81 Z ) ( u_s4_l18 A ) + USE SIGNAL ; + - n_s3_l82 ( u_s3_l82 Z ) ( u_s4_l31 A ) + USE SIGNAL ; + - n_s3_l83 ( u_s3_l83 Z ) ( u_s4_l44 A ) + USE SIGNAL ; + - n_s3_l84 ( u_s3_l84 Z ) ( u_s4_l57 A ) + USE SIGNAL ; + - n_s3_l85 ( u_s3_l85 Z ) ( u_s4_l70 A ) + USE SIGNAL ; + - n_s3_l86 ( u_s3_l86 Z ) ( u_s4_l83 A ) + USE SIGNAL ; + - n_s3_l87 ( u_s3_l87 Z ) ( u_s4_l0 A ) + USE SIGNAL ; + - n_s3_l88 ( u_s3_l88 Z ) ( u_s4_l13 A ) + USE SIGNAL ; + - n_s3_l89 ( u_s3_l89 Z ) ( u_s4_l26 A ) + USE SIGNAL ; + - n_s3_l90 ( u_s3_l90 Z ) ( u_s4_l39 A ) + USE SIGNAL ; + - n_s3_l91 ( u_s3_l91 Z ) ( u_s4_l52 A ) + USE SIGNAL ; + - n_s3_l92 ( u_s3_l92 Z ) ( u_s4_l65 A ) + USE SIGNAL ; + - n_s3_l93 ( u_s3_l93 Z ) ( u_s4_l78 A ) + USE SIGNAL ; + - n_s3_l94 ( u_s3_l94 Z ) ( u_s4_l91 A ) + USE SIGNAL ; + - n_s3_l95 ( u_s3_l95 Z ) ( u_s4_l8 A ) + USE SIGNAL ; + - n_s4_l0 ( u_s4_l0 Z ) ( u_s5_l28 A ) + USE SIGNAL ; + - n_s4_l1 ( u_s4_l1 Z ) ( u_s5_l45 A ) + USE SIGNAL ; + - n_s4_l2 ( u_s4_l2 Z ) ( u_s5_l62 A ) + USE SIGNAL ; + - n_s4_l3 ( u_s4_l3 Z ) ( u_s5_l79 A ) + USE SIGNAL ; + - n_s4_l4 ( u_s4_l4 Z ) ( u_s5_l0 A ) + USE SIGNAL ; + - n_s4_l5 ( u_s4_l5 Z ) ( u_s5_l17 A ) + USE SIGNAL ; + - n_s4_l6 ( u_s4_l6 Z ) ( u_s5_l34 A ) + USE SIGNAL ; + - n_s4_l7 ( u_s4_l7 Z ) ( u_s5_l51 A ) + USE SIGNAL ; + - n_s4_l8 ( u_s4_l8 Z ) ( u_s5_l68 A ) + USE SIGNAL ; + - n_s4_l9 ( u_s4_l9 Z ) ( u_s5_l85 A ) + USE SIGNAL ; + - n_s4_l10 ( u_s4_l10 Z ) ( u_s5_l6 A ) + USE SIGNAL ; + - n_s4_l11 ( u_s4_l11 Z ) ( u_s5_l23 A ) + USE SIGNAL ; + - n_s4_l12 ( u_s4_l12 Z ) ( u_s5_l40 A ) + USE SIGNAL ; + - n_s4_l13 ( u_s4_l13 Z ) ( u_s5_l57 A ) + USE SIGNAL ; + - n_s4_l14 ( u_s4_l14 Z ) ( u_s5_l74 A ) + USE SIGNAL ; + - n_s4_l15 ( u_s4_l15 Z ) ( u_s5_l91 A ) + USE SIGNAL ; + - n_s4_l16 ( u_s4_l16 Z ) ( u_s5_l12 A ) + USE SIGNAL ; + - n_s4_l17 ( u_s4_l17 Z ) ( u_s5_l29 A ) + USE SIGNAL ; + - n_s4_l18 ( u_s4_l18 Z ) ( u_s5_l46 A ) + USE SIGNAL ; + - n_s4_l19 ( u_s4_l19 Z ) ( u_s5_l63 A ) + USE SIGNAL ; + - n_s4_l20 ( u_s4_l20 Z ) ( u_s5_l80 A ) + USE SIGNAL ; + - n_s4_l21 ( u_s4_l21 Z ) ( u_s5_l1 A ) + USE SIGNAL ; + - n_s4_l22 ( u_s4_l22 Z ) ( u_s5_l18 A ) + USE SIGNAL ; + - n_s4_l23 ( u_s4_l23 Z ) ( u_s5_l35 A ) + USE SIGNAL ; + - n_s4_l24 ( u_s4_l24 Z ) ( u_s5_l52 A ) + USE SIGNAL ; + - n_s4_l25 ( u_s4_l25 Z ) ( u_s5_l69 A ) + USE SIGNAL ; + - n_s4_l26 ( u_s4_l26 Z ) ( u_s5_l86 A ) + USE SIGNAL ; + - n_s4_l27 ( u_s4_l27 Z ) ( u_s5_l7 A ) + USE SIGNAL ; + - n_s4_l28 ( u_s4_l28 Z ) ( u_s5_l24 A ) + USE SIGNAL ; + - n_s4_l29 ( u_s4_l29 Z ) ( u_s5_l41 A ) + USE SIGNAL ; + - n_s4_l30 ( u_s4_l30 Z ) ( u_s5_l58 A ) + USE SIGNAL ; + - n_s4_l31 ( u_s4_l31 Z ) ( u_s5_l75 A ) + USE SIGNAL ; + - n_s4_l32 ( u_s4_l32 Z ) ( u_s5_l92 A ) + USE SIGNAL ; + - n_s4_l33 ( u_s4_l33 Z ) ( u_s5_l13 A ) + USE SIGNAL ; + - n_s4_l34 ( u_s4_l34 Z ) ( u_s5_l30 A ) + USE SIGNAL ; + - n_s4_l35 ( u_s4_l35 Z ) ( u_s5_l47 A ) + USE SIGNAL ; + - n_s4_l36 ( u_s4_l36 Z ) ( u_s5_l64 A ) + USE SIGNAL ; + - n_s4_l37 ( u_s4_l37 Z ) ( u_s5_l81 A ) + USE SIGNAL ; + - n_s4_l38 ( u_s4_l38 Z ) ( u_s5_l2 A ) + USE SIGNAL ; + - n_s4_l39 ( u_s4_l39 Z ) ( u_s5_l19 A ) + USE SIGNAL ; + - n_s4_l40 ( u_s4_l40 Z ) ( u_s5_l36 A ) + USE SIGNAL ; + - n_s4_l41 ( u_s4_l41 Z ) ( u_s5_l53 A ) + USE SIGNAL ; + - n_s4_l42 ( u_s4_l42 Z ) ( u_s5_l70 A ) + USE SIGNAL ; + - n_s4_l43 ( u_s4_l43 Z ) ( u_s5_l87 A ) + USE SIGNAL ; + - n_s4_l44 ( u_s4_l44 Z ) ( u_s5_l8 A ) + USE SIGNAL ; + - n_s4_l45 ( u_s4_l45 Z ) ( u_s5_l25 A ) + USE SIGNAL ; + - n_s4_l46 ( u_s4_l46 Z ) ( u_s5_l42 A ) + USE SIGNAL ; + - n_s4_l47 ( u_s4_l47 Z ) ( u_s5_l59 A ) + USE SIGNAL ; + - n_s4_l48 ( u_s4_l48 Z ) ( u_s5_l76 A ) + USE SIGNAL ; + - n_s4_l49 ( u_s4_l49 Z ) ( u_s5_l93 A ) + USE SIGNAL ; + - n_s4_l50 ( u_s4_l50 Z ) ( u_s5_l14 A ) + USE SIGNAL ; + - n_s4_l51 ( u_s4_l51 Z ) ( u_s5_l31 A ) + USE SIGNAL ; + - n_s4_l52 ( u_s4_l52 Z ) ( u_s5_l48 A ) + USE SIGNAL ; + - n_s4_l53 ( u_s4_l53 Z ) ( u_s5_l65 A ) + USE SIGNAL ; + - n_s4_l54 ( u_s4_l54 Z ) ( u_s5_l82 A ) + USE SIGNAL ; + - n_s4_l55 ( u_s4_l55 Z ) ( u_s5_l3 A ) + USE SIGNAL ; + - n_s4_l56 ( u_s4_l56 Z ) ( u_s5_l20 A ) + USE SIGNAL ; + - n_s4_l57 ( u_s4_l57 Z ) ( u_s5_l37 A ) + USE SIGNAL ; + - n_s4_l58 ( u_s4_l58 Z ) ( u_s5_l54 A ) + USE SIGNAL ; + - n_s4_l59 ( u_s4_l59 Z ) ( u_s5_l71 A ) + USE SIGNAL ; + - n_s4_l60 ( u_s4_l60 Z ) ( u_s5_l88 A ) + USE SIGNAL ; + - n_s4_l61 ( u_s4_l61 Z ) ( u_s5_l9 A ) + USE SIGNAL ; + - n_s4_l62 ( u_s4_l62 Z ) ( u_s5_l26 A ) + USE SIGNAL ; + - n_s4_l63 ( u_s4_l63 Z ) ( u_s5_l43 A ) + USE SIGNAL ; + - n_s4_l64 ( u_s4_l64 Z ) ( u_s5_l60 A ) + USE SIGNAL ; + - n_s4_l65 ( u_s4_l65 Z ) ( u_s5_l77 A ) + USE SIGNAL ; + - n_s4_l66 ( u_s4_l66 Z ) ( u_s5_l94 A ) + USE SIGNAL ; + - n_s4_l67 ( u_s4_l67 Z ) ( u_s5_l15 A ) + USE SIGNAL ; + - n_s4_l68 ( u_s4_l68 Z ) ( u_s5_l32 A ) + USE SIGNAL ; + - n_s4_l69 ( u_s4_l69 Z ) ( u_s5_l49 A ) + USE SIGNAL ; + - n_s4_l70 ( u_s4_l70 Z ) ( u_s5_l66 A ) + USE SIGNAL ; + - n_s4_l71 ( u_s4_l71 Z ) ( u_s5_l83 A ) + USE SIGNAL ; + - n_s4_l72 ( u_s4_l72 Z ) ( u_s5_l4 A ) + USE SIGNAL ; + - n_s4_l73 ( u_s4_l73 Z ) ( u_s5_l21 A ) + USE SIGNAL ; + - n_s4_l74 ( u_s4_l74 Z ) ( u_s5_l38 A ) + USE SIGNAL ; + - n_s4_l75 ( u_s4_l75 Z ) ( u_s5_l55 A ) + USE SIGNAL ; + - n_s4_l76 ( u_s4_l76 Z ) ( u_s5_l72 A ) + USE SIGNAL ; + - n_s4_l77 ( u_s4_l77 Z ) ( u_s5_l89 A ) + USE SIGNAL ; + - n_s4_l78 ( u_s4_l78 Z ) ( u_s5_l10 A ) + USE SIGNAL ; + - n_s4_l79 ( u_s4_l79 Z ) ( u_s5_l27 A ) + USE SIGNAL ; + - n_s4_l80 ( u_s4_l80 Z ) ( u_s5_l44 A ) + USE SIGNAL ; + - n_s4_l81 ( u_s4_l81 Z ) ( u_s5_l61 A ) + USE SIGNAL ; + - n_s4_l82 ( u_s4_l82 Z ) ( u_s5_l78 A ) + USE SIGNAL ; + - n_s4_l83 ( u_s4_l83 Z ) ( u_s5_l95 A ) + USE SIGNAL ; + - n_s4_l84 ( u_s4_l84 Z ) ( u_s5_l16 A ) + USE SIGNAL ; + - n_s4_l85 ( u_s4_l85 Z ) ( u_s5_l33 A ) + USE SIGNAL ; + - n_s4_l86 ( u_s4_l86 Z ) ( u_s5_l50 A ) + USE SIGNAL ; + - n_s4_l87 ( u_s4_l87 Z ) ( u_s5_l67 A ) + USE SIGNAL ; + - n_s4_l88 ( u_s4_l88 Z ) ( u_s5_l84 A ) + USE SIGNAL ; + - n_s4_l89 ( u_s4_l89 Z ) ( u_s5_l5 A ) + USE SIGNAL ; + - n_s4_l90 ( u_s4_l90 Z ) ( u_s5_l22 A ) + USE SIGNAL ; + - n_s4_l91 ( u_s4_l91 Z ) ( u_s5_l39 A ) + USE SIGNAL ; + - n_s4_l92 ( u_s4_l92 Z ) ( u_s5_l56 A ) + USE SIGNAL ; + - n_s4_l93 ( u_s4_l93 Z ) ( u_s5_l73 A ) + USE SIGNAL ; + - n_s4_l94 ( u_s4_l94 Z ) ( u_s5_l90 A ) + USE SIGNAL ; + - n_s4_l95 ( u_s4_l95 Z ) ( u_s5_l11 A ) + USE SIGNAL ; + - out[0] ( PIN out[0] ) ( u_s5_l0 Z ) + USE SIGNAL ; + - out[1] ( PIN out[1] ) ( u_s5_l1 Z ) + USE SIGNAL ; + - out[2] ( PIN out[2] ) ( u_s5_l2 Z ) + USE SIGNAL ; + - out[3] ( PIN out[3] ) ( u_s5_l3 Z ) + USE SIGNAL ; + - out[4] ( PIN out[4] ) ( u_s5_l4 Z ) + USE SIGNAL ; + - out[5] ( PIN out[5] ) ( u_s5_l5 Z ) + USE SIGNAL ; + - out[6] ( PIN out[6] ) ( u_s5_l6 Z ) + USE SIGNAL ; + - out[7] ( PIN out[7] ) ( u_s5_l7 Z ) + USE SIGNAL ; + - out[8] ( PIN out[8] ) ( u_s5_l8 Z ) + USE SIGNAL ; + - out[9] ( PIN out[9] ) ( u_s5_l9 Z ) + USE SIGNAL ; + - out[10] ( PIN out[10] ) ( u_s5_l10 Z ) + USE SIGNAL ; + - out[11] ( PIN out[11] ) ( u_s5_l11 Z ) + USE SIGNAL ; + - out[12] ( PIN out[12] ) ( u_s5_l12 Z ) + USE SIGNAL ; + - out[13] ( PIN out[13] ) ( u_s5_l13 Z ) + USE SIGNAL ; + - out[14] ( PIN out[14] ) ( u_s5_l14 Z ) + USE SIGNAL ; + - out[15] ( PIN out[15] ) ( u_s5_l15 Z ) + USE SIGNAL ; + - out[16] ( PIN out[16] ) ( u_s5_l16 Z ) + USE SIGNAL ; + - out[17] ( PIN out[17] ) ( u_s5_l17 Z ) + USE SIGNAL ; + - out[18] ( PIN out[18] ) ( u_s5_l18 Z ) + USE SIGNAL ; + - out[19] ( PIN out[19] ) ( u_s5_l19 Z ) + USE SIGNAL ; + - out[20] ( PIN out[20] ) ( u_s5_l20 Z ) + USE SIGNAL ; + - out[21] ( PIN out[21] ) ( u_s5_l21 Z ) + USE SIGNAL ; + - out[22] ( PIN out[22] ) ( u_s5_l22 Z ) + USE SIGNAL ; + - out[23] ( PIN out[23] ) ( u_s5_l23 Z ) + USE SIGNAL ; + - out[24] ( PIN out[24] ) ( u_s5_l24 Z ) + USE SIGNAL ; + - out[25] ( PIN out[25] ) ( u_s5_l25 Z ) + USE SIGNAL ; + - out[26] ( PIN out[26] ) ( u_s5_l26 Z ) + USE SIGNAL ; + - out[27] ( PIN out[27] ) ( u_s5_l27 Z ) + USE SIGNAL ; + - out[28] ( PIN out[28] ) ( u_s5_l28 Z ) + USE SIGNAL ; + - out[29] ( PIN out[29] ) ( u_s5_l29 Z ) + USE SIGNAL ; + - out[30] ( PIN out[30] ) ( u_s5_l30 Z ) + USE SIGNAL ; + - out[31] ( PIN out[31] ) ( u_s5_l31 Z ) + USE SIGNAL ; + - out[32] ( PIN out[32] ) ( u_s5_l32 Z ) + USE SIGNAL ; + - out[33] ( PIN out[33] ) ( u_s5_l33 Z ) + USE SIGNAL ; + - out[34] ( PIN out[34] ) ( u_s5_l34 Z ) + USE SIGNAL ; + - out[35] ( PIN out[35] ) ( u_s5_l35 Z ) + USE SIGNAL ; + - out[36] ( PIN out[36] ) ( u_s5_l36 Z ) + USE SIGNAL ; + - out[37] ( PIN out[37] ) ( u_s5_l37 Z ) + USE SIGNAL ; + - out[38] ( PIN out[38] ) ( u_s5_l38 Z ) + USE SIGNAL ; + - out[39] ( PIN out[39] ) ( u_s5_l39 Z ) + USE SIGNAL ; + - out[40] ( PIN out[40] ) ( u_s5_l40 Z ) + USE SIGNAL ; + - out[41] ( PIN out[41] ) ( u_s5_l41 Z ) + USE SIGNAL ; + - out[42] ( PIN out[42] ) ( u_s5_l42 Z ) + USE SIGNAL ; + - out[43] ( PIN out[43] ) ( u_s5_l43 Z ) + USE SIGNAL ; + - out[44] ( PIN out[44] ) ( u_s5_l44 Z ) + USE SIGNAL ; + - out[45] ( PIN out[45] ) ( u_s5_l45 Z ) + USE SIGNAL ; + - out[46] ( PIN out[46] ) ( u_s5_l46 Z ) + USE SIGNAL ; + - out[47] ( PIN out[47] ) ( u_s5_l47 Z ) + USE SIGNAL ; + - out[48] ( PIN out[48] ) ( u_s5_l48 Z ) + USE SIGNAL ; + - out[49] ( PIN out[49] ) ( u_s5_l49 Z ) + USE SIGNAL ; + - out[50] ( PIN out[50] ) ( u_s5_l50 Z ) + USE SIGNAL ; + - out[51] ( PIN out[51] ) ( u_s5_l51 Z ) + USE SIGNAL ; + - out[52] ( PIN out[52] ) ( u_s5_l52 Z ) + USE SIGNAL ; + - out[53] ( PIN out[53] ) ( u_s5_l53 Z ) + USE SIGNAL ; + - out[54] ( PIN out[54] ) ( u_s5_l54 Z ) + USE SIGNAL ; + - out[55] ( PIN out[55] ) ( u_s5_l55 Z ) + USE SIGNAL ; + - out[56] ( PIN out[56] ) ( u_s5_l56 Z ) + USE SIGNAL ; + - out[57] ( PIN out[57] ) ( u_s5_l57 Z ) + USE SIGNAL ; + - out[58] ( PIN out[58] ) ( u_s5_l58 Z ) + USE SIGNAL ; + - out[59] ( PIN out[59] ) ( u_s5_l59 Z ) + USE SIGNAL ; + - out[60] ( PIN out[60] ) ( u_s5_l60 Z ) + USE SIGNAL ; + - out[61] ( PIN out[61] ) ( u_s5_l61 Z ) + USE SIGNAL ; + - out[62] ( PIN out[62] ) ( u_s5_l62 Z ) + USE SIGNAL ; + - out[63] ( PIN out[63] ) ( u_s5_l63 Z ) + USE SIGNAL ; + - out[64] ( PIN out[64] ) ( u_s5_l64 Z ) + USE SIGNAL ; + - out[65] ( PIN out[65] ) ( u_s5_l65 Z ) + USE SIGNAL ; + - out[66] ( PIN out[66] ) ( u_s5_l66 Z ) + USE SIGNAL ; + - out[67] ( PIN out[67] ) ( u_s5_l67 Z ) + USE SIGNAL ; + - out[68] ( PIN out[68] ) ( u_s5_l68 Z ) + USE SIGNAL ; + - out[69] ( PIN out[69] ) ( u_s5_l69 Z ) + USE SIGNAL ; + - out[70] ( PIN out[70] ) ( u_s5_l70 Z ) + USE SIGNAL ; + - out[71] ( PIN out[71] ) ( u_s5_l71 Z ) + USE SIGNAL ; + - out[72] ( PIN out[72] ) ( u_s5_l72 Z ) + USE SIGNAL ; + - out[73] ( PIN out[73] ) ( u_s5_l73 Z ) + USE SIGNAL ; + - out[74] ( PIN out[74] ) ( u_s5_l74 Z ) + USE SIGNAL ; + - out[75] ( PIN out[75] ) ( u_s5_l75 Z ) + USE SIGNAL ; + - out[76] ( PIN out[76] ) ( u_s5_l76 Z ) + USE SIGNAL ; + - out[77] ( PIN out[77] ) ( u_s5_l77 Z ) + USE SIGNAL ; + - out[78] ( PIN out[78] ) ( u_s5_l78 Z ) + USE SIGNAL ; + - out[79] ( PIN out[79] ) ( u_s5_l79 Z ) + USE SIGNAL ; + - out[80] ( PIN out[80] ) ( u_s5_l80 Z ) + USE SIGNAL ; + - out[81] ( PIN out[81] ) ( u_s5_l81 Z ) + USE SIGNAL ; + - out[82] ( PIN out[82] ) ( u_s5_l82 Z ) + USE SIGNAL ; + - out[83] ( PIN out[83] ) ( u_s5_l83 Z ) + USE SIGNAL ; + - out[84] ( PIN out[84] ) ( u_s5_l84 Z ) + USE SIGNAL ; + - out[85] ( PIN out[85] ) ( u_s5_l85 Z ) + USE SIGNAL ; + - out[86] ( PIN out[86] ) ( u_s5_l86 Z ) + USE SIGNAL ; + - out[87] ( PIN out[87] ) ( u_s5_l87 Z ) + USE SIGNAL ; + - out[88] ( PIN out[88] ) ( u_s5_l88 Z ) + USE SIGNAL ; + - out[89] ( PIN out[89] ) ( u_s5_l89 Z ) + USE SIGNAL ; + - out[90] ( PIN out[90] ) ( u_s5_l90 Z ) + USE SIGNAL ; + - out[91] ( PIN out[91] ) ( u_s5_l91 Z ) + USE SIGNAL ; + - out[92] ( PIN out[92] ) ( u_s5_l92 Z ) + USE SIGNAL ; + - out[93] ( PIN out[93] ) ( u_s5_l93 Z ) + USE SIGNAL ; + - out[94] ( PIN out[94] ) ( u_s5_l94 Z ) + USE SIGNAL ; + - out[95] ( PIN out[95] ) ( u_s5_l95 Z ) + USE SIGNAL ; +END NETS +END DESIGN diff --git a/src/grt/test/snapshot_batched_bus_route.tcl b/src/grt/test/snapshot_batched_bus_route.tcl new file mode 100644 index 00000000000..e355af833d2 --- /dev/null +++ b/src/grt/test/snapshot_batched_bus_route.tcl @@ -0,0 +1,11 @@ +set_thread_count 16 + +rename global_route global_route_serial +proc global_route { args } { + uplevel 1 [list global_route_serial {*}$args -snapshot_batched_width 16] +} + +source "bus_route.tcl" + +puts "pass" +exit 0 diff --git a/src/grt/test/snapshot_batched_incremental_state.tcl b/src/grt/test/snapshot_batched_incremental_state.tcl new file mode 100644 index 00000000000..b5ff4b6a88b --- /dev/null +++ b/src/grt/test/snapshot_batched_incremental_state.tcl @@ -0,0 +1,36 @@ +source "helpers.tcl" +read_lef "Nangate45/Nangate45.lef" +read_def "gcd.def" + +set_thread_count 16 + +if { [grt::get_snapshot_batched_width] != 0 } { + utl::error GRT 707 \ + "FastRoute should start with snapshot_batched_width set to 0." +} + +global_route -verbose -snapshot_batched_width 16 + +if { [grt::get_snapshot_batched_width] != 16 } { + utl::error GRT 708 \ + "Default global_route should leave snapshot_batched_width at 16." +} + +global_route -start_incremental +global_route -end_incremental -snapshot_batched_width 16 + +if { [grt::get_snapshot_batched_width] != 16 } { + utl::error GRT 709 \ + "Incremental global_route -snapshot_batched_width 16 did not reach FastRoute." +} + +global_route -start_incremental +global_route -end_incremental -snapshot_batched_width 0 + +if { [grt::get_snapshot_batched_width] != 0 } { + utl::error GRT 710 \ + "Incremental global_route -snapshot_batched_width 0 did not disable snapshot-batched routing." +} + +puts "pass" +exit 0 diff --git a/src/grt/test/snapshot_batched_single_thread_smoke.tcl b/src/grt/test/snapshot_batched_single_thread_smoke.tcl new file mode 100644 index 00000000000..0e3df883d89 --- /dev/null +++ b/src/grt/test/snapshot_batched_single_thread_smoke.tcl @@ -0,0 +1,46 @@ +source "helpers.tcl" +read_lef "Nangate45/Nangate45.lef" +read_def "shuffle_stress.def" + +set_thread_count 1 + +set_routing_layers -signal metal2-metal6 +set_global_routing_layer_adjustment * 0.20 +foreach layer {metal2 metal3 metal4 metal5} { + set_global_routing_region_adjustment {7.8 2.8 10.2 140.0} \ + -layer $layer \ + -adjustment 0.20 +} + +set output "" +tee -variable output -quiet { + global_route -allow_congestion -snapshot_batched_width 16 \ + -congestion_iterations 200 -verbose +} + +if { [grt::get_snapshot_batched_width] != 16 } { + utl::error GRT 711 \ + "global_route -snapshot_batched_width 16 should keep\ + snapshot-batched routing enabled even with one requested thread." +} + +set wirelength -1 +set vias -1 + +foreach line [split $output "\n"] { + if { [regexp {Total wirelength:\s+([0-9]+)\s+um} $line -> value] } { + set wirelength $value + } elseif { [regexp {Final number of vias:\s+([0-9]+)} $line -> value] } { + set vias $value + } +} + +if { $wirelength <= 0 || $vias < 0 } { + utl::error GRT 712 \ + "Failed to capture single-thread snapshot-batched global-route summary output." +} + +require_snapshot_batched_activity "snapshot_batched_single_thread_smoke" + +puts "pass" +exit 0 diff --git a/src/grt/test/snapshot_batched_smoke.tcl b/src/grt/test/snapshot_batched_smoke.tcl new file mode 100644 index 00000000000..67a53bad24f --- /dev/null +++ b/src/grt/test/snapshot_batched_smoke.tcl @@ -0,0 +1,44 @@ +source "helpers.tcl" +read_lef "Nangate45/Nangate45.lef" +read_def "shuffle_stress.def" + +set_thread_count 16 + +set_routing_layers -signal metal2-metal6 +set_global_routing_layer_adjustment * 0.20 +foreach layer {metal2 metal3 metal4 metal5} { + set_global_routing_region_adjustment {7.8 2.8 10.2 140.0} \ + -layer $layer \ + -adjustment 0.20 +} + +set output "" +tee -variable output -quiet { + global_route -allow_congestion -snapshot_batched_width 16 \ + -congestion_iterations 200 -verbose +} + +set report_file [make_result_file "snapshot_batched_smoke.rpt"] +set stream [open $report_file w] +puts -nonewline $stream $output +close $stream + +set wirelength -1 +set vias -1 + +foreach line [split $output "\n"] { + if { [regexp {Total wirelength:\s+([0-9]+)\s+um} $line -> value] } { + set wirelength $value + } elseif { [regexp {Final number of vias:\s+([0-9]+)} $line -> value] } { + set vias $value + } +} + +if { $wirelength <= 0 || $vias < 0 } { + utl::error GRT 706 "Failed to capture snapshot-batched global-route summary output." +} + +require_snapshot_batched_activity "snapshot_batched_smoke" + +puts "pass" +exit 0 diff --git a/src/grt/test/thread_count_reports.tcl b/src/grt/test/thread_count_reports.tcl new file mode 100644 index 00000000000..b3e8414d073 --- /dev/null +++ b/src/grt/test/thread_count_reports.tcl @@ -0,0 +1,66 @@ +source "helpers.tcl" +read_lef "Nangate45/Nangate45.lef" +read_def "gcd.def" + +proc write_thread_report { output file_name } { + set stream [open $file_name w] + set section "" + set found_wirelength 0 + set found_resources 0 + set found_congestion 0 + + foreach line [split $output "\n"] { + if { $section eq "" } { + if { [regexp {Routing resources analysis:} $line] } { + set section "resources" + set found_resources 1 + puts $stream $line + } elseif { [regexp {Final congestion report:} $line] } { + set section "congestion" + set found_congestion 1 + puts $stream $line + } elseif { [regexp {Total wirelength:} $line] } { + set found_wirelength 1 + puts $stream $line + } + } else { + puts $stream $line + if { $line eq "" } { + set section "" + } + } + } + + close $stream + + if { !$found_resources || !$found_congestion || !$found_wirelength } { + utl::error GRT 705 \ + "Failed to capture threaded global-route report output." + } +} + +proc capture_thread_report { thread_count prefix } { + set_thread_count $thread_count + + set output "" + tee -variable output -quiet {global_route -verbose} + + set raw_file [make_result_file "${prefix}.raw.rpt"] + set stream [open $raw_file w] + puts -nonewline $stream $output + close $stream + + set report_file [make_result_file "${prefix}.rpt"] + write_thread_report $output $report_file + return $report_file +} + +set report_file1 [capture_thread_report 1 thread_count_reports1] +set report_file2 [capture_thread_report 2 thread_count_reports2] + +if { [diff_files $report_file1 $report_file2] != 0 } { + exit 1 +} + +puts "pass" +exit 0 diff --git a/test/helpers.tcl b/test/helpers.tcl index 9f204442467..cf4fbed4606 100644 --- a/test/helpers.tcl +++ b/test/helpers.tcl @@ -202,6 +202,13 @@ proc diff_files { file1 file2 { ignore "" } } { } } +proc require_snapshot_batched_activity { test_name } { + if { [grt::get_snapshot_batch_count] <= 0 } { + utl::error GRT 713 \ + "$test_name did not execute snapshot-batched routing." + } +} + proc run_unit_test_and_exit { relative_path } { set test_dir [pwd] set openroad_dir [file dirname [file dirname [file dirname $test_dir]]]