From 76d8496008913b4e9a07451c24ad031e04a37b69 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 12:24:28 -0700 Subject: [PATCH 001/120] [cli] add crr cli parameters --- vpr/src/base/read_options.cpp | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp index fca403f89e..ef17a2a5c6 100644 --- a/vpr/src/base/read_options.cpp +++ b/vpr/src/base/read_options.cpp @@ -3280,6 +3280,39 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio .default_value("off") .show_in(argparse::ShowIn::HELP_ONLY); + auto& crr_grp = parser.add_argument_group("CRR options"); + + crr_grp.add_argument(args.sb_maps, "--sb_maps") + .help("Switch block map file that specifed the switch block template used for each location") + .default_value("off") + .show_in(argparse::ShowIn::HELP_ONLY); + + crr_grp.add_argument(args.sb_templates, "--sb_templates") + .help("Directory containing the switch block templates") + .default_value("off") + .show_in(argparse::ShowIn::HELP_ONLY); + + crr_grp.add_argument(args.crr_num_threads, "--crr_num_threads") + .help("Number of threads to use for the CRR generation") + .default_value("1") + .show_in(argparse::ShowIn::HELP_ONLY); + + crr_grp.add_argument(args.preserve_input_pins, "--preserve_input_pins") + .help("Whether the input pins connections should be generated by the default flow and not from the CRR template") + .default_value("off") + .show_in(argparse::ShowIn::HELP_ONLY); + + crr_grp.add_argument(args.preserve_output_pins, "--preserve_output_pins") + .help("Whether the output pins connections should be generated by the default flow and not from the CRR template") + .default_value("off") + .show_in(argparse::ShowIn::HELP_ONLY); + + crr_grp.add_argument(args.annotated_rr_graph, "--annotated_rr_graph") + .help("Whether the generated CRR should be annotated with delay") + .default_value("off") + .show_in(argparse::ShowIn::HELP_ONLY); + + auto& power_grp = parser.add_argument_group("power analysis options"); power_grp.add_argument(args.do_power, "--power") From a1b7cc93b2982e73f4d68d667bf5e6f7fafd63b8 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 12:39:35 -0700 Subject: [PATCH 002/120] [setup_vpr] add structs for crrOpts --- vpr/src/base/setup_vpr.cpp | 12 ++++++++++++ vpr/src/base/setup_vpr.h | 1 + 2 files changed, 13 insertions(+) diff --git a/vpr/src/base/setup_vpr.cpp b/vpr/src/base/setup_vpr.cpp index 8bdbed39dc..c5b6d94754 100644 --- a/vpr/src/base/setup_vpr.cpp +++ b/vpr/src/base/setup_vpr.cpp @@ -48,6 +48,7 @@ static void setup_switches(const t_arch& Arch, t_det_routing_arch& RoutingArch, const std::vector& arch_switches); static void setup_analysis_opts(const t_options& Options, t_analysis_opts& analysis_opts); +static void setup_crr_opts(const t_options& Options, t_crr_opts& crr_opts); static void setup_power_opts(const t_options& Options, t_power_opts* power_opts, t_arch* Arch); /** @@ -99,6 +100,7 @@ void SetupVPR(const t_options* options, t_ap_opts* apOpts, t_router_opts* routerOpts, t_analysis_opts* analysisOpts, + t_crr_opts* crrOpts, t_noc_opts* nocOpts, t_server_opts* serverOpts, t_det_routing_arch& routingArch, @@ -151,6 +153,7 @@ void SetupVPR(const t_options* options, setup_anneal_sched(*options, &placerOpts->anneal_sched); setup_router_opts(*options, routerOpts); setup_analysis_opts(*options, *analysisOpts); + setup_crr_opts(*options, *crrOpts); setup_power_opts(*options, powerOpts, arch); setup_noc_opts(*options, nocOpts); setup_server_opts(*options, serverOpts); @@ -755,6 +758,15 @@ static void setup_analysis_opts(const t_options& Options, t_analysis_opts& analy analysis_opts.generate_net_timing_report = Options.generate_net_timing_report; } +static void setup_crr_opts(const t_options& Options, t_crr_opts& crr_opts) { + crr_opts.sb_maps = Options.sb_maps; + crr_opts.sb_templates = Options.sb_templates; + crr_opts.crr_num_threads = Options.crr_num_threads; + crr_opts.preserve_input_pins = Options.preserve_input_pins; + crr_opts.preserve_output_pins = Options.preserve_output_pins; + crr_opts.annotated_rr_graph = Options.annotated_rr_graph; +} + static void setup_power_opts(const t_options& Options, t_power_opts* power_opts, t_arch* Arch) { DeviceContext& device_ctx = g_vpr_ctx.mutable_device(); diff --git a/vpr/src/base/setup_vpr.h b/vpr/src/base/setup_vpr.h index f72bb231bd..1e6eaa5812 100644 --- a/vpr/src/base/setup_vpr.h +++ b/vpr/src/base/setup_vpr.h @@ -16,6 +16,7 @@ void SetupVPR(const t_options* Options, t_ap_opts* APOpts, t_router_opts* RouterOpts, t_analysis_opts* AnalysisOpts, + t_crr_opts* CRROpts, t_noc_opts* NocOpts, t_server_opts* ServerOpts, t_det_routing_arch& RoutingArch, From 8f30644710154f9f8fdce3781444a03f2a899b02 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 14:36:26 -0700 Subject: [PATCH 003/120] [utils] pass CRROpts to alloc_routing_structs --- utils/route_diag/src/main.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/utils/route_diag/src/main.cpp b/utils/route_diag/src/main.cpp index 3dd599504a..af2f783302 100644 --- a/utils/route_diag/src/main.cpp +++ b/utils/route_diag/src/main.cpp @@ -296,6 +296,7 @@ int main(int argc, const char **argv) { alloc_routing_structs(chan_width, vpr_setup.RouterOpts, + vpr_setup.CRROpts, vpr_setup.RoutingArch, vpr_setup.Segments, Arch.directs, From f18cc17ce6576a7e24d880d0d07f14a2cc9daf28 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 14:38:12 -0700 Subject: [PATCH 004/120] [place] padd crropts to relevant funcitons in placement --- vpr/src/analytical_place/analytical_placement_flow.cpp | 1 + vpr/src/analytical_place/detailed_placer.cpp | 1 + vpr/src/place/delay_model/PlacementDelayModelCreator.cpp | 9 ++++++++- vpr/src/place/delay_model/PlacementDelayModelCreator.h | 2 ++ vpr/src/place/place.cpp | 2 ++ vpr/src/place/place.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-) diff --git a/vpr/src/analytical_place/analytical_placement_flow.cpp b/vpr/src/analytical_place/analytical_placement_flow.cpp index 62b6f8889f..b078c7e455 100644 --- a/vpr/src/analytical_place/analytical_placement_flow.cpp +++ b/vpr/src/analytical_place/analytical_placement_flow.cpp @@ -238,6 +238,7 @@ void run_analytical_placement_flow(t_vpr_setup& vpr_setup) { if (pre_cluster_timing_manager.is_valid()) { place_delay_model = PlacementDelayModelCreator::create_delay_model(vpr_setup.PlacerOpts, vpr_setup.RouterOpts, + vpr_setup.CRROpts, (const Netlist<>&)atom_nlist, vpr_setup.RoutingArch, vpr_setup.Segments, diff --git a/vpr/src/analytical_place/detailed_placer.cpp b/vpr/src/analytical_place/detailed_placer.cpp index 615493df77..ac8cc816e5 100644 --- a/vpr/src/analytical_place/detailed_placer.cpp +++ b/vpr/src/analytical_place/detailed_placer.cpp @@ -64,6 +64,7 @@ AnnealerDetailedPlacer::AnnealerDetailedPlacer(const BlkLocRegistry& curr_cluste if (vpr_setup.PlacerOpts.place_algorithm.is_timing_driven()) { place_delay_model = PlacementDelayModelCreator::create_delay_model(vpr_setup.PlacerOpts, vpr_setup.RouterOpts, + vpr_setup.CRROpts, (const Netlist<>&)clustered_netlist, vpr_setup.RoutingArch, vpr_setup.Segments, diff --git a/vpr/src/place/delay_model/PlacementDelayModelCreator.cpp b/vpr/src/place/delay_model/PlacementDelayModelCreator.cpp index 551ce777c0..a7b90c1ea6 100644 --- a/vpr/src/place/delay_model/PlacementDelayModelCreator.cpp +++ b/vpr/src/place/delay_model/PlacementDelayModelCreator.cpp @@ -26,6 +26,7 @@ static int get_longest_segment_length(const std::vector& segment_ std::unique_ptr PlacementDelayModelCreator::create_delay_model(const t_placer_opts& placer_opts, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const Netlist<>& net_list, t_det_routing_arch& det_routing_arch, const std::vector& segment_inf, @@ -36,7 +37,13 @@ PlacementDelayModelCreator::create_delay_model(const t_placer_opts& placer_opts, t_chan_width chan_width = setup_chan_width(router_opts, chan_width_dist); - alloc_routing_structs(chan_width, router_opts, det_routing_arch, segment_inf, directs, is_flat); + alloc_routing_structs(chan_width, + router_opts, + crr_opts, + det_routing_arch, + segment_inf, + directs, + is_flat); const RouterLookahead* router_lookahead = get_cached_router_lookahead(det_routing_arch, router_opts.lookahead_type, diff --git a/vpr/src/place/delay_model/PlacementDelayModelCreator.h b/vpr/src/place/delay_model/PlacementDelayModelCreator.h index 6da4ac56f1..802d59ddcb 100644 --- a/vpr/src/place/delay_model/PlacementDelayModelCreator.h +++ b/vpr/src/place/delay_model/PlacementDelayModelCreator.h @@ -8,6 +8,7 @@ class PlaceDelayModel; struct t_placer_opts; struct t_router_opts; +struct t_crr_opts; struct t_det_routing_arch; struct t_segment_inf; struct t_chan_width_dist; @@ -20,6 +21,7 @@ class PlacementDelayModelCreator { static std::unique_ptr create_delay_model(const t_placer_opts& placer_opts, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const Netlist<>& net_list, t_det_routing_arch& det_routing_arch, const std::vector& segment_inf, diff --git a/vpr/src/place/place.cpp b/vpr/src/place/place.cpp index c5d46b5af3..a6061bfd4b 100644 --- a/vpr/src/place/place.cpp +++ b/vpr/src/place/place.cpp @@ -29,6 +29,7 @@ void print_clb_placement(const char* fname); void try_place(const Netlist<>& net_list, const t_placer_opts& placer_opts, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const t_analysis_opts& analysis_opts, const t_noc_opts& noc_opts, const t_chan_width_dist& chan_width_dist, @@ -83,6 +84,7 @@ void try_place(const Netlist<>& net_list, /*do this before the initial placement to avoid messing up the initial placement */ place_delay_model = PlacementDelayModelCreator::create_delay_model(placer_opts, router_opts, + crr_opts, net_list, det_routing_arch, segment_inf, diff --git a/vpr/src/place/place.h b/vpr/src/place/place.h index 37246502bc..109158d5b9 100644 --- a/vpr/src/place/place.h +++ b/vpr/src/place/place.h @@ -8,6 +8,7 @@ class FlatPlacementInfo; void try_place(const Netlist<>& net_list, const t_placer_opts& placer_opts, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const t_analysis_opts& analysis_opts, const t_noc_opts& noc_opts, const t_chan_width_dist& chan_width_dist, From 81b4cc1e949260669d8e66e44bf45142b8aa65ca Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 14:44:41 -0700 Subject: [PATCH 005/120] [vpr][types] add t_crr_opts --- vpr/src/base/vpr_types.h | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h index bfed5f4ef1..2d2ce79d2a 100644 --- a/vpr/src/base/vpr_types.h +++ b/vpr/src/base/vpr_types.h @@ -1409,6 +1409,16 @@ struct t_analysis_opts { bool skip_sync_clustering_and_routing_results; }; +/// Stores CRR specific options +struct t_crr_opts { + std::string sb_maps; + std::string sb_templates; + int crr_num_threads; + bool preserve_input_pins; + bool preserve_output_pins; + bool annotated_rr_graph; +}; + /// Stores NoC specific options, when supplied as an input by the user struct t_noc_opts { bool noc; /// Date: Tue, 14 Oct 2025 14:46:18 -0700 Subject: [PATCH 006/120] [vpr][base] pass CRROpts to relevant base functions --- vpr/src/base/place_and_route.cpp | 7 ++++++- vpr/src/base/place_and_route.h | 1 + vpr/src/base/read_options.h | 8 ++++++++ vpr/src/base/vpr_api.cpp | 7 +++++++ vpr/src/base/vpr_api.h | 1 + 5 files changed, 23 insertions(+), 1 deletion(-) diff --git a/vpr/src/base/place_and_route.cpp b/vpr/src/base/place_and_route.cpp index 4462fbe1d8..a50257360d 100644 --- a/vpr/src/base/place_and_route.cpp +++ b/vpr/src/base/place_and_route.cpp @@ -42,6 +42,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, const Netlist<>& router_net_list, const t_placer_opts& placer_opts_ref, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const t_analysis_opts& analysis_opts, const t_noc_opts& noc_opts, const t_file_name_opts& filename_opts, @@ -172,6 +173,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, try_place(placement_net_list, placer_opts, router_opts, + crr_opts, analysis_opts, noc_opts, arch->Chans, @@ -184,6 +186,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, success = route(router_net_list, current, router_opts, + crr_opts, analysis_opts, det_routing_arch, segment_inf, net_delay, @@ -314,7 +317,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, break; if (placer_opts.place_freq == PLACE_ALWAYS) { placer_opts.place_chan_width = current; - try_place(placement_net_list, placer_opts, router_opts, analysis_opts, noc_opts, + try_place(placement_net_list, placer_opts, router_opts, crr_opts, analysis_opts, noc_opts, arch->Chans, det_routing_arch, segment_inf, arch->directs, FlatPlacementInfo(), // Pass empty flat placement info. @@ -324,6 +327,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, success = route(router_net_list, current, router_opts, + crr_opts, analysis_opts, det_routing_arch, segment_inf, @@ -374,6 +378,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, det_routing_arch, segment_inf, router_opts, + crr_opts, arch->directs, &warnings, is_flat); diff --git a/vpr/src/base/place_and_route.h b/vpr/src/base/place_and_route.h index a67712d694..356eae042a 100644 --- a/vpr/src/base/place_and_route.h +++ b/vpr/src/base/place_and_route.h @@ -21,6 +21,7 @@ int binary_search_place_and_route(const Netlist<>& placement_net_list, const Netlist<>& router_net_list, const t_placer_opts& placer_opts_ref, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const t_analysis_opts& analysis_opts, const t_noc_opts& noc_opts, const t_file_name_opts& filename_opts, diff --git a/vpr/src/base/read_options.h b/vpr/src/base/read_options.h index 5485f058c4..c0a25c0ea0 100644 --- a/vpr/src/base/read_options.h +++ b/vpr/src/base/read_options.h @@ -284,6 +284,14 @@ struct t_options { argparse::ArgValue write_timing_summary; argparse::ArgValue skip_sync_clustering_and_routing_results; argparse::ArgValue generate_net_timing_report; + + /* CRR options */ + argparse::ArgValue sb_maps; + argparse::ArgValue sb_templates; + argparse::ArgValue crr_num_threads; + argparse::ArgValue preserve_input_pins; + argparse::ArgValue preserve_output_pins; + argparse::ArgValue annotated_rr_graph; }; argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_options& args); diff --git a/vpr/src/base/vpr_api.cpp b/vpr/src/base/vpr_api.cpp index fab47d319c..2bfb9fb75a 100644 --- a/vpr/src/base/vpr_api.cpp +++ b/vpr/src/base/vpr_api.cpp @@ -297,6 +297,7 @@ void vpr_init_with_options(const t_options* options, t_vpr_setup* vpr_setup, t_a &vpr_setup->APOpts, &vpr_setup->RouterOpts, &vpr_setup->AnalysisOpts, + &vpr_setup->CRROpts, &vpr_setup->NocOpts, &vpr_setup->ServerOpts, vpr_setup->RoutingArch, @@ -879,6 +880,7 @@ void vpr_place(const Netlist<>& net_list, try_place(net_list, vpr_setup.PlacerOpts, vpr_setup.RouterOpts, + vpr_setup.CRROpts, vpr_setup.AnalysisOpts, vpr_setup.NocOpts, arch.Chans, @@ -1095,6 +1097,7 @@ RouteStatus vpr_route_fixed_W(const Netlist<>& net_list, status = route(net_list, fixed_channel_width, vpr_setup.RouterOpts, + vpr_setup.CRROpts, vpr_setup.AnalysisOpts, vpr_setup.RoutingArch, vpr_setup.Segments, @@ -1127,6 +1130,7 @@ RouteStatus vpr_route_min_W(const Netlist<>& net_list, net_list, vpr_setup.PlacerOpts, router_opts, + vpr_setup.CRROpts, vpr_setup.AnalysisOpts, vpr_setup.NocOpts, vpr_setup.FileNameOpts, @@ -1207,6 +1211,7 @@ void vpr_create_rr_graph(t_vpr_setup& vpr_setup, const t_arch& arch, int chan_wi det_routing_arch, vpr_setup.Segments, router_opts, + vpr_setup.CRROpts, arch.directs, &warnings, is_flat); @@ -1349,6 +1354,7 @@ void vpr_setup_vpr(t_options* Options, t_ap_opts* APOpts, t_router_opts* RouterOpts, t_analysis_opts* AnalysisOpts, + t_crr_opts* CRROpts, t_noc_opts* NocOpts, t_server_opts* ServerOpts, t_det_routing_arch& RoutingArch, @@ -1372,6 +1378,7 @@ void vpr_setup_vpr(t_options* Options, APOpts, RouterOpts, AnalysisOpts, + CRROpts, NocOpts, ServerOpts, RoutingArch, diff --git a/vpr/src/base/vpr_api.h b/vpr/src/base/vpr_api.h index 7147691ba7..90f156e2ca 100644 --- a/vpr/src/base/vpr_api.h +++ b/vpr/src/base/vpr_api.h @@ -181,6 +181,7 @@ void vpr_setup_vpr(t_options* Options, t_ap_opts* APOpts, t_router_opts* RouterOpts, t_analysis_opts* AnalysisOpts, + t_crr_opts* CRROpts, t_noc_opts* NocOpts, t_server_opts* ServerOpts, t_det_routing_arch& RoutingArch, From 4bb1fbdad10e87454e7228cf26a175105d4c1ef2 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 14:48:48 -0700 Subject: [PATCH 007/120] [vpr][route] pass crr_opts to relevant routing functions --- vpr/src/route/route.cpp | 2 ++ vpr/src/route/route.h | 1 + vpr/src/route/route_utils.cpp | 2 ++ vpr/src/route/route_utils.h | 1 + vpr/src/route/router_delay_profiling.cpp | 2 ++ vpr/src/route/router_delay_profiling.h | 1 + vpr/src/route/rr_graph_generation/rr_graph.cpp | 1 + vpr/src/route/rr_graph_generation/rr_graph.h | 1 + 8 files changed, 11 insertions(+) diff --git a/vpr/src/route/route.cpp b/vpr/src/route/route.cpp index 1a9f74e226..3bd19a1b05 100644 --- a/vpr/src/route/route.cpp +++ b/vpr/src/route/route.cpp @@ -17,6 +17,7 @@ bool route(const Netlist<>& net_list, int width_fac, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const t_analysis_opts& analysis_opts, t_det_routing_arch& det_routing_arch, std::vector& segment_inf, @@ -62,6 +63,7 @@ bool route(const Netlist<>& net_list, det_routing_arch, segment_inf, router_opts, + crr_opts, directs, &warning_count, is_flat); diff --git a/vpr/src/route/route.h b/vpr/src/route/route.h index 5d519228d0..d3bf5f58f2 100644 --- a/vpr/src/route/route.h +++ b/vpr/src/route/route.h @@ -20,6 +20,7 @@ bool route(const Netlist<>& net_list, int width_fac, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const t_analysis_opts& analysis_opts, t_det_routing_arch& det_routing_arch, std::vector& segment_inf, diff --git a/vpr/src/route/route_utils.cpp b/vpr/src/route/route_utils.cpp index fe6d9cdc41..994623ae80 100644 --- a/vpr/src/route/route_utils.cpp +++ b/vpr/src/route/route_utils.cpp @@ -493,6 +493,7 @@ vtr::vector>> set_net /** Wrapper for create_rr_graph() with extra checks */ void try_graph(int width_fac, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, t_det_routing_arch& det_routing_arch, std::vector& segment_inf, t_chan_width_dist chan_width_dist, @@ -525,6 +526,7 @@ void try_graph(int width_fac, det_routing_arch, segment_inf, router_opts, + crr_opts, directs, &warning_count, is_flat); diff --git a/vpr/src/route/route_utils.h b/vpr/src/route/route_utils.h index 6aa2e2d6c7..16ca05b75d 100644 --- a/vpr/src/route/route_utils.h +++ b/vpr/src/route/route_utils.h @@ -149,6 +149,7 @@ vtr::vector>> set_net /** Wrapper for create_rr_graph() with extra checks */ void try_graph(int width_fac, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, t_det_routing_arch& det_routing_arch, std::vector& segment_inf, t_chan_width_dist chan_width_dist, diff --git a/vpr/src/route/router_delay_profiling.cpp b/vpr/src/route/router_delay_profiling.cpp index fcfa10335d..208f6e7cf2 100644 --- a/vpr/src/route/router_delay_profiling.cpp +++ b/vpr/src/route/router_delay_profiling.cpp @@ -238,6 +238,7 @@ vtr::vector calculate_all_path_delays_from_rr_node(RRNodeId src void alloc_routing_structs(const t_chan_width& chan_width, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, t_det_routing_arch& det_routing_arch, const std::vector& segment_inf, const std::vector& directs, @@ -264,6 +265,7 @@ void alloc_routing_structs(const t_chan_width& chan_width, det_routing_arch, segment_inf, router_opts, + crr_opts, directs, &warnings, is_flat); diff --git a/vpr/src/route/router_delay_profiling.h b/vpr/src/route/router_delay_profiling.h index 2769a34c45..430382ab97 100644 --- a/vpr/src/route/router_delay_profiling.h +++ b/vpr/src/route/router_delay_profiling.h @@ -46,6 +46,7 @@ vtr::vector calculate_all_path_delays_from_rr_node(RRNodeId src void alloc_routing_structs(const t_chan_width& chan_width, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, t_det_routing_arch& det_routing_arch, const std::vector& segment_inf, const std::vector& directs, diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp index 7671a72e91..709a38b7d7 100644 --- a/vpr/src/route/rr_graph_generation/rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/rr_graph.cpp @@ -385,6 +385,7 @@ void create_rr_graph(e_graph_type graph_type, t_det_routing_arch& det_routing_arch, const std::vector& segment_inf, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const std::vector& directs, int* Warnings, bool is_flat) { diff --git a/vpr/src/route/rr_graph_generation/rr_graph.h b/vpr/src/route/rr_graph_generation/rr_graph.h index 4aca0d82b7..ae8d82d69f 100644 --- a/vpr/src/route/rr_graph_generation/rr_graph.h +++ b/vpr/src/route/rr_graph_generation/rr_graph.h @@ -27,6 +27,7 @@ void create_rr_graph(e_graph_type graph_type, t_det_routing_arch& det_routing_arch, const std::vector& segment_inf, const t_router_opts& router_opts, + const t_crr_opts& crr_opts, const std::vector& directs, int* Warnings, bool is_flat); From 3b8da60ece2a492b20b3694b85a8afdd88c61d90 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 14:52:19 -0700 Subject: [PATCH 008/120] [vpr][route] pass crr_opts to build_tileable_unidir_rr_graph --- vpr/src/route/rr_graph_generation/rr_graph.cpp | 1 + .../tileable_rr_graph/tileable_rr_graph_builder.cpp | 1 + .../tileable_rr_graph/tileable_rr_graph_builder.h | 1 + 3 files changed, 3 insertions(+) diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp index 709a38b7d7..18a2c9c630 100644 --- a/vpr/src/route/rr_graph_generation/rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/rr_graph.cpp @@ -465,6 +465,7 @@ void create_rr_graph(e_graph_type graph_type, build_tileable_unidir_rr_graph(block_types, grid, nodes_per_chan, + crr_opts, det_routing_arch.switch_block_type, det_routing_arch.Fs, det_routing_arch.switch_block_subtype, diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp index 4c9369b9d8..59a95cde89 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp @@ -71,6 +71,7 @@ void build_tileable_unidir_rr_graph(const std::vector& types, const DeviceGrid& grids, const t_chan_width& chan_width, + const t_crr_opts& crr_opts, const e_switch_block_type& sb_type, const int& Fs, const e_switch_block_type& sb_subtype, diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.h index 5b3894fc5b..19ad80b4bb 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.h @@ -16,6 +16,7 @@ void build_tileable_unidir_rr_graph(const std::vector& types, const DeviceGrid& grids, const t_chan_width& chan_width, + const t_crr_opts& crr_opts, const e_switch_block_type& sb_type, const int& Fs, const e_switch_block_type& sb_subtype, From 5bdab0a1ef6e12571c04de1f0d52f9044e1669b7 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 15:50:55 -0700 Subject: [PATCH 009/120] [libs][external] add openXLSX --- .gitmodules | 3 +++ libs/EXTERNAL/OpenXLSX | 1 + 2 files changed, 4 insertions(+) create mode 160000 libs/EXTERNAL/OpenXLSX diff --git a/.gitmodules b/.gitmodules index b2b3b51fee..849f8ebca6 100644 --- a/.gitmodules +++ b/.gitmodules @@ -16,3 +16,6 @@ [submodule "libs/EXTERNAL/yosys-slang"] path = libs/EXTERNAL/yosys-slang url = https://github.com/povik/yosys-slang.git +[submodule "libs/EXTERNAL/OpenXLSX"] + path = libs/EXTERNAL/OpenXLSX + url = https://github.com/troldal/OpenXLSX.git diff --git a/libs/EXTERNAL/OpenXLSX b/libs/EXTERNAL/OpenXLSX new file mode 160000 index 0000000000..5723411d47 --- /dev/null +++ b/libs/EXTERNAL/OpenXLSX @@ -0,0 +1 @@ +Subproject commit 5723411d47643ce3b5b9994064c26ca8cd841f13 From b9f40e6a3c17823363af2cdca6b011021e6d04e9 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 16:02:50 -0700 Subject: [PATCH 010/120] [cli] fix default values for crr params --- vpr/src/base/read_options.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp index ef17a2a5c6..69511b4d35 100644 --- a/vpr/src/base/read_options.cpp +++ b/vpr/src/base/read_options.cpp @@ -3284,12 +3284,12 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio crr_grp.add_argument(args.sb_maps, "--sb_maps") .help("Switch block map file that specifed the switch block template used for each location") - .default_value("off") + .default_value("") .show_in(argparse::ShowIn::HELP_ONLY); crr_grp.add_argument(args.sb_templates, "--sb_templates") .help("Directory containing the switch block templates") - .default_value("off") + .default_value("") .show_in(argparse::ShowIn::HELP_ONLY); crr_grp.add_argument(args.crr_num_threads, "--crr_num_threads") From 664ca84461b193ccdd46dfe3985f959687a92737 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 16:09:13 -0700 Subject: [PATCH 011/120] [vpr][route][tileable] call crr generator if sb_maps is not empty --- .../tileable_rr_graph_builder.cpp | 68 ++++++++++--------- 1 file changed, 36 insertions(+), 32 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp index 59a95cde89..787621cbe3 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp @@ -240,39 +240,43 @@ void build_tileable_unidir_rr_graph(const std::vector& typ *Warnings |= RR_GRAPH_WARN_FC_CLIPPED; } - // Build the connections tile by tile: - // We classify rr_nodes into a general switch block (GSB) data structure - // where we create edges to each rr_nodes in the GSB with respect to - // Fc_in and Fc_out, switch block patterns - // In addition, we will also handle direct-connections: - // Add edges that bridge OPINs and IPINs to the rr_graph - // Create edges for a tileable rr_graph - build_rr_graph_edges(device_ctx.rr_graph, - device_ctx.rr_graph_builder, - rr_node_driver_switches, - grids, vib_grid, 0, - device_chan_width, - segment_inf, segment_inf_x, segment_inf_y, - Fc_in, Fc_out, - sb_type, Fs, sb_subtype, sub_fs, - perimeter_cb, - opin2all_sides, concat_wire, - wire_opposite_side, - delayless_rr_switch); - - // Build direction connection lists - // TODO: use tile direct builder - // Create data structure of direct-connections - std::vector clb_to_clb_directs = alloc_and_load_clb_to_clb_directs(directs, delayless_switch); - std::vector clb2clb_directs; - for (size_t idirect = 0; idirect < directs.size(); ++idirect) { - // Sanity checks on rr switch id - VTR_ASSERT(device_ctx.rr_graph.valid_switch(RRSwitchId(clb_to_clb_directs[idirect].switch_index))); - clb2clb_directs.push_back(clb_to_clb_directs[idirect]); - } + if (crr_opts.sb_maps.empty()) { + // Build the connections tile by tile: + // We classify rr_nodes into a general switch block (GSB) data structure + // where we create edges to each rr_nodes in the GSB with respect to + // Fc_in and Fc_out, switch block patterns + // In addition, we will also handle direct-connections: + // Add edges that bridge OPINs and IPINs to the rr_graph + // Create edges for a tileable rr_graph + build_rr_graph_edges(device_ctx.rr_graph, + device_ctx.rr_graph_builder, + rr_node_driver_switches, + grids, vib_grid, 0, + device_chan_width, + segment_inf, segment_inf_x, segment_inf_y, + Fc_in, Fc_out, + sb_type, Fs, sb_subtype, sub_fs, + perimeter_cb, + opin2all_sides, concat_wire, + wire_opposite_side, + delayless_rr_switch); + + // Build direction connection lists + // TODO: use tile direct builder + // Create data structure of direct-connections + std::vector clb_to_clb_directs = alloc_and_load_clb_to_clb_directs(directs, delayless_switch); + std::vector clb2clb_directs; + for (size_t idirect = 0; idirect < directs.size(); ++idirect) { + // Sanity checks on rr switch id + VTR_ASSERT(device_ctx.rr_graph.valid_switch(RRSwitchId(clb_to_clb_directs[idirect].switch_index))); + clb2clb_directs.push_back(clb_to_clb_directs[idirect]); + } - build_rr_graph_direct_connections(device_ctx.rr_graph, device_ctx.rr_graph_builder, device_ctx.grid, 0, - directs, clb2clb_directs); + build_rr_graph_direct_connections(device_ctx.rr_graph, device_ctx.rr_graph_builder, device_ctx.grid, 0, + directs, clb2clb_directs); + } else { + build_crr_graph_edges(device_ctx.rr_graph, device_ctx.rr_graph_builder, crr_opts, directs); + } // Allocate and load routing resource switches, which are derived from the switches from the architecture file, // based on their fanin in the rr graph. This routine also adjusts the rr nodes to point to these new rr switches From 3f1518bdd587ceaf7206ee726af010dd28396ae0 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 16:16:47 -0700 Subject: [PATCH 012/120] [libs][external] add OpenXLSX to external libs cmake --- libs/EXTERNAL/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/libs/EXTERNAL/CMakeLists.txt b/libs/EXTERNAL/CMakeLists.txt index 816ea7f57c..e34a535936 100644 --- a/libs/EXTERNAL/CMakeLists.txt +++ b/libs/EXTERNAL/CMakeLists.txt @@ -12,6 +12,7 @@ add_subdirectory(libsdcparse) add_subdirectory(libblifparse) add_subdirectory(libtatum) add_subdirectory(libcatch2) +add_subdirectory(OpenXLSX) #add_subdirectory(parmys) #Proc numbers From c8c964e13b01259a6c8f25df8897d89d216e560d Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 14 Oct 2025 16:17:33 -0700 Subject: [PATCH 013/120] [vpr][route][rr_graph] include crr_graph_edge_builder in tileable rr graph builder --- .../tileable_rr_graph/tileable_rr_graph_builder.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp index 787621cbe3..ca80099189 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp @@ -26,6 +26,8 @@ #include "tileable_rr_graph_edge_builder.h" #include "tileable_rr_graph_builder.h" +#include "crr_graph_edge_builder.h" + #include "globals.h" /************************************************************************ @@ -275,7 +277,7 @@ void build_tileable_unidir_rr_graph(const std::vector& typ build_rr_graph_direct_connections(device_ctx.rr_graph, device_ctx.rr_graph_builder, device_ctx.grid, 0, directs, clb2clb_directs); } else { - build_crr_graph_edges(device_ctx.rr_graph, device_ctx.rr_graph_builder, crr_opts, directs); + build_crr_graph_edges(device_ctx.rr_graph, device_ctx.rr_graph_builder, crr_opts); } // Allocate and load routing resource switches, which are derived from the switches from the architecture file, From b19604583aeaa50839cfbb2605e5837b8e428ef8 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 15 Oct 2025 10:45:18 -0700 Subject: [PATCH 014/120] [vpr][route][crr] add df processor --- .../crr_generator/data_frame_processor.cpp | 319 ++++++++++++++++++ .../crr_generator/data_frame_processor.h | 211 ++++++++++++ 2 files changed, 530 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp new file mode 100644 index 0000000000..82a44fb76e --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp @@ -0,0 +1,319 @@ +#include "data_frame_processor.h" + +#include "vtr_log.h" + +#include + +namespace crrgenerator { + +// DataFrame implementation + +DataFrame::DataFrame(size_t rows, size_t cols) : rows_(rows), cols_(cols) { + data_.resize(rows); + for (auto& row : data_) { + row.resize(cols); + } +} + +Cell& DataFrame::at(size_t row, size_t col) { + validate_bounds(row, col); + return data_[row][col]; +} + +const Cell& DataFrame::at(size_t row, size_t col) const { + validate_bounds(row, col); + return data_[row][col]; +} + +void DataFrame::resize(size_t rows, size_t cols) { + rows_ = rows; + cols_ = cols; + data_.resize(rows); + for (auto& row : data_) { + row.resize(cols); + } +} + +void DataFrame::clear() { + data_.clear(); + rows_ = 0; + cols_ = 0; + source_file.clear(); + connections = 0; +} + +std::vector DataFrame::get_row(size_t row) const { + if (row >= rows_) { + VTR_LOG_ERROR("Row index out of range: %zu - max %zu", row, rows_); + } + return data_[row]; +} + +std::vector DataFrame::get_column(size_t col) const { + if (col >= cols_) { + VTR_LOG_ERROR("Column index out of range: %zu - max %zu", col, cols_); + } + + std::vector column; + column.reserve(rows_); + for (size_t row = 0; row < rows_; ++row) { + column.push_back(data_[row][col]); + } + return column; +} + +void DataFrame::set_row(size_t row, const std::vector& values) { + if (row >= rows_) { + VTR_LOG_ERROR("Row index out of range: %zu - max %zu", row, rows_); + } + + for (size_t col = 0; col < std::min(values.size(), cols_); ++col) { + data_[row][col] = values[col]; + } +} + +void DataFrame::set_column(size_t col, const std::vector& values) { + if (col >= cols_) { + VTR_LOG_ERROR("Column index out of range: %zu - max %zu", col, cols_); + } + + for (size_t row = 0; row < std::min(values.size(), rows_); ++row) { + data_[row][col] = values[row]; + } +} + +size_t DataFrame::count_non_empty() const { + size_t count = 0; + for (const auto& row : data_) { + for (const auto& cell : row) { + if (!cell.is_empty()) { + ++count; + } + } + } + return count; +} + +size_t DataFrame::count_non_empty_in_range(size_t start_row, size_t start_col, + size_t end_row, + size_t end_col) const { + size_t count = 0; + for (size_t row = start_row; row < std::min(end_row, rows_); ++row) { + for (size_t col = start_col; col < std::min(end_col, cols_); ++col) { + if (!data_[row][col].is_empty()) { + ++count; + } + } + } + return count; +} + +void DataFrame::validate_bounds(size_t row, size_t col) const { + if (row >= rows_ || col >= cols_) { + VTR_LOG_ERROR("DataFrame index out of range: %zu,%zu - max %zu,%zu", row, col, rows_, cols_); + } +} + +// DataFrameProcessor implementation +DataFrame DataFrameProcessor::read_excel(const std::string& filename) { + + validate_excel_file(filename); + + VTR_LOG_DEBUG("Reading Excel file: %s", filename.c_str()); + + try { + // Open the Excel document + OpenXLSX::XLDocument doc; + doc.open(filename); + + if (!doc.isOpen()) { + VTR_LOG_ERROR("Failed to open Excel file: %s", filename.c_str()); + } + + VTR_LOG_DEBUG("Document %s opened successfully", filename.c_str()); + + // Get the first worksheet + auto workbook = doc.workbook(); + auto worksheet_names = workbook.worksheetNames(); + + if (worksheet_names.empty()) { + VTR_LOG_ERROR("No worksheets found in Excel file: %s", filename.c_str()); + } + + auto worksheet = workbook.worksheet(worksheet_names[0]); + VTR_LOG_DEBUG("Got worksheet: '%s'", worksheet_names[0].c_str()); + + // Get the used range - fix for OpenXLSX API + auto range = worksheet.range(); + size_t last_row = range.numRows(); + size_t last_col = range.numColumns(); + + VTR_LOG_DEBUG("Worksheet dimensions: %zux%zu", last_row, last_col); + + // Safety check + if (last_row > 10000 || last_col > 1000) { + VTR_LOG_ERROR("Excel file too large: %zux%zu (limit: 10000x1000)", + last_row, last_col); + } + + if (last_row == 0 || last_col == 0) { + VTR_LOG_ERROR("Excel file appears to be empty: %s", filename.c_str()); + } + + DataFrame df(last_row, last_col); + VTR_LOG_DEBUG("Created DataFrame with dimensions: %zux%zu", last_row, last_col); + + // Read all cells + VTR_LOG_DEBUG("Reading cell data..."); + size_t cells_read = 0; + + for (size_t row = 1; row <= last_row; ++row) { + for (size_t col = 1; col <= last_col; ++col) { + try { + auto cell = worksheet.cell(row, col); + // Convert cell.value() to XLCellValue and parse it + OpenXLSX::XLCellValue cell_value = cell.value(); + df.at(row - 1, col - 1) = parse_excel_cell(cell_value); + cells_read++; + } catch (const std::exception& e) { + VTR_LOG_DEBUG("Error reading cell (%zu, %zu): %s", row, col, e.what()); + df.at(row - 1, col - 1) = Cell(); // Empty cell + } + } + + // Progress logging for large files + if (row % 100 == 0) { + VTR_LOG_DEBUG("Read %zu rows (%zu cells)", row, cells_read); + } + } + + doc.close(); + + df.source_file = std::filesystem::path(filename).stem().string(); + VTR_LOG_DEBUG("Successfully read Excel file with dimensions: %zux%zu, %zu cells", + df.rows(), df.cols(), cells_read); + + return df; + + } catch (const std::exception& e) { + VTR_LOG_ERROR("Error reading Excel file %s: %s", filename.c_str(), e.what()); + } +} + +DataFrame DataFrameProcessor::process_dataframe(DataFrame df, + int merge_rows_count, + int merge_cols_count) { + VTR_LOG_DEBUG("Processing dataframe with merge_rows=%d, merge_cols=%d", + merge_rows_count, merge_cols_count); + + // Perform row merging + std::vector merged_row_indices = {0, 1}; + merge_rows(df, merged_row_indices); + + // Perform column merging + std::vector merged_col_indices = {2}; + merge_columns(df, merged_col_indices); + + // Count connections in the data area + df.connections = df.count_non_empty_in_range(static_cast(merge_rows_count), + static_cast(merge_cols_count), + df.rows(), + df.cols()); + + VTR_LOG_DEBUG("Processed dataframe with %zu connections", df.connections); + + return df; +} + +void DataFrameProcessor::update_switch_delays(const DataFrame& df, + int& switch_delay_max_ps, + int& switch_delay_min_ps) { + for (size_t col = NUM_EMPTY_COLS; col < df.cols(); ++col) { + for (size_t row = NUM_EMPTY_ROWS; row < df.rows(); ++row) { + const Cell& cell = df.at(row, col); + + if (!cell.is_empty() && cell.is_number()) { + int switch_delay_ps = cell.as_int(); + + if (switch_delay_ps > switch_delay_max_ps) { + switch_delay_max_ps = switch_delay_ps; + } + if (switch_delay_ps < switch_delay_min_ps) { + switch_delay_min_ps = switch_delay_ps; + } + } + } + } + + VTR_LOG_DEBUG("Updated switch delays: min=%d, max=%d", + switch_delay_min_ps, + switch_delay_max_ps); +} + +// Fixed parse_excel_cell to work with XLCellValue +Cell DataFrameProcessor::parse_excel_cell(const OpenXLSX::XLCellValue& cell_value) { + // Get the value type + auto value_type = cell_value.type(); + + switch (value_type) { + case OpenXLSX::XLValueType::Boolean: + return Cell(static_cast(cell_value.get() ? 1 : 0)); + + case OpenXLSX::XLValueType::Integer: + return Cell(static_cast(cell_value.get())); + + case OpenXLSX::XLValueType::Float: + return Cell(cell_value.get()); + + case OpenXLSX::XLValueType::String: { + std::string value = cell_value.get(); + if (value.empty()) { + return Cell(); + } + return Cell(value); + } + case OpenXLSX::XLValueType::Empty: + default: + return Cell(); + } +} + +void DataFrameProcessor::merge_rows(DataFrame& df, const std::vector& merge_row_indices) { + for (const auto& row : merge_row_indices) { + Cell value; + for (size_t col = 0; col < df.cols(); ++col) { + if (!df.at(row, col).is_empty()) { + value = df.at(row, col); + } + df.at(row, col) = value; + } + } +} + +void DataFrameProcessor::merge_columns(DataFrame& df, const std::vector& merge_col_indices) { + for (const auto& col : merge_col_indices) { + Cell value; + for (size_t row = 0; row < df.rows(); ++row) { + if (!df.at(row, col).is_empty()) { + value = df.at(row, col); + } + df.at(row, col) = value; + } + } +} + +void DataFrameProcessor::validate_excel_file(const std::string& filename) { + if (!std::filesystem::exists(filename)) { + VTR_LOG_ERROR("Excel file does not exist: %s", filename.c_str()); + } + + // Check file extension + std::string extension = std::filesystem::path(filename).extension().string(); + std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower); + + if (extension != ".xlsx" && extension != ".xls") { + VTR_LOG_ERROR("Unsupported file format: %s. Expected .xlsx or .xls", extension.c_str()); + } +} + +} // namespace rrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h new file mode 100644 index 0000000000..39cca9f28f --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h @@ -0,0 +1,211 @@ +#pragma once + +#include +#include + +#include "OpenXLSX.hpp" + +#include "common.h" + +namespace crrgenerator { + +constexpr int NUM_EMPTY_ROWS = 5; +constexpr int NUM_EMPTY_COLS = 4; + + +/** + * @brief Represents a cell in the dataframe + */ +struct Cell { + enum class Type { EMPTY, STRING, INTEGER, DOUBLE }; + + Type type = Type::EMPTY; + std::string string_value; + int64_t int_value = 0; + double double_value = 0.0; + + Cell() = default; + explicit Cell(const std::string& value) + : type(Type::STRING), string_value(value) {} + explicit Cell(int64_t value) : type(Type::INTEGER), int_value(value) {} + explicit Cell(double value) : type(Type::DOUBLE), double_value(value) {} + + bool is_empty() const { return type == Type::EMPTY; } + bool is_string() const { return type == Type::STRING; } + bool is_integer() const { return type == Type::INTEGER; } + bool is_double() const { return type == Type::DOUBLE; } + bool is_number() const { return is_integer() || is_double(); } + + int64_t as_int() const { + if (is_integer()) return int_value; + if (is_double()) return static_cast(double_value); + if (is_string()) return std::stoll(string_value); + return 0; + } + + double as_double() const { + if (is_double()) return double_value; + if (is_integer()) return static_cast(int_value); + if (is_string()) return std::stod(string_value); + return 0.0; + } + + std::string as_string() const { + if (is_string()) return string_value; + if (is_integer()) return std::to_string(int_value); + if (is_double()) return std::to_string(double_value); + return ""; + } +}; + +/** + * @brief Simple dataframe implementation for processing Excel data + * + * This class provides pandas-like functionality for processing Excel files + * containing switch block configuration data. + */ +class DataFrame { + public: + DataFrame() = default; + DataFrame(size_t rows, size_t cols); + + // Access methods + Cell& at(size_t row, size_t col); + const Cell& at(size_t row, size_t col) const; + Cell& operator()(size_t row, size_t col) { return at(row, col); } + const Cell& operator()(size_t row, size_t col) const { return at(row, col); } + + // Dimensions + size_t rows() const { return rows_; } + size_t cols() const { return cols_; } + std::pair shape() const { return {rows_, cols_}; } + + // Resize operations + void resize(size_t rows, size_t cols); + void clear(); + + // Row/column operations + std::vector get_row(size_t row) const; + std::vector get_column(size_t col) const; + void set_row(size_t row, const std::vector& values); + void set_column(size_t col, const std::vector& values); + + // Statistics and counting + size_t count_non_empty() const; + size_t count_non_empty_in_range(size_t start_row, size_t start_col, + size_t end_row, size_t end_col) const; + + // Iteration support + class RowIterator { + public: + RowIterator(DataFrame* df, size_t row) : df_(df), row_(row) {} + + Cell& operator[](size_t col) { return df_->at(row_, col); } + const Cell& operator[](size_t col) const { return df_->at(row_, col); } + + size_t size() const { return df_->cols(); } + size_t get_row_index() const { return row_; } + + RowIterator& operator++() { + ++row_; + return *this; + } + bool operator!=(const RowIterator& other) const { + + } + RowIterator& operator*() { return *this; } + + private: + DataFrame* df_; + size_t row_; + }; + + class ConstRowIterator { + public: + ConstRowIterator(const DataFrame* df, size_t row) : df_(df), row_(row) {} + + const Cell& operator[](size_t col) const { return df_->at(row_, col); } + + size_t size() const { return df_->cols(); } + size_t get_row_index() const { return row_; } + + ConstRowIterator& operator++() { + ++row_; + return *this; + } + bool operator!=(const ConstRowIterator& other) const { + return row_ != other.row_; + } + const ConstRowIterator& operator*() const { return *this; } + + private: + const DataFrame* df_; + size_t row_; + }; + + RowIterator begin() { return RowIterator(this, 0); } + RowIterator end() { return RowIterator(this, rows_); } + ConstRowIterator begin() const { return ConstRowIterator(this, 0); } + ConstRowIterator end() const { return ConstRowIterator(this, rows_); } + + // Metadata + std::string source_file; + size_t connections = 0; + + private: + std::vector> data_; + size_t rows_ = 0; + size_t cols_ = 0; + + void validate_bounds(size_t row, size_t col) const; +}; + +/** + * @brief Processes Excel files and converts them to DataFrames + * + * This class handles reading Excel files and performing the cell merging + * operations similar to the Python pandas functionality. + */ +class DataFrameProcessor { + public: + DataFrameProcessor() = default; + + /** + * @brief Read Excel file and create DataFrame + * @param filename Path to Excel file + * @return DataFrame containing the Excel data + * @throws FileException if file cannot be read + */ + DataFrame read_excel(const std::string& filename); + + /** + * @brief Process DataFrame with merging operations + * @param df DataFrame to process + * @param merge_rows_count Number of rows to merge + * @param merge_cols_count Number of columns to merge + * @return Processed DataFrame + */ + DataFrame process_dataframe(DataFrame df, + int merge_rows_count = NUM_EMPTY_ROWS, + int merge_cols_count = NUM_EMPTY_COLS); + + /** + * @brief Update switch delay min/max based on DataFrame content + * @param df DataFrame to analyze + * @param switch_delay_max_ps Current maximum switch delay (will be updated) + * @param switch_delay_min_ps Current minimum switch delay (will be updated) + */ + void update_switch_delays(const DataFrame& df, int& switch_delay_max_ps, + int& switch_delay_min_ps); + + private: + // Excel parsing helpers + Cell parse_excel_cell(const OpenXLSX::XLCellValue& cell_value); + void merge_rows(DataFrame& df, const std::vector& merge_row_indices); + void merge_columns(DataFrame& df, const std::vector& merge_col_indices); + + // Validation + void validate_excel_file(const std::string& filename); +}; + +} // namespace crrgenerator From 9a57b251991fb8d88d5128b5d0bb0757670286ff Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 15 Oct 2025 10:47:13 -0700 Subject: [PATCH 015/120] [vpr][route][crr] add init impl for crr_graph_edge_builder --- .../crr_generator/crr_graph_edge_builder.cpp | 7 +++++++ .../crr_generator/crr_graph_edge_builder.h | 10 ++++++++++ 2 files changed, 17 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp new file mode 100644 index 0000000000..af3ecfa1d8 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp @@ -0,0 +1,7 @@ +#include "crr_graph_edge_builder.h" + +void build_crr_graph_edges(const RRGraphView& rr_graph, + RRGraphBuilder& rr_graph_builder, + const t_crr_opts& crr_opts) { + // TODO: Implement +} \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h new file mode 100644 index 0000000000..bad838bb82 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h @@ -0,0 +1,10 @@ +# pragma once + +#include "vpr_types.h" +#include "rr_graph.h" +#include "rr_graph_view.h" +#include "rr_graph_builder.h" + +void build_crr_graph_edges(const RRGraphView& rr_graph, + RRGraphBuilder& rr_graph_builder, + const t_crr_opts& crr_opts); \ No newline at end of file From 7fa89693db95a7c366670721b76b5478ac884f25 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 15 Oct 2025 12:40:55 -0700 Subject: [PATCH 016/120] [vpr][cmake] add openXLSX --- vpr/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/vpr/CMakeLists.txt b/vpr/CMakeLists.txt index 2a30974832..b8b4dcebac 100644 --- a/vpr/CMakeLists.txt +++ b/vpr/CMakeLists.txt @@ -119,6 +119,7 @@ target_link_libraries(libvpr libpugixml librrgraph ZLIB::ZLIB + OpenXLSX::OpenXLSX ) if(VPR_USE_SERVER) From e7bd77ed6836d023cffc60c4d534fe785d4570ee Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 15 Oct 2025 12:42:12 -0700 Subject: [PATCH 017/120] [vpr][route][rr_graph] fix warnings --- .../tileable_rr_graph/crr_generator/data_frame_processor.cpp | 1 + .../tileable_rr_graph/crr_generator/data_frame_processor.h | 4 +--- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp index 82a44fb76e..4ca38af0fa 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp @@ -197,6 +197,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { } catch (const std::exception& e) { VTR_LOG_ERROR("Error reading Excel file %s: %s", filename.c_str(), e.what()); + return DataFrame(); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h index 39cca9f28f..607952b1fc 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h @@ -5,8 +5,6 @@ #include "OpenXLSX.hpp" -#include "common.h" - namespace crrgenerator { constexpr int NUM_EMPTY_ROWS = 5; @@ -111,7 +109,7 @@ class DataFrame { return *this; } bool operator!=(const RowIterator& other) const { - + return df_ != other.df_ || row_ != other.row_; } RowIterator& operator*() { return *this; } From 1d16bf3b67c76e1279403763e785937f69c2d194 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 15 Oct 2025 12:58:27 -0700 Subject: [PATCH 018/120] [libs][external] add yaml-cpp --- .gitmodules | 3 +++ libs/EXTERNAL/yaml-cpp | 1 + 2 files changed, 4 insertions(+) create mode 160000 libs/EXTERNAL/yaml-cpp diff --git a/.gitmodules b/.gitmodules index 849f8ebca6..6c25b9bc47 100644 --- a/.gitmodules +++ b/.gitmodules @@ -19,3 +19,6 @@ [submodule "libs/EXTERNAL/OpenXLSX"] path = libs/EXTERNAL/OpenXLSX url = https://github.com/troldal/OpenXLSX.git +[submodule "libs/EXTERNAL/yaml-cpp"] + path = libs/EXTERNAL/yaml-cpp + url = https://github.com/jbeder/yaml-cpp.git diff --git a/libs/EXTERNAL/yaml-cpp b/libs/EXTERNAL/yaml-cpp new file mode 160000 index 0000000000..a83cd31548 --- /dev/null +++ b/libs/EXTERNAL/yaml-cpp @@ -0,0 +1 @@ +Subproject commit a83cd31548b19d50f3f983b069dceb4f4d50756d From afe9b9c64bd10c47df6fddc1851f7ed4f9e18f70 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 15 Oct 2025 13:02:05 -0700 Subject: [PATCH 019/120] [cmake] add yaml-cpp to cmake files --- libs/EXTERNAL/CMakeLists.txt | 1 + vpr/CMakeLists.txt | 1 + 2 files changed, 2 insertions(+) diff --git a/libs/EXTERNAL/CMakeLists.txt b/libs/EXTERNAL/CMakeLists.txt index e34a535936..deaafd4fa4 100644 --- a/libs/EXTERNAL/CMakeLists.txt +++ b/libs/EXTERNAL/CMakeLists.txt @@ -13,6 +13,7 @@ add_subdirectory(libblifparse) add_subdirectory(libtatum) add_subdirectory(libcatch2) add_subdirectory(OpenXLSX) +add_subdirectory(yaml-cpp) #add_subdirectory(parmys) #Proc numbers diff --git a/vpr/CMakeLists.txt b/vpr/CMakeLists.txt index b8b4dcebac..44d485fa4f 100644 --- a/vpr/CMakeLists.txt +++ b/vpr/CMakeLists.txt @@ -120,6 +120,7 @@ target_link_libraries(libvpr librrgraph ZLIB::ZLIB OpenXLSX::OpenXLSX + yaml-cpp::yaml-cpp ) if(VPR_USE_SERVER) From 2f361fd401a82ababe629959154b2551c97c6661 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 06:53:29 -0700 Subject: [PATCH 020/120] [crr][switch_block_manager] add header file --- .../crr_generator/crr_switch_block_manager.h | 116 ++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h new file mode 100644 index 0000000000..fb06a6bfe1 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h @@ -0,0 +1,116 @@ +#pragma once + +#include + +#include "common.h" +#include "data_frame_processor.h" + +namespace crrgenerator { + +/** + * @brief Manages switch block configurations and Excel file processing + * + * This class handles reading YAML configuration files, processing Excel files + * containing switch block data, and managing switch block patterns. + */ +class SwitchBlockManager { +public: + SwitchBlockManager(); + + /** + * @brief Initialize the manager with configuration file + * @param sb_maps_file Path to the YAML configuration file + * @param sb_annotated_dir Directory containing Excel files + * @param is_annotated_excel Whether the switches are annotated in Excel + */ + void initialize(const std::string& sb_maps_file, + const std::string& sb_annotated_dir, + const bool is_annotated_excel); + + /** + * @brief Get DataFrame for a specific switch block pattern + * @param pattern Switch block pattern name (e.g., "SB_1__2_") + * @return Pointer to DataFrame or nullptr if not found + */ + const DataFrame* get_switch_block_dataframe(const std::string& pattern) const; + + /** + * @brief Check if a pattern exists in the switch block mapping + * @param pattern Pattern to check + * @return true if pattern exists + */ + bool has_pattern(const std::string& pattern) const; + + /** + * @brief Get all available patterns + * @return Vector of all pattern names + */ + std::vector get_all_patterns() const; + + /** + * @brief Find the first matching pattern in switch mapping file + * for a switch block name + * @param sw_name Switch block name to match + * @return Matching pattern or empty string if no match + */ + std::string find_matching_pattern(const std::string& sw_name) const; + + /** + * @brief Print statistics about loaded switch blocks + */ + void print_statistics() const; + + /** + * @brief Get the total number of connections across all switch blocks + * @return Total connection count + */ + size_t get_total_connections() const; + + /** + * @brief Get the maximum switch delay in picoseconds + * @return Maximum switch delay in picoseconds + */ + int get_max_switch_delay_ps() const { return switch_delay_max_ps_; } + + /** + * @brief Get the minimum switch delay in picoseconds + * @return Minimum switch delay in picoseconds + */ + int get_min_switch_delay_ps() const { return switch_delay_min_ps_; } + +private: + /** + * @brief Ordered list of switch block patterns + * + * We need to store the switch blocks in the same order defined in the YAML + * file. Later, if a switch block match to multiple patterns defined in the + * YAML file, the pattern defined earliest in the list will be used. + */ + std::vector ordered_switch_block_patterns_; + std::unordered_map switch_block_to_file_; + std::unordered_map dataframes_; + std::unordered_map file_cache_; + + // Global switch delay range + int switch_delay_max_ps_; + int switch_delay_min_ps_; + + DataFrameProcessor processor_; + std::string annotated_dir_; + + // File processing + void load_excel_file(const std::string& pattern, + const std::string& excel_file); + + /** + * @brief Update global switch delay ranges based on all loaded DataFrames + * @param is_annotated_excel Whether the switches are annotated in Excel + */ + void update_and_set_global_switch_delays(const bool is_annotated_excel); + + // Validation + void validate_yaml_structure(const YAML::Node& root); + void validate_excel_files(); +}; + +} // namespace crrgenerator From 7ea77407a04269471d347e2c5a5a67ae531bce9d Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 07:52:19 -0700 Subject: [PATCH 021/120] [vpr][route][crr] add pattern matcher --- .../tileable_rr_graph/crr_generator/pattern_matcher.h | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/pattern_matcher.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/pattern_matcher.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/pattern_matcher.h new file mode 100644 index 0000000000..e69de29bb2 From d2b81e6dcb6af4c58c2dcb217a824f7152877635 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 07:54:40 -0700 Subject: [PATCH 022/120] [vpr][route][crr][switch_block_manager] add missing libs --- .../crr_generator/crr_switch_block_manager.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h index fb06a6bfe1..d39730657b 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h @@ -1,8 +1,10 @@ #pragma once +#include +#include + #include -#include "common.h" #include "data_frame_processor.h" namespace crrgenerator { From 6a056264498ab6ef705044850a54f205ef4b23e1 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 08:03:56 -0700 Subject: [PATCH 023/120] [vpr][route][crr] rename pattern_match to crr_pattern_matcher --- .../crr_generator/crr_pattern_matcher.h | 169 ++++++++++++++++++ .../crr_generator/pattern_matcher.h | 0 2 files changed, 169 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h delete mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/pattern_matcher.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h new file mode 100644 index 0000000000..722264f899 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h @@ -0,0 +1,169 @@ +#include +#include +#include +#include +#include + +namespace crrgenerator { + +class PatternMatcher { +private: + // Helper function to parse range [start:end:step] or comma-separated values [7,20] + static bool matches_range(int value, const std::string& range_str) { + // Extract numbers from [start:end:step] or [7,20] format + size_t start_pos = range_str.find('['); + size_t end_pos = range_str.find(']'); + if (start_pos == std::string::npos || end_pos == std::string::npos) { + return false; + } + + std::string range_content = range_str.substr(start_pos + 1, end_pos - start_pos - 1); + + // Check if it's comma-separated values (e.g., [7,20]) + if (range_content.find(',') != std::string::npos) { + // Parse comma-separated values + std::vector values; + size_t pos = 0; + size_t comma_pos; + + while ((comma_pos = range_content.find(',', pos)) != std::string::npos) { + values.push_back(std::stoi(range_content.substr(pos, comma_pos - pos))); + pos = comma_pos + 1; + } + values.push_back(std::stoi(range_content.substr(pos))); + + // Check if value is in the list + return std::find(values.begin(), values.end(), value) != values.end(); + } + // Check if it's range notation (e.g., [2:32:3]) + else if (range_content.find(':') != std::string::npos) { + // Parse start:end:step + std::vector parts; + size_t pos = 0; + size_t colon_pos; + + while ((colon_pos = range_content.find(':', pos)) != std::string::npos) { + parts.push_back(std::stoi(range_content.substr(pos, colon_pos - pos))); + pos = colon_pos + 1; + } + parts.push_back(std::stoi(range_content.substr(pos))); + + if (parts.size() != 3) return false; + + int start = parts[0]; + int end = parts[1]; // end is NOT exclusive as per your specification + int step = parts[2]; + + if (value < start || value > end) return false; + if ((value - start) % step != 0) return false; + + return true; + } + // Single value (e.g., [5]) + else { + int single_value = std::stoi(range_content); + return value == single_value; + } + } + + // Convert pattern to regex, handling * and [start:end:step] ranges + static std::string pattern_to_regex(const std::string& pattern) { + std::string regex_pattern = "^"; + + for (size_t i = 0; i < pattern.length(); ++i) { + char c = pattern[i]; + + if (c == '*') { + regex_pattern += "([0-9]+)"; // Capture group for numbers + } + else if (c == '[') { + // Find the matching closing bracket + size_t close_bracket = pattern.find(']', i); + if (close_bracket != std::string::npos) { + std::string range = pattern.substr(i, close_bracket - i + 1); + regex_pattern += "([0-9]+)"; // Capture the number, validate range later + i = close_bracket; // Skip to after the closing bracket + } + else { + regex_pattern += "\\["; // Literal bracket if no closing bracket found + } + } + else if (c == '\\' && i + 1 < pattern.length() && pattern[i + 1] == '*') { + // Handle escaped asterisk - treat as literal * + regex_pattern += "\\*"; + ++i; // Skip the next character + } + else { + // Escape regex special characters + if (c == '.' || c == '^' || c == '$' || c == '+' || c == '?' || + c == '(' || c == ')' || c == '|' || c == '{' || c == '}') { + regex_pattern += "\\"; + } + regex_pattern += c; + } + } + + regex_pattern += "$"; + return regex_pattern; + } + +public: + static bool matches_pattern(const std::string& name, const std::string& pattern) { + // Fast path for exact matches (no wildcards or ranges) + if (pattern.find('*') == std::string::npos && + pattern.find('[') == std::string::npos && + pattern.find('\\') == std::string::npos) { + return name == pattern; + } + + // Compile regex for this pattern + std::string regex_str = pattern_to_regex(pattern); + std::regex compiled_regex(regex_str); + + std::smatch matches; + if (!std::regex_match(name, matches, compiled_regex)) { + return false; + } + + // Now validate any range constraints + std::vector captured_numbers; + for (size_t i = 1; i < matches.size(); ++i) { + captured_numbers.push_back(matches[i].str()); + } + + // Parse pattern again to find ranges and validate them + size_t capture_index = 0; + for (size_t i = 0; i < pattern.length(); ++i) { + char c = pattern[i]; + + if (c == '*') { + // Simple wildcard, no validation needed + ++capture_index; + } + else if (c == '[') { + // Find the matching closing bracket + size_t close_bracket = pattern.find(']', i); + if (close_bracket != std::string::npos) { + std::string range = pattern.substr(i, close_bracket - i + 1); + + if (capture_index < captured_numbers.size()) { + int captured_value = std::stoi(captured_numbers[capture_index]); + if (!matches_range(captured_value, range)) { + return false; + } + } + + ++capture_index; + i = close_bracket; // Skip to after the closing bracket + } + } + else if (c == '\\' && i + 1 < pattern.length() && pattern[i + 1] == '*') { + ++i; // Skip escaped asterisk + } + } + + return true; + } +}; + +} // namespace crrgenerator \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/pattern_matcher.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/pattern_matcher.h deleted file mode 100644 index e69de29bb2..0000000000 From 7343fcec6d5b8bb97b7965d6e6e7b873ed017bb3 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 08:07:03 -0700 Subject: [PATCH 024/120] [vpr][route][crr] add switch block mng impl --- .../crr_switch_block_manager.cpp | 183 ++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp new file mode 100644 index 0000000000..a0f26f0d21 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp @@ -0,0 +1,183 @@ +#include + +#include +#include + +#include + +#include "crr_switch_block_manager.h" +#include "crr_pattern_matcher.h" + +#include "vtr_log.h" + +namespace crrgenerator { + +SwitchBlockManager::SwitchBlockManager() = default; + +void SwitchBlockManager::initialize(const std::string& sb_maps_file, + const std::string& sb_annotated_dir, + const bool is_annotated_excel) { + VTR_LOG("Initializing SwitchBlockManager with maps file: %s\n", sb_maps_file.c_str()); + + annotated_dir_ = sb_annotated_dir; + + // Load YAML configuration + try { + YAML::Node config = YAML::LoadFile(sb_maps_file); + validate_yaml_structure(config); + + if (!config["SB_MAPS"]) { + VTR_LOG_ERROR("SB_MAPS section not found in YAML file\n"); + } + + YAML::Node sb_maps = config["SB_MAPS"]; + VTR_LOGV_DEBUG("Found SB_MAPS section with %zu entries\n", sb_maps.size()); + + // Process each switch block mapping + std::unordered_set unique_files; + for (const auto& item : sb_maps) { + std::string pattern = item.first.as(); + + std::string excel_file = item.second.as(); + if (item.second.IsNull()) { + excel_file = ""; + } + + std::string full_path = std::filesystem::path(annotated_dir_) / excel_file; + if (excel_file.empty()) { + full_path = ""; + } + + // Handle escaped asterisks (replace \* with *) + std::regex escaped_asterisk(R"(\\\*)"); + pattern = std::regex_replace(pattern, escaped_asterisk, "*"); + + ordered_switch_block_patterns_.push_back(pattern); + switch_block_to_file_[pattern] = full_path; + if (!full_path.empty()) { + unique_files.insert(full_path); + } + } + + for (const auto& full_path : unique_files) { + if (std::filesystem::exists(full_path)) { + try { + VTR_LOGV_DEBUG("Attempting to read Excel file: %s\n", full_path.c_str()); + DataFrame df = processor_.read_excel(full_path); + df = processor_.process_dataframe(std::move(df), NUM_EMPTY_ROWS, + NUM_EMPTY_COLS); + file_cache_[full_path] = std::move(df); + VTR_LOGV_DEBUG("Processed %zu connections in %s file\n", + file_cache_[full_path].connections, + std::filesystem::path(full_path).filename().string()); + } catch (const std::exception& e) { + VTR_LOG_ERROR("Failed to read required Excel file '%s': %s\n", full_path.c_str(), e.what()); + } + } else { + VTR_LOG_ERROR("Required Excel file not found: %s\n", full_path.c_str()); + } + } + + // Map patterns to loaded DataFrames + for (const auto& [pattern, full_path] : switch_block_to_file_) { + if (file_cache_.find(full_path) != file_cache_.end()) { + dataframes_[pattern] = &file_cache_[full_path]; + } + } + + update_and_set_global_switch_delays(is_annotated_excel); + + print_statistics(); + } catch (const YAML::Exception& e) { + VTR_LOG_ERROR("Failed to parse YAML file %s: %s\n", sb_maps_file.c_str(), e.what()); + } catch (const std::exception& e) { + VTR_LOG_ERROR("Failed to initialize SwitchBlockManager: %s\n", e.what()); + } +} + +const DataFrame* SwitchBlockManager::get_switch_block_dataframe(const std::string& pattern) const { + auto it = dataframes_.find(pattern); + return (it != dataframes_.end()) ? it->second : nullptr; +} + +bool SwitchBlockManager::has_pattern(const std::string& pattern) const { + return dataframes_.find(pattern) != dataframes_.end(); +} + +std::vector SwitchBlockManager::get_all_patterns() const { + std::vector patterns; + patterns.reserve(dataframes_.size()); + + for (const auto& [pattern, _] : dataframes_) { + patterns.push_back(pattern); + } + + return patterns; +} + +std::string SwitchBlockManager::find_matching_pattern(const std::string& sw_name) const { + for (const auto& pattern : ordered_switch_block_patterns_) { + if (PatternMatcher::matches_pattern(sw_name, pattern)) { + return pattern; + } + } + return ""; +} + +void SwitchBlockManager::update_and_set_global_switch_delays(const bool is_annotated_excel) { + if (is_annotated_excel) { + int switch_delay_max_ps = std::numeric_limits::min(); + int switch_delay_min_ps = std::numeric_limits::max(); + for (const auto& [pattern, df] : dataframes_) { + processor_.update_switch_delays(*df, switch_delay_max_ps, + switch_delay_min_ps); + } + + switch_delay_max_ps_ = switch_delay_max_ps; + switch_delay_min_ps_ = switch_delay_min_ps; + } else { + switch_delay_max_ps_ = 1000; + switch_delay_min_ps_ = 1; + } + + VTR_LOG("Global switch delay range updated: %d - %d\n", switch_delay_min_ps_, switch_delay_max_ps_); +} + +void SwitchBlockManager::print_statistics() const { + VTR_LOG("=== CRR Generator Switch Block Manager Statistics ===\n"); + VTR_LOG("Patterns loaded: %zu\n", dataframes_.size()); + VTR_LOG("Unique Excel files: %zu\n", file_cache_.size()); + VTR_LOG("Total connections: %zu\n", get_total_connections()); + VTR_LOG("Switch delay range: %d - %d\n", switch_delay_min_ps_, switch_delay_max_ps_); + + // Print file details + for (const auto& [file, df] : file_cache_) { + VTR_LOG(" %s: %zu connections (%zux%zu)\n", + std::filesystem::path(file).filename().string(), + df.connections, df.rows(), df.cols()); + } +} + +size_t SwitchBlockManager::get_total_connections() const { + size_t total = 0; + for (const auto& [file, df] : file_cache_) { + total += df.connections; + } + return total; +} + +void SwitchBlockManager::validate_yaml_structure(const YAML::Node& root) { + if (!root.IsMap()) { + VTR_LOG_ERROR("YAML root must be a map\n"); + } + + if (!root["SB_MAPS"]) { + VTR_LOG_ERROR("Required 'SB_MAPS' section not found in YAML\n"); + } + + if (!root["SB_MAPS"].IsMap()) { + VTR_LOG_ERROR("'SB_MAPS' must be a map\n"); + } +} + +} // namespace crrgenerator From 7c0372150ba3afe086901e516dcf49ad3b3c6df1 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 09:05:10 -0700 Subject: [PATCH 025/120] [vpr][route][crr] add crr.h/cpp --- .../crr_generator/custom_rr_graph.cpp | 248 +++++++++ .../crr_generator/custom_rr_graph.h | 498 ++++++++++++++++++ 2 files changed, 746 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp new file mode 100644 index 0000000000..18546ce5fa --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp @@ -0,0 +1,248 @@ +#include "custom_rr_graph.h" + +#include "vtr_log.h" + +namespace crrgenerator { + +// RRGraph implementation + +void RRGraph::add_node(const RRNode& node) { + nodes_.push_back(node); + update_node_index(node.get_id(), nodes_.size() - 1); +} + +void RRGraph::add_node(NodeId id, NodeType type, int capacity, + const std::string& direction, const Location& location, + const NodeTiming& timing, const NodeSegmentId& segment_id) { + add_node(RRNode(id, type, capacity, direction, location, timing, segment_id)); +} + +const RRNode* RRGraph::get_node(NodeId id) const { + auto it = node_id_to_index_.find(id); + return (it != node_id_to_index_.end()) ? &nodes_[it->second] : nullptr; +} + +RRNode* RRGraph::get_node(NodeId id) { + auto it = node_id_to_index_.find(id); + return (it != node_id_to_index_.end()) ? &nodes_[it->second] : nullptr; +} + +void RRGraph::add_edge(const RREdge& edge) { edges_.push_back(edge); } + +void RRGraph::add_edge(NodeId src_node, NodeId sink_node, SwitchId switch_id) { + add_edge(RREdge(src_node, sink_node, switch_id)); +} + +void RRGraph::add_channel(const Channel& channel) { + channels_.push_back(channel); +} + +void RRGraph::add_channel(int max_width, int x_max, int x_min, int y_max, + int y_min) { + add_channel(Channel(max_width, x_max, x_min, y_max, y_min)); +} + +void RRGraph::add_xy_list(const XYList& xy_list) { + xy_lists_.push_back(xy_list); +} + +void RRGraph::add_xy_list(XYList::Type type, int index, int info) { + add_xy_list(XYList(type, index, info)); +} + +void RRGraph::add_switch(const Switch& switch_obj) { + switches_.push_back(switch_obj); + update_switch_index(switch_obj.get_id(), switches_.size() - 1); +} + +void RRGraph::add_switch(SwitchId id, const std::string& name, + const std::string& type, const Timing& timing, + const Sizing& sizing) { + add_switch(Switch(id, name, type, timing, sizing)); +} + +const Switch* RRGraph::get_switch(SwitchId id) const { + auto it = switch_id_to_index_.find(id); + return (it != switch_id_to_index_.end()) ? &switches_[it->second] : nullptr; +} + +Switch* RRGraph::get_switch(SwitchId id) { + auto it = switch_id_to_index_.find(id); + return (it != switch_id_to_index_.end()) ? &switches_[it->second] : nullptr; +} + +void RRGraph::add_segment(const Segment& segment) { + segments_.push_back(segment); + update_segment_index(segment.get_id(), segments_.size() - 1); +} + +void RRGraph::add_segment(SegmentId id, const std::string& name, int length, + const std::string& res_type) { + add_segment(Segment(id, name, length, res_type)); +} + +const Segment* RRGraph::get_segment(SegmentId id) const { + auto it = segment_id_to_index_.find(id); + return (it != segment_id_to_index_.end()) ? &segments_[it->second] : nullptr; +} + +void RRGraph::add_block_type(const BlockType& block_type) { + block_types_.push_back(block_type); +} + +void RRGraph::add_block_type(int id, const std::string& name, int height, + int width, + const std::vector& pin_classes) { + add_block_type(BlockType(id, name, height, width, pin_classes)); +} + +void RRGraph::add_grid_loc(const GridLoc& grid_loc) { + grid_locs_.push_back(grid_loc); +} + +void RRGraph::add_grid_loc(int type_id, int height_offset, int width_offset, + int x, int y, int layer) { + add_grid_loc(GridLoc(type_id, height_offset, width_offset, x, y, layer)); +} + +void RRGraph::clear() { + nodes_.clear(); + edges_.clear(); + switches_.clear(); + segments_.clear(); + node_id_to_index_.clear(); + switch_id_to_index_.clear(); + segment_id_to_index_.clear(); + tool_name_.clear(); + tool_version_.clear(); + tool_comment_.clear(); +} + +void RRGraph::print_statistics() const { + VTR_LOG("=== CRR Generator RR Graph Statistics ===\n"); + VTR_LOG("Nodes: %zu\n", nodes_.size()); + VTR_LOG("Edges: %zu\n", edges_.size()); + VTR_LOG("Switches: %zu\n", switches_.size()); + VTR_LOG("Segments: %zu\n", segments_.size()); + + // Count nodes by type + std::map type_counts; + for (const auto& node : nodes_) { + type_counts[node.get_type()]++; + } + + for (const auto& [type, count] : type_counts) { + VTR_LOG(" %s nodes: %zu\n", to_string(type), count); + } + + VTR_LOG("Tool: %s v%s\n", tool_name_.c_str(), tool_version_.c_str()); + if (!tool_comment_.empty()) { + VTR_LOG("Comment: %s\n", tool_comment_.c_str()); + } +} + +std::vector RRGraph::get_nodes_by_type(NodeType type) const { + std::vector result; + for (const auto& node : nodes_) { + if (node.get_type() == type) { + result.push_back(node.get_id()); + } + } + return result; +} + +std::unordered_set RRGraph::get_source_nodes() const { + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::SOURCE) { + result.insert(node.get_id()); + } + } + return result; +} + +std::unordered_set RRGraph::get_sink_nodes() const { + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::SINK) { + result.insert(node.get_id()); + } + } + return result; +} + +std::unordered_set RRGraph::get_ipin_nodes() const { + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::IPIN) { + result.insert(node.get_id()); + } + } + return result; +} + +std::unordered_set RRGraph::get_opin_nodes() const { + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::OPIN) { + result.insert(node.get_id()); + } + } + return result; +} + +std::vector RRGraph::get_preserved_edges( + const bool preserve_ipin_connections, + const bool preserve_opin_connections) const { + std::vector result; + auto source_nodes = get_source_nodes(); + auto sink_nodes = get_sink_nodes(); + auto ipin_nodes = get_ipin_nodes(); + auto opin_nodes = get_opin_nodes(); + for (const auto& edge : edges_) { + auto edge_src_node = edge.get_src_node(); + auto edge_sink_node = edge.get_sink_node(); + if (source_nodes.find(edge_src_node) != source_nodes.end() || + sink_nodes.find(edge_sink_node) != sink_nodes.end() || + (opin_nodes.find(edge_src_node) != opin_nodes.end() && + ipin_nodes.find(edge_sink_node) != ipin_nodes.end())) { + result.push_back(edge); + } else { + if (preserve_ipin_connections && + ipin_nodes.find(edge_sink_node) != ipin_nodes.end()) { + result.push_back(edge); + } + + if (preserve_opin_connections && + opin_nodes.find(edge_src_node) != opin_nodes.end()) { + result.push_back(edge); + } + } + } + + // Remove duplicate edges + std::sort(result.begin(), result.end()); + result.erase(std::unique(result.begin(), result.end()), result.end()); + return result; +} + +void RRGraph::set_tool_info(const std::string& name, const std::string& version, + const std::string& comment) { + tool_name_ = name; + tool_version_ = version; + tool_comment_ = comment; +} + +void RRGraph::update_node_index(NodeId id, size_t index) { + node_id_to_index_[id] = index; +} + +void RRGraph::update_switch_index(SwitchId id, size_t index) { + switch_id_to_index_[id] = index; +} + +void RRGraph::update_segment_index(SegmentId id, size_t index) { + segment_id_to_index_[id] = index; +} + +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h new file mode 100644 index 0000000000..19553c72a1 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h @@ -0,0 +1,498 @@ +#pragma once + +#include "crr_common.h" + +namespace crrgenerator { + +/** + * @brief Represents a routing resource node in the FPGA + */ +class RRNode { + public: + RRNode() = default; + RRNode(NodeId id, NodeType type, int capacity, const std::string& direction, + const Location& location, const NodeTiming& timing, + const NodeSegmentId& segment_id) + : id_(id), + type_(type), + capacity_(capacity), + direction_(direction), + location_(location), + timing_(timing), + segment_id_(segment_id) {} + + // Getters + NodeId get_id() const { return id_; } + NodeType get_type() const { return type_; } + int get_capacity() const { return capacity_; } + const std::string& get_direction() const { return direction_; } + const Location& get_location() const { return location_; } + const std::string& get_ptc() const { return location_.ptc; } + const NodeTiming& get_timing() const { return timing_; } + const NodeSegmentId& get_segment() const { return segment_id_; } + + // Setters + void set_id(NodeId id) { id_ = id; } + void set_type(NodeType type) { type_ = type; } + void set_capacity(int capacity) { capacity_ = capacity; } + void set_direction(const std::string& direction) { direction_ = direction; } + void set_location(const Location& location) { location_ = location; } + void set_timing(const NodeTiming& timing) { timing_ = timing; } + void set_segment(const NodeSegmentId& segment_id) { segment_id_ = segment_id; } + + // Utility methods + NodeHash get_hash() const { + return std::make_tuple(type_, location_.ptc, location_.x_low, + location_.x_high, location_.y_low, location_.y_high); + } + + bool is_single_coordinate() const { + return (location_.x_low == location_.x_high) && + (location_.y_low == location_.y_high); + } + + bool operator<(const RRNode& other) const { + return id_ < other.id_; + } + + bool operator==(const RRNode& other) const { + return id_ == other.id_; + } + + private: + NodeId id_{0}; + NodeType type_{NodeType::INVALID}; + int capacity_{-1}; + std::string direction_; + Location location_; + NodeTiming timing_; + NodeSegmentId segment_id_; +}; + +/** + * @brief Represents a routing edge connecting two nodes + */ +class RREdge { + public: + RREdge() = default; + RREdge(NodeId src_node, NodeId sink_node, SwitchId switch_id) + : src_node_(src_node), sink_node_(sink_node), switch_id_(switch_id) {} + + // Getters + NodeId get_src_node() const { return src_node_; } + NodeId get_sink_node() const { return sink_node_; } + SwitchId get_switch_id() const { return switch_id_; } + + // Setters + void set_src_node(NodeId node) { src_node_ = node; } + void set_sink_node(NodeId node) { sink_node_ = node; } + void set_switch_id(SwitchId id) { switch_id_ = id; } + + bool operator<(const RREdge& other) const { + return std::tie(src_node_, sink_node_, switch_id_) < + std::tie(other.src_node_, other.sink_node_, other.switch_id_); + } + + bool operator==(const RREdge& other) const { + return src_node_ == other.src_node_ && sink_node_ == other.sink_node_ && + switch_id_ == other.switch_id_; + } + + private: + NodeId src_node_{0}; + NodeId sink_node_{0}; + SwitchId switch_id_{0}; +}; + +/** + * @brief Represents a list of X or Y coordinates + */ +class XYList { + public: + enum class Type { X_LIST, Y_LIST, INVALID_LIST }; + + XYList() = default; + XYList(Type type, int index, int info) + : type_(type), index_(index), info_(info) {} + + // Getters + Type get_type() const { return type_; } + int get_index() const { return index_; } + int get_info() const { return info_; } + + // Setters + void set_type(Type type) { type_ = type; } + void set_index(int index) { index_ = index; } + void set_info(int info) { info_ = info; } + + private: + Type type_{Type::INVALID_LIST}; + int index_{-1}; + int info_{-1}; +}; + +/** + * @brief Represents a channel in the FPGA + */ +class Channel { + public: + Channel() = default; + Channel(int max_width, int x_max, int x_min, int y_max, int y_min) + : max_width_(max_width), + x_max_(x_max), + x_min_(x_min), + y_max_(y_max), + y_min_(y_min) {} + + // Getters + int get_max_width() const { return max_width_; } + int get_x_max() const { return x_max_; } + int get_x_min() const { return x_min_; } + int get_y_max() const { return y_max_; } + int get_y_min() const { return y_min_; } + + // Setters + void set_max_width(int max_width) { max_width_ = max_width; } + void set_x_max(int x_max) { x_max_ = x_max; } + void set_x_min(int x_min) { x_min_ = x_min; } + void set_y_max(int y_max) { y_max_ = y_max; } + void set_y_min(int y_min) { y_min_ = y_min; } + + private: + int max_width_{-1}; + int x_max_{-1}; + int x_min_{-1}; + int y_max_{-1}; + int y_min_{-1}; +}; + +/** + * @brief Represents a pin in the FPGA + */ +class Pin { + public: + Pin() = default; + Pin(const int ptc, const std::string& value) : ptc_(ptc), value_(value) {} + + // Getters + int get_ptc() const { return ptc_; } + std::string get_value() const { return value_; } + + // Setters + void set_ptc(const int ptc) { ptc_ = ptc; } + void set_value(const std::string& value) { value_ = value; } + + private: + int ptc_; + std::string value_; +}; + +/** + * @brief Represents a pin class in the FPGA + */ +class PinClass { + public: + PinClass() = default; + PinClass(const std::string& type, const std::vector& pins) + : type_(type), pins_(pins) {} + + // Getters + const std::string& get_type() const { return type_; } + const std::vector& get_pins() const { return pins_; } + + // Setters + void set_type(const std::string& type) { type_ = type; } + void set_pins(const std::vector& pins) { pins_ = pins; } + + private: + std::string type_; + std::vector pins_; +}; + +/** + * @brief Represents a block type in the FPGA + */ +class BlockType { + public: + BlockType() = default; + BlockType(int id, const std::string& name, int height, int width, + const std::vector& pin_classes) + : id_(id), + name_(name), + height_(height), + width_(width), + pin_classes_(pin_classes) {} + + // Getters + int get_id() const { return id_; } + const std::string& get_name() const { return name_; } + int get_height() const { return height_; } + int get_width() const { return width_; } + const std::vector& get_pin_classes() const { return pin_classes_; } + // Setters + void set_id(int id) { id_ = id; } + void set_name(const std::string& name) { name_ = name; } + void set_height(int height) { height_ = height; } + void set_width(int width) { width_ = width; } + void set_pin_classes(const std::vector& pin_classes) { + pin_classes_ = pin_classes; + } + + private: + int id_{-1}; + std::string name_; + int height_{-1}; + int width_{-1}; + std::vector pin_classes_; +}; + +/** + * @brief Represents a grid in the FPGA + */ +class GridLoc { + public: + GridLoc() = default; + GridLoc(int type_id, int height_offset, int width_offset, int x, int y, + int layer) + : type_id_(type_id), + height_offset_(height_offset), + width_offset_(width_offset), + x_(x), + y_(y), + layer_(layer) {} + + // Getters + int get_type_id() const { return type_id_; } + int get_height_offset() const { return height_offset_; } + int get_width_offset() const { return width_offset_; } + int get_x() const { return x_; } + int get_y() const { return y_; } + int get_layer() const { return layer_; } + + // Setters + void set_type_id(int type_id) { type_id_ = type_id; } + void set_height_offset(int height_offset) { height_offset_ = height_offset; } + void set_width_offset(int width_offset) { width_offset_ = width_offset; } + void set_x(int x) { x_ = x; } + void set_y(int y) { y_ = y; } + void set_layer(int layer) { layer_ = layer; } + + private: + int type_id_{-1}; + int height_offset_{-1}; + int width_offset_{-1}; + int x_{-1}; + int y_{-1}; + int layer_{-1}; +}; + +/** + * @brief Represents a switch with timing and sizing information + */ +class Switch { + public: + Switch() = default; + Switch(SwitchId id, const std::string& name, const std::string& type, + const Timing& timing, const Sizing& sizing) + : id_(id), name_(name), type_(type), timing_(timing), sizing_(sizing) {} + + // Getters + SwitchId get_id() const { return id_; } + const std::string& get_name() const { return name_; } + const std::string& get_type() const { return type_; } + const Timing& get_timing() const { return timing_; } + const Sizing& get_sizing() const { return sizing_; } + + // Setters + void set_id(SwitchId id) { id_ = id; } + void set_name(const std::string& name) { name_ = name; } + void set_type(const std::string& type) { type_ = type; } + void set_timing(const Timing& timing) { timing_ = timing; } + void set_sizing(const Sizing& sizing) { sizing_ = sizing; } + + private: + SwitchId id_{0}; + std::string name_; + std::string type_; + Timing timing_; + Sizing sizing_; +}; + +/** + * @brief Represents a wire segment + */ +class Segment { + public: + Segment() = default; + Segment(SegmentId id, const std::string& name, int length, + const std::string& res_type) + : id_(id), name_(name), length_(length), res_type_(res_type) {} + + // Getters + SegmentId get_id() const { return id_; } + const std::string& get_name() const { return name_; } + int get_length() const { return length_; } + const std::string& get_res_type() const { return res_type_; } + // Setters + void set_id(SegmentId id) { id_ = id; } + void set_name(const std::string& name) { name_ = name; } + void set_length(int length) { length_ = length; } + void set_res_type(const std::string& res_type) { res_type_ = res_type; } + + private: + SegmentId id_{0}; + std::string name_; + int length_{-1}; + std::string res_type_; +}; + +/** + * @brief Main routing resource graph class + * + * This class contains all nodes, edges, switches, and segments that make up + * the FPGA routing resource graph. + */ +class RRGraph { + public: + RRGraph() = default; + + // Node management + void add_node(const RRNode& node); + void add_node(NodeId id, NodeType type, int capacity, + const std::string& direction, const Location& location, + const NodeTiming& timing, const NodeSegmentId& segment_id); + const RRNode* get_node(NodeId id) const; + RRNode* get_node(NodeId id); + const std::vector& get_nodes() const { return nodes_; } + std::vector& get_nodes() { return nodes_; } + size_t get_node_count() const { return nodes_.size(); } + + // Edge management + void add_edge(const RREdge& edge); + void add_edge(NodeId src_node, NodeId sink_node, SwitchId switch_id); + const std::vector& get_edges() const { return edges_; } + std::vector& get_edges() { return edges_; } + size_t get_edge_count() const { return edges_.size(); } + + // Channel management + void add_channel(const Channel& channel); + void add_channel(int max_width, int x_max, int x_min, int y_max, int y_min); + const Channel* get_channel(size_t channel_id) const { + return &channels_[channel_id]; + } + Channel* get_channel(size_t channel_id) { return &channels_[channel_id]; } + const std::vector& get_channels() const { return channels_; } + std::vector& get_channels() { return channels_; } + size_t get_channel_count() const { return channels_.size(); } + + // XYList management + void add_xy_list(const XYList& xy_list); + void add_xy_list(XYList::Type type, int index, int info); + const XYList* get_xy_list(size_t xy_list_id) const { + return &xy_lists_[xy_list_id]; + } + XYList* get_xy_list(size_t xy_list_id) { return &xy_lists_[xy_list_id]; } + const std::vector& get_xy_lists() const { return xy_lists_; } + std::vector& get_xy_lists() { return xy_lists_; } + size_t get_xy_list_count() const { return xy_lists_.size(); } + + // Switch management + void add_switch(const Switch& switch_obj); + void add_switch(SwitchId id, const std::string& name, const std::string& type, + const Timing& timing, const Sizing& sizing); + const Switch* get_switch(SwitchId id) const; + Switch* get_switch(SwitchId id); + const std::vector& get_switches() const { return switches_; } + std::vector& get_switches() { return switches_; } + size_t get_switch_count() const { return switches_.size(); } + + // Segment management + void add_segment(const Segment& segment); + void add_segment(SegmentId id, const std::string& name, int length, + const std::string& res_type); + const Segment* get_segment(SegmentId id) const; + const std::vector& get_segments() const { return segments_; } + std::vector& get_segments() { return segments_; } + size_t get_segment_count() const { return segments_.size(); } + + // Block type management + void add_block_type(const BlockType& block_type); + void add_block_type(int id, const std::string& name, int height, int width, + const std::vector& pin_classes); + const BlockType* get_block_type(size_t id) const { return &block_types_[id]; } + BlockType* get_block_type(size_t id) { return &block_types_[id]; } + const std::vector& get_block_types() const { return block_types_; } + std::vector& get_block_types() { return block_types_; } + size_t get_block_type_count() const { return block_types_.size(); } + + // Grid management + void add_grid_loc(const GridLoc& grid_loc); + void add_grid_loc(int type_id, int height_offset, int width_offset, int x, + int y, int layer); + const GridLoc* get_grid_loc(size_t grid_loc_id) const { + return &grid_locs_[grid_loc_id]; + } + GridLoc* get_grid_loc(size_t grid_loc_id) { return &grid_locs_[grid_loc_id]; } + const std::vector& get_grid_locs() const { return grid_locs_; } + std::vector& get_grid_locs() { return grid_locs_; } + size_t get_grid_loc_count() const { return grid_locs_.size(); } + + // Utility methods + void clear(); + void reserve_nodes(size_t count) { nodes_.reserve(count); } + void reserve_edges(size_t count) { edges_.reserve(count); } + void reserve_switches(size_t count) { switches_.reserve(count); } + void reserve_segments(size_t count) { segments_.reserve(count); } + void sort_nodes() { std::sort(nodes_.begin(), nodes_.end()); } + void sort_edges() { std::sort(edges_.begin(), edges_.end()); } + void shrink_to_fit() { nodes_.shrink_to_fit(); edges_.shrink_to_fit(); } + + // Statistics + void print_statistics() const; + + // Node categorization + std::vector get_nodes_by_type(NodeType type) const; + std::unordered_set get_source_nodes() const; + std::unordered_set get_sink_nodes() const; + std::unordered_set get_ipin_nodes() const; + std::unordered_set get_opin_nodes() const; + + // Edge filtering + std::vector get_preserved_edges( + const bool preserve_ipin_connections, + const bool preserve_opin_connections) const; + + // Metadata + void set_tool_info(const std::string& name, const std::string& version, + const std::string& comment); + const std::string& get_tool_name() const { return tool_name_; } + const std::string& get_tool_version() const { return tool_version_; } + const std::string& get_tool_comment() const { return tool_comment_; } + + private: + std::vector nodes_; + std::vector edges_; + std::vector channels_; + std::vector xy_lists_; + std::vector switches_; + std::vector segments_; + std::vector block_types_; + std::vector grid_locs_; + + // Lookup maps for efficiency + std::unordered_map node_id_to_index_; + std::unordered_map switch_id_to_index_; + std::unordered_map segment_id_to_index_; + + // Metadata + std::string tool_name_; + std::string tool_version_; + std::string tool_comment_; + + // Helper methods + void update_node_index(NodeId id, size_t index); + void update_switch_index(SwitchId id, size_t index); + void update_segment_index(SegmentId id, size_t index); +}; + +} // namespace crrgenerator From 835f5e2f1e528251ea0fe1a93159a0d3740a37c8 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 09:05:44 -0700 Subject: [PATCH 026/120] [vpr][route][crr] add crr_common.h --- .../crr_generator/crr_common.h | 360 ++++++++++++++++++ 1 file changed, 360 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h new file mode 100644 index 0000000000..f337d15d8c --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h @@ -0,0 +1,360 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // For getrusage on Unix/Linux + +namespace crrgenerator { + +// Forward declarations +class RRGraph; +class RRNode; +class RREdge; +class Switch; +class Segment; +class ConfigManager; +class XMLHandler; +class SwitchBlockManager; +class NodeLookupManager; +class ConnectionBuilder; +class SwitchManager; +class DataFrameProcessor; +class ThreadPool; +class RRGraphGenerator; + +// Type aliases for convenience +using NodeId = int32_t; +using SwitchId = int32_t; +using SegmentId = int32_t; +using Coordinate = int32_t; +using DelayValue = float; + +// Constants +// Number of empty rows and columns in the Excel file +constexpr int NUM_EMPTY_ROWS = 5; +constexpr int NUM_EMPTY_COLS = 4; + +constexpr SwitchId DELAY_0_ID = 1; +constexpr int DEFAULT_SWITCH_DELAY_MIN = 10000; + +// Node types +enum class NodeType { SOURCE, SINK, IPIN, OPIN, CHANX, CHANY, INVALID }; + +// Direction types +enum class Direction { INC_DIR, DEC_DIR }; + +// Side types +enum class Side { LEFT, RIGHT, TOP, BOTTOM, IPIN, OPIN, INVALID }; + +// Location structure +struct Location { + Coordinate x_low{-1}; + Coordinate x_high{-1}; + Coordinate y_low{-1}; + Coordinate y_high{-1}; + Coordinate layer{-1}; + std::string ptc; + std::string side; + + Location() = default; + Location(Coordinate xl, Coordinate xh, Coordinate yl, Coordinate yh, + Coordinate l, const std::string& p, const std::string& s) + : x_low(xl), + x_high(xh), + y_low(yl), + y_high(yh), + layer(l), + ptc(p), + side(s) {} + + bool operator==(const Location& other) const { + return x_low == other.x_low && x_high == other.x_high && + y_low == other.y_low && y_high == other.y_high && + layer == other.layer && ptc == other.ptc && side == other.side; + } +}; + +// Node timing information +struct NodeTiming { + DelayValue r{0.0}; + DelayValue c{0.0}; + + NodeTiming() = default; + NodeTiming(DelayValue r_val, DelayValue c_val) : r(r_val), c(c_val) {} +}; + +// Node segment information +struct NodeSegmentId { + int segment_id{-1}; + + NodeSegmentId() = default; + NodeSegmentId(int segment_id_val) : segment_id(segment_id_val) {} + + bool empty() const { return segment_id == -1; } +}; + +// Timing information +struct Timing { + DelayValue Cin{0.0}; + DelayValue Tdel{0.0}; + + Timing() = default; + Timing(DelayValue cin_val, DelayValue tdel_val) + : Cin(cin_val), Tdel(tdel_val) {} +}; + +// Sizing information +struct Sizing { + DelayValue mux_trans_size{0.0}; + DelayValue buf_size{0.0}; + + Sizing() = default; + Sizing(DelayValue mux_size, DelayValue buffer_size) + : mux_trans_size(mux_size), buf_size(buffer_size) {} +}; + +/** + * @brief Connection class + * + * This class represents a connection between two nodes in the RR graph. + * It is used to store the connection information and to compare connections. + */ +class Connection { +public: + Connection(NodeId sink_node, NodeId src_node, SwitchId switch_id) + : sink_node_(sink_node), src_node_(src_node), switch_id_(switch_id) {} + NodeId sink_node() const { return sink_node_; } + NodeId src_node() const { return src_node_; } + SwitchId switch_id() const { return switch_id_; } + + bool operator<(const Connection& other) const { + return std::tie(sink_node_, src_node_, switch_id_) < + std::tie(other.sink_node_, other.src_node_, other.switch_id_); + } + + bool operator==(const Connection& other) const { + return sink_node_ == other.sink_node_ && src_node_ == other.src_node_ && + switch_id_ == other.switch_id_; + } + +private: + NodeId sink_node_; + NodeId src_node_; + SwitchId switch_id_; +}; + +// Hash function for Location +struct LocationHash { + std::size_t operator()(const Location& loc) const { + auto h1 = std::hash{}(loc.x_low); + auto h2 = std::hash{}(loc.x_high); + auto h3 = std::hash{}(loc.y_low); + auto h4 = std::hash{}(loc.y_high); + auto h5 = std::hash{}(loc.ptc); + return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3) ^ (h5 << 4); + } +}; + +// Node hash type for lookups +using NodeHash = std::tuple; + +// Hash function for NodeHash +struct NodeHasher { + std::size_t operator()(const NodeHash& hash) const { + auto h1 = std::hash{}(static_cast(std::get<0>(hash))); + auto h2 = std::hash{}(std::get<1>(hash)); + auto h3 = std::hash{}(std::get<2>(hash)); + auto h4 = std::hash{}(std::get<3>(hash)); + auto h5 = std::hash{}(std::get<4>(hash)); + auto h6 = std::hash{}(std::get<5>(hash)); + + // Combine hashes using a better mixing function + std::size_t result = h1; + result ^= h2 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h3 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h4 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h5 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h6 + 0x9e3779b9 + (result << 6) + (result >> 2); + + return result; + } +}; + +// Edge hash type for lookups +using EdgeKey = std::tuple; + +// Utility functions +inline std::string to_string(NodeType type) { + switch (type) { + case NodeType::SOURCE: + return "SOURCE"; + case NodeType::SINK: + return "SINK"; + case NodeType::IPIN: + return "IPIN"; + case NodeType::OPIN: + return "OPIN"; + case NodeType::CHANX: + return "CHANX"; + case NodeType::CHANY: + return "CHANY"; + default: + return "UNKNOWN"; + } +} + +inline NodeType string_to_node_type(const std::string& str) { + if (str == "SOURCE" || str == "source") return NodeType::SOURCE; + if (str == "SINK" || str == "sink") return NodeType::SINK; + if (str == "IPIN" || str == "ipin") return NodeType::IPIN; + if (str == "OPIN" || str == "opin") return NodeType::OPIN; + if (str == "CHANX" || str == "chanx") return NodeType::CHANX; + if (str == "CHANY" || str == "chany") return NodeType::CHANY; + throw std::invalid_argument("Unknown node type: " + str); +} + +inline std::string to_string(Direction dir) { + return (dir == Direction::INC_DIR) ? "INC_DIR" : "DEC_DIR"; +} + +inline std::string to_string(Side side) { + switch (side) { + case Side::LEFT: + return "Left"; + case Side::RIGHT: + return "Right"; + case Side::TOP: + return "Top"; + case Side::BOTTOM: + return "Bottom"; + case Side::IPIN: + return "IPIN"; + case Side::OPIN: + return "OPIN"; + default: + return "UNKNOWN"; + } +} + +inline Side string_to_side(const std::string& str) { + if (str == "Left") return Side::LEFT; + if (str == "Right") return Side::RIGHT; + if (str == "Top") return Side::TOP; + if (str == "Bottom") return Side::BOTTOM; + if (str == "IPIN") return Side::IPIN; + if (str == "OPIN") return Side::OPIN; + throw std::invalid_argument("Unknown side: " + str); +} + +/** + * @brief Get the memory usage + * @return Memory usage in KB + */ +inline size_t get_memory_usage() { +#ifdef _WIN32 + PROCESS_MEMORY_COUNTERS pmc; + if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) { + return pmc.WorkingSetSize / 1024; // Convert bytes to KB + } + return 0; +#else + struct rusage usage; + getrusage(RUSAGE_SELF, &usage); + return static_cast(usage.ru_maxrss); // Already in KB on Linux, bytes on macOS +#ifdef __APPLE__ + return static_cast(usage.ru_maxrss / 1024); // Convert bytes to KB on macOS +#endif +#endif +} + +/** + * @brief Get the peak memory usage + * @return Peak memory usage in KB + */ +inline size_t get_peak_memory_usage() { +#ifdef _WIN32 + PROCESS_MEMORY_COUNTERS pmc; + if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) { + return pmc.PeakWorkingSetSize / 1024; // Convert bytes to KB + } + return 0; +#else + // On Unix/Linux, we need to read /proc/self/status for peak memory + std::ifstream status_file("/proc/self/status"); + std::string line; + while (std::getline(status_file, line)) { + if (line.substr(0, 6) == "VmHWM:") { + std::istringstream iss(line); + std::string label, value, unit; + iss >> label >> value >> unit; + return std::stoul(value); // Already in KB + } + } + + // Fallback to getrusage if /proc/self/status is not available + struct rusage usage; + getrusage(RUSAGE_SELF, &usage); +#ifdef __APPLE__ + return static_cast(usage.ru_maxrss / 1024); // Convert bytes to KB on macOS +#else + return static_cast(usage.ru_maxrss); // Already in KB on Linux +#endif +#endif +} + +// Exception classes +class RRGeneratorException : public std::runtime_error { + public: + explicit RRGeneratorException(const std::string& message) + : std::runtime_error(message) {} +}; + +class ConfigException : public RRGeneratorException { + public: + explicit ConfigException(const std::string& message) + : RRGeneratorException("Configuration error: " + message) {} +}; + +class FileException : public RRGeneratorException { + public: + explicit FileException(const std::string& message) + : RRGeneratorException("File error: " + message) {} +}; + +class ParseException : public RRGeneratorException { + public: + explicit ParseException(const std::string& message) + : RRGeneratorException("Parse error: " + message) {} +}; + +class SwitchException : public RRGeneratorException { + public: + explicit SwitchException(const std::string& message) + : RRGeneratorException("Switch error: " + message) {} +}; + +} // namespace crrgenerator \ No newline at end of file From d2619f82cd890cee8253edeb69c279648eab6841 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 09:15:35 -0700 Subject: [PATCH 027/120] [vpr][route][crr] add xml_handler.h/cpp --- .../crr_generator/xml_handler.cpp | 652 ++++++++++++++++++ .../crr_generator/xml_handler.h | 142 ++++ 2 files changed, 794 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp new file mode 100644 index 0000000000..50a56bda11 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -0,0 +1,652 @@ +#include "xml_handler.h" + +namespace crrgenerator { + +inline void xml_escape_and_write(std::ostream& os, const std::string& s) { + for (char c : s) { + switch (c) { + case '&': os << "&"; break; + case '<': os << "<"; break; + case '>': os << ">"; break; + case '"': os << """; break; + case '\'': os << "'"; break; + default: os << c; break; + } + } +} +inline void write_attr(std::ostream& os, const char* name, const std::string& v) { + os << ' ' << name << "=\""; xml_escape_and_write(os, v); os << '"'; +} +template +inline void write_attr(std::ostream& os, const char* name, T v) { + os << ' ' << name << "=\"" << v << '"'; +} + +XMLHandler::XMLHandler() { setup_attribute_mapping(); } + +void XMLHandler::setup_attribute_mapping() { + attribute_map_ = {{"x_max", "xMax"}, + {"x_min", "xMin"}, + {"y_max", "yMax"}, + {"y_min", "yMin"}, + {"res_type", "resType"}, + {"chan_width_max", "chanWidthMax"}, + {"buf_size", "bufSize"}, + {"mux_trans_size", "muxTransSize"}, + {"C_per_meter", "cPerMeter"}, + {"R_per_meter", "rPerMeter"}, + {"block_type_id", "blockTypeId"}, + {"height_offset", "heightOffset"}, + {"width_offset", "widthOffset"}, + {"C", "c"}, + {"R", "r"}, + {"Cinternal", "cinternal"}, + {"Cin", "cin"}, + {"Cout", "cout"}, + {"Tdel", "tdel"}, + {"src_node", "srcNode"}, + {"sink_node", "sinkNode"}, + {"switch_id", "switchId"}, + {"segment_id", "segmentId"}}; +} + +std::unique_ptr XMLHandler::read_rr_graph( + const std::string& filename) { + VTR_LOG("Reading RR graph from: %s\n", filename.c_str()); + + pugi::xml_document doc; + pugi::xml_parse_result result = doc.load_file(filename.c_str(), + pugi::parse_default); + + if (!result) { + std::ifstream in(filename); + std::string line; + size_t pos = 0; + int lineno = 1; + while (std::getline(in, line)) { + if (pos + line.size() + 1 > static_cast(result.offset)) { + VTR_LOG("Parse error at line %d near: %s\n", lineno, line.c_str()); + break; + } + pos += line.size() + 1; + lineno++; + } + + VTR_LOG_ERROR("Failed to parse XML file %s: %s (at byte offset %zu)", filename.c_str(), + result.description(), result.offset); + } + + validate_xml_structure(doc); + + auto graph = std::make_unique(); + pugi::xml_node root = doc.child("rr_graph"); + + // Parse tool information + parse_tool_info(root, *graph); + + // Parse main sections + if (auto channels = root.child("channels")) { + parse_channels(channels, *graph); + } + + if (auto switches = root.child("switches")) { + parse_switches(switches, *graph); + } + + if (auto segments = root.child("segments")) { + parse_segments(segments, *graph); + } + + if (auto block_types = root.child("block_types")) { + parse_block_types(block_types, *graph); + } + + if (auto grids = root.child("grid")) { + parse_grid(grids, *graph); + } + + if (auto rr_nodes = root.child("rr_nodes")) { + parse_nodes(rr_nodes, *graph); + } + + if (auto rr_edges = root.child("rr_edges")) { + parse_edges(rr_edges, *graph); + } + + graph->print_statistics(); + VTR_LOG("Successfully loaded RR graph from %s\n", filename.c_str()); + + return graph; +} + +void XMLHandler::write_rr_graph(const std::string& filename, + const RRGraph& graph) { + VTR_LOG("Writing RR graph to: %s\n", filename.c_str()); + + std::string temp_filename = filename + ".tmp"; + std::vector out_buf(100 * 1024 * 1024); + std::ofstream out; + out.rdbuf()->pubsetbuf(out_buf.data(), static_cast(out_buf.size())); + out.open(temp_filename, std::ios::out | std::ios::binary); + if (!out) { + throw FileException("Failed to open output file: " + temp_filename); + } + + out << "\n"; + out << "\n"; + + write_channels(out, graph); + write_switches(out, graph); + write_segments(out, graph); + write_block_types(out, graph); + write_grid(out, graph); + write_nodes(out, graph); + write_edges(out, graph); + + out << "\n"; + out.close(); + + if (std::rename(temp_filename.c_str(), filename.c_str()) != 0) { + std::remove(temp_filename.c_str()); + throw FileException("Failed to atomically replace XML file: " + filename); + } + + VTR_LOG("Successfully wrote RR graph to %s\n", filename.c_str()); +} + +void XMLHandler::parse_tool_info(const pugi::xml_node& root, RRGraph& graph) { + std::string tool_name = root.attribute("tool_name").as_string(); + std::string tool_version = root.attribute("tool_version").as_string(); + std::string tool_comment = root.attribute("tool_comment").as_string(); + + graph.set_tool_info(tool_name, tool_version, tool_comment); +} + +void XMLHandler::parse_channels(const pugi::xml_node& channels_node, + RRGraph& graph) { + for (pugi::xml_node channel_node : channels_node.children("channel")) { + Channel channel = parse_channel(channel_node); + graph.add_channel(channel); + } + for (pugi::xml_node channel_node : channels_node.children("x_list")) { + XYList xy_list = parse_xy_list(channel_node); + graph.add_xy_list(xy_list); + } + for (pugi::xml_node channel_node : channels_node.children("y_list")) { + XYList xy_list = parse_xy_list(channel_node); + graph.add_xy_list(xy_list); + } + VTR_LOG_DEBUG("Parsed %zu channels\n", graph.get_channel_count()); +} + +Channel XMLHandler::parse_channel(const pugi::xml_node& channel_node) { + int max_width = channel_node.attribute("chan_width_max").as_int(); + int x_max = channel_node.attribute("x_max").as_int(); + int x_min = channel_node.attribute("x_min").as_int(); + int y_max = channel_node.attribute("y_max").as_int(); + int y_min = channel_node.attribute("y_min").as_int(); + + return Channel(max_width, x_max, x_min, y_max, y_min); +} + +XYList XMLHandler::parse_xy_list(const pugi::xml_node& xy_list_node) { + XYList::Type type = XYList::Type::INVALID_LIST; + if (std::string(xy_list_node.name()) == "x_list") { + type = XYList::Type::X_LIST; + } else { + assert(std::string(xy_list_node.name()) == "y_list"); + type = XYList::Type::Y_LIST; + } + int index = xy_list_node.attribute("index").as_int(); + int info = xy_list_node.attribute("info").as_int(); + return XYList(type, index, info); +} + +void XMLHandler::parse_switches(const pugi::xml_node& switches_node, + RRGraph& graph) { + for (pugi::xml_node switch_node : switches_node.children("switch")) { + Switch switch_obj = parse_switch(switch_node); + graph.add_switch(switch_obj); + } + VTR_LOG_DEBUG("Parsed %zu switches\n", graph.get_switch_count()); +} + +Switch XMLHandler::parse_switch(const pugi::xml_node& switch_xml) { + SwitchId id = switch_xml.attribute("id").as_int(); + std::string name = switch_xml.attribute("name").as_string(); + std::string type = switch_xml.attribute("type").as_string(); + + Timing timing; + if (auto timing_node = switch_xml.child("timing")) { + timing = parse_timing(timing_node); + } + + Sizing sizing; + if (auto sizing_node = switch_xml.child("sizing")) { + sizing = parse_sizing(sizing_node); + } + + return Switch(id, name, type, timing, sizing); +} + +Timing XMLHandler::parse_timing(const pugi::xml_node& timing_xml) { + return Timing(timing_xml.attribute("Cin").as_float(), + timing_xml.attribute("Tdel").as_float()); +} + +Sizing XMLHandler::parse_sizing(const pugi::xml_node& sizing_xml) { + return Sizing(sizing_xml.attribute("mux_trans_size").as_float(), + sizing_xml.attribute("buf_size").as_float()); +} + +void XMLHandler::parse_segments(const pugi::xml_node& segments_node, + RRGraph& graph) { + for (pugi::xml_node segment_node : segments_node.children("segment")) { + Segment segment = parse_segment(segment_node); + graph.add_segment(segment); + } + VTR_LOG_DEBUG("Parsed %zu segments\n", graph.get_segment_count()); +} + +Segment XMLHandler::parse_segment(const pugi::xml_node& segment_xml) { + SegmentId id = segment_xml.attribute("id").as_int(); + std::string name = segment_xml.attribute("name").as_string(); + int length = -1; + if (segment_xml.attribute("length")) { + length = segment_xml.attribute("length").as_int(); + } + std::string res_type = ""; + if (segment_xml.attribute("res_type")) { + res_type = segment_xml.attribute("res_type").as_string(); + } + return Segment(id, name, length, res_type); +} + +void XMLHandler::parse_block_types(const pugi::xml_node& block_types_node, + RRGraph& graph) { + for (pugi::xml_node block_type_node : + block_types_node.children("block_type")) { + BlockType block_type = parse_block_type(block_type_node); + graph.add_block_type(block_type); + } + VTR_LOG_DEBUG("Parsed %zu block types\n", graph.get_block_type_count()); +} + +BlockType XMLHandler::parse_block_type(const pugi::xml_node& block_type_node) { + int id = block_type_node.attribute("id").as_int(); + std::string name = block_type_node.attribute("name").as_string(); + int height = block_type_node.attribute("height").as_int(); + int width = block_type_node.attribute("width").as_int(); + std::vector pin_classes; + for (pugi::xml_node pin_class_node : block_type_node.children("pin_class")) { + PinClass pin_class = parse_pin_class(pin_class_node); + pin_classes.push_back(pin_class); + } + return BlockType(id, name, height, width, pin_classes); +} + +PinClass XMLHandler::parse_pin_class(const pugi::xml_node& pin_class_node) { + std::string type = pin_class_node.attribute("type").as_string(); + std::vector pins; + for (pugi::xml_node pin_node : pin_class_node.children("pin")) { + Pin pin = parse_pin(pin_node); + pins.push_back(pin); + } + return PinClass(type, pins); +} + +Pin XMLHandler::parse_pin(const pugi::xml_node& pin_node) { + int ptc = pin_node.attribute("ptc").as_int(); + std::string value = pin_node.text().get(); + return Pin(ptc, value); +} + +void XMLHandler::parse_grid(const pugi::xml_node& grids_node, RRGraph& graph) { + for (pugi::xml_node grid_node : grids_node.children("grid_loc")) { + GridLoc grid_loc = parse_grid_loc(grid_node); + graph.add_grid_loc(grid_loc); + } + VTR_LOG_DEBUG("Parsed %zu grid locations\n", graph.get_grid_loc_count()); +} + +GridLoc XMLHandler::parse_grid_loc(const pugi::xml_node& grid_node) { + int type_id = grid_node.attribute("block_type_id").as_int(); + int height_offset = grid_node.attribute("height_offset").as_int(); + int width_offset = grid_node.attribute("width_offset").as_int(); + int x = grid_node.attribute("x").as_int(); + int y = grid_node.attribute("y").as_int(); + int layer = grid_node.attribute("layer").as_int(); + return GridLoc(type_id, height_offset, width_offset, x, y, layer); +} + +void XMLHandler::parse_nodes(const pugi::xml_node& nodes_node, RRGraph& graph) { + for (pugi::xml_node node_xml : nodes_node.children("node")) { + RRNode node = parse_node(node_xml); + graph.add_node(node); + } + VTR_LOG_DEBUG("Parsed %zu nodes\n", graph.get_node_count()); +} + +RRNode XMLHandler::parse_node(const pugi::xml_node& node_xml) { + NodeId id = node_xml.attribute("id").as_int(); + NodeType type = string_to_node_type(node_xml.attribute("type").as_string()); + int capacity = node_xml.attribute("capacity").as_int(); + std::string direction = ""; + if (node_xml.attribute("direction")) { + direction = node_xml.attribute("direction").as_string(); + } + + Location location; + if (auto loc_node = node_xml.child("loc")) { + location = parse_location(loc_node); + } + + NodeTiming timing; + if (auto timing_node = node_xml.child("timing")) { + timing = parse_node_timing(timing_node); + } + + NodeSegmentId segment_id; + if (auto segment_node = node_xml.child("segment")) { + segment_id = parse_node_segment(segment_node); + } + + return RRNode(id, type, capacity, direction, location, timing, segment_id); +} + +Location XMLHandler::parse_location(const pugi::xml_node& loc_xml) { + int layer = 0; + if (loc_xml.attribute("layer")) { + layer = loc_xml.attribute("layer").as_int(); + } + std::string side = ""; + if (loc_xml.attribute("side")) { + side = loc_xml.attribute("side").as_string(); + } + return Location( + loc_xml.attribute("xlow").as_int(), loc_xml.attribute("xhigh").as_int(), + loc_xml.attribute("ylow").as_int(), loc_xml.attribute("yhigh").as_int(), + layer, loc_xml.attribute("ptc").as_string(), side); +} + +NodeTiming XMLHandler::parse_node_timing(const pugi::xml_node& timing_xml) { + return NodeTiming(timing_xml.attribute("R").as_float(), + timing_xml.attribute("C").as_float()); +} + +NodeSegmentId XMLHandler::parse_node_segment(const pugi::xml_node& segment_xml) { + return NodeSegmentId(segment_xml.attribute("segment_id").as_int()); +} + +void XMLHandler::parse_edges(const pugi::xml_node& edges_node, RRGraph& graph) { + for (pugi::xml_node edge_xml : edges_node.children("edge")) { + RREdge edge = parse_edge(edge_xml); + graph.add_edge(edge); + } + VTR_LOG_DEBUG("Parsed %zu edges\n", graph.get_edge_count()); +} + +RREdge XMLHandler::parse_edge(const pugi::xml_node& edge_xml) { + NodeId src_node = edge_xml.attribute("src_node").as_int(); + NodeId sink_node = edge_xml.attribute("sink_node").as_int(); + SwitchId switch_id = edge_xml.attribute("switch_id").as_int(); + + return RREdge(src_node, sink_node, switch_id); +} + +void XMLHandler::write_tool_info(std::ostream& out, const RRGraph& graph) { + if (!graph.get_tool_name().empty()) write_attr(out, "tool_name", graph.get_tool_name()); + if (!graph.get_tool_version().empty()) write_attr(out, "tool_version", graph.get_tool_version()); + if (!graph.get_tool_comment().empty()) write_attr(out, "tool_comment", graph.get_tool_comment()); +} + +void XMLHandler::write_channels(std::ostream& out, const RRGraph& graph) { + out << " \n"; + for (const auto& channel : graph.get_channels()) write_channel(out, channel); + for (const auto& xy_list : graph.get_xy_lists()) write_xy_list(out, xy_list); + out << " \n"; +} + +void XMLHandler::write_channel(std::ostream& out, const Channel& channel) { + out << " \n"; +} + +void XMLHandler::write_xy_list(std::ostream& out, const XYList& xy_list) { + out << " <" << (xy_list.get_type() == XYList::Type::X_LIST ? "x_list" : "y_list"); + write_attr(out, "index", xy_list.get_index()); + write_attr(out, "info", xy_list.get_info()); + out << "/>\n"; +} + +void XMLHandler::write_switches(std::ostream& out, const RRGraph& graph) { + out << " \n"; + for (const auto& s : graph.get_switches()) write_switch(out, s); + out << " \n"; +} + +void XMLHandler::write_switch(std::ostream& out, const Switch& s) { + out << " \n"; + out << " \n"; + out << " \n"; + out << " \n"; +} + +void XMLHandler::write_segments(std::ostream& out, const RRGraph& graph) { + if (graph.get_segment_count() == 0) return; + out << " \n"; + for (const auto& seg : graph.get_segments()) { + out << " \n"; + } + out << " \n"; +} + +void XMLHandler::write_block_types(std::ostream& out, const RRGraph& graph) { + out << " \n"; + for (const auto& bt : graph.get_block_types()) write_block_type(out, bt); + out << " \n"; +} + +void XMLHandler::write_block_type(std::ostream& out, const BlockType& bt) { + out << " \n"; + for (const auto& pc : bt.get_pin_classes()) write_pin_class(out, pc); + out << " \n"; +} + +void XMLHandler::write_pin_class(std::ostream& out, const PinClass& pc) { + out << " \n"; + for (const auto& p : pc.get_pins()) write_pin(out, p); + out << " \n"; +} + +void XMLHandler::write_pin(std::ostream& out, const Pin& pin) { + out << " '; + xml_escape_and_write(out, pin.get_value()); + out << "\n"; +} + +void XMLHandler::write_grid(std::ostream& out, const RRGraph& graph) { + out << " \n"; + for (const auto& gl : graph.get_grid_locs()) write_grid_loc(out, gl); + out << " \n"; +} + +void XMLHandler::write_grid_loc(std::ostream& out, const GridLoc& gl) { + out << " \n"; +} + +void XMLHandler::write_nodes(std::ostream& out, const RRGraph& graph) { + out << " \n"; + for (const auto& n : graph.get_nodes()) write_node(out, n); + out << " \n"; +} + +void XMLHandler::write_node(std::ostream& out, const RRNode& n) { + out << " \n"; + write_location(out, n.get_location()); + write_node_timing(out, n.get_timing()); + if (!n.get_segment().empty()) write_node_segment(out, n.get_segment()); + out << " \n"; +} + +void XMLHandler::write_location(std::ostream& out, const Location& loc) { + out << " \n"; +} + +void XMLHandler::write_node_timing(std::ostream& out, const NodeTiming& t) { + out << " \n"; +} + +void XMLHandler::write_node_segment(std::ostream& out, const NodeSegmentId& seg) { + out << " \n"; +} + +void XMLHandler::write_edges(std::ostream& out, const RRGraph& graph) { + out << " \n"; + for (const auto& e : graph.get_edges()) write_edge(out, e); + out << " \n"; +} + +void XMLHandler::write_edge(std::ostream& out, const RREdge& e) { + out << " \n"; +} + +void XMLHandler::update_vpr_xml_with_switches( + const std::vector& switches, const std::string& input_file, + const std::string& output_file, SwitchId switch_delay_min, + SwitchId switch_delay_max) { + VTR_LOG("Updating VPR XML with new switches: %s -> %s\n", input_file.c_str(), + output_file.c_str()); + + pugi::xml_document doc; + pugi::xml_parse_result result = doc.load_file(input_file.c_str()); + + if (!result) { + throw FileException(fmt::format("Failed to parse VPR XML file {}: {}", + input_file, result.description())); + } + + // Find switchlist element + pugi::xml_node switchlist = doc.select_node("//switchlist").node(); + if (!switchlist) { + throw ParseException(" element not found in VPR XML file"); + } + + // Find the last default switch ID + SwitchId last_default_id = 0; + for (const auto& switch_obj : switches) { + last_default_id = std::max(last_default_id, switch_obj.get_id()); + } + + SwitchId first_new_id = std::min(switch_delay_min - 1, last_default_id + 1); + + // Add new switches + for (SwitchId switch_id = first_new_id; switch_id <= switch_delay_max + 1; + ++switch_id) { + pugi::xml_node switch_element = switchlist.append_child("switch"); + + switch_element.append_attribute("type") = "mux"; + switch_element.append_attribute("name") = + fmt::format("sw_{}", switch_id).c_str(); + switch_element.append_attribute("R") = "0."; + switch_element.append_attribute("Cin") = ".77e-15"; + switch_element.append_attribute("Cout") = "0."; + switch_element.append_attribute("Tdel") = + fmt::format("{:.8e}", switch_id * 1e-12).c_str(); + switch_element.append_attribute("mux_trans_size") = "2.630740"; + switch_element.append_attribute("buf_size") = "27.645901"; + } + + VTR_LOG("Successfully updated VPR XML with %zu new switches\n", + (switch_delay_max + 1 - first_new_id + 1)); +} + +std::string XMLHandler::format_float_value(double value) { + std::string result = fmt::format("{}", value); + + // Remove trailing .0 for integer values (C++17 compatible) + if (result.length() >= 2 && result.substr(result.length() - 2) == ".0") { + result = result.substr(0, result.length() - 2); + } + + // Format scientific notation + if (result.find("e-") != std::string::npos) { + result = fmt::format("{:.8e}", value); + } + + return result; +} + +void XMLHandler::validate_xml_structure(const pugi::xml_document& doc) { + pugi::xml_node root = doc.child("rr_graph"); + if (!root) { + throw ParseException("Root element 'rr_graph' not found"); + } +} + +std::string XMLHandler::map_attribute_name(const std::string& internal_name) { + auto it = attribute_map_.find(internal_name); + return (it != attribute_map_.end()) ? it->second : internal_name; +} + +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h new file mode 100644 index 0000000000..25cf0c2329 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h @@ -0,0 +1,142 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include + +#include "crr_common.h" +#include "custom_rr_graph.h" + +namespace crrgenerator { + +/** + * @brief Handles XML file I/O operations for RR graphs + * + * This class provides functionality to read and write RR graph XML files, + * with support for attribute mapping and pretty printing. + */ +class XMLHandler { +public: + XMLHandler(); + + /** + * @brief Read RR graph from XML file + * @param filename Path to the XML file + * @return Parsed RR graph + * @throws FileException if file cannot be read + * @throws ParseException if XML is malformed + */ + std::unique_ptr read_rr_graph(const std::string& filename); + + /** + * @brief Write RR graph to XML file + * @param graph RR graph to write + * @param filename Output file path + * @throws FileException if file cannot be written + */ + void write_rr_graph(const std::string& filename, const RRGraph& graph); + + /** + * @brief Update VPR XML file with new switches + * @param switches Vector of switches to add + * @param input_file Input VPR XML file + * @param output_file Output VPR XML file + * @param switch_delay_min Minimum switch delay ID + * @param switch_delay_max Maximum switch delay ID + */ + void update_vpr_xml_with_switches(const std::vector& switches, + const std::string& input_file, + const std::string& output_file, + SwitchId switch_delay_min, + SwitchId switch_delay_max); + + private: + // Attribute mapping for XML conversion + std::unordered_map attribute_map_; + + // XML parsing methods + void parse_tool_info(const pugi::xml_node& root, RRGraph& graph); + void parse_channels(const pugi::xml_node& channels_node, RRGraph& graph); + void parse_switches(const pugi::xml_node& switches_node, RRGraph& graph); + void parse_segments(const pugi::xml_node& segments_node, RRGraph& graph); + void parse_block_types(const pugi::xml_node& block_types_node, + RRGraph& graph); + void parse_grid(const pugi::xml_node& grids_node, RRGraph& graph); + void parse_nodes(const pugi::xml_node& nodes_node, RRGraph& graph); + void parse_edges(const pugi::xml_node& edges_node, RRGraph& graph); + + // Node parsing helpers + RRNode parse_node(const pugi::xml_node& node_xml); + Location parse_location(const pugi::xml_node& loc_xml); + NodeTiming parse_node_timing(const pugi::xml_node& timing_xml); + NodeSegmentId parse_node_segment(const pugi::xml_node& segment_xml); + + // Channel parsing helpers + Channel parse_channel(const pugi::xml_node& channel_xml); + XYList parse_xy_list(const pugi::xml_node& xy_list_xml); + + // Switch parsing helpers + Switch parse_switch(const pugi::xml_node& switch_xml); + Timing parse_timing(const pugi::xml_node& timing_xml); + Sizing parse_sizing(const pugi::xml_node& sizing_xml); + + // Segment parsing helpers + Segment parse_segment(const pugi::xml_node& segment_xml); + + // Block type parsing helpers + BlockType parse_block_type(const pugi::xml_node& block_type_xml); + PinClass parse_pin_class(const pugi::xml_node& pin_class_xml); + Pin parse_pin(const pugi::xml_node& pin_xml); + + // Grid parsing helpers + GridLoc parse_grid_loc(const pugi::xml_node& grid_xml); + + // Edge parsing helpers + RREdge parse_edge(const pugi::xml_node& edge_xml); + + // XML writing methods (streaming) + void write_tool_info(std::ostream& out, const RRGraph& graph); + void write_channels(std::ostream& out, const RRGraph& graph); + void write_switches(std::ostream& out, const RRGraph& graph); + void write_segments(std::ostream& out, const RRGraph& graph); + void write_block_types(std::ostream& out, const RRGraph& graph); + void write_grid(std::ostream& out, const RRGraph& graph); + void write_nodes(std::ostream& out, const RRGraph& graph); + void write_edges(std::ostream& out, const RRGraph& graph); + + // Writing helpers (streaming) + void write_channel(std::ostream& out, const Channel& channel); + void write_xy_list(std::ostream& out, const XYList& xy_list); + void write_switch(std::ostream& out, const Switch& switch_obj); + void write_timing(std::ostream& out, const Timing& timing); + void write_sizing(std::ostream& out, const Sizing& sizing); + void write_block_type(std::ostream& out, const BlockType& block_type); + void write_pin_class(std::ostream& out, const PinClass& pin_class); + void write_pin(std::ostream& out, const Pin& pin); + void write_grid_loc(std::ostream& out, const GridLoc& grid_loc); + void write_node(std::ostream& out, const RRNode& node); + void write_location(std::ostream& out, const Location& location); + void write_node_timing(std::ostream& out, const NodeTiming& timing); + void write_node_segment(std::ostream& out, const NodeSegmentId& segment_id); + void write_edge(std::ostream& out, const RREdge& edge); + + // Utility methods + void setup_attribute_mapping(); + std::string map_attribute_name(const std::string& internal_name); + std::string format_float_value(double value); + void update_element_attributes( + pugi::xml_node& element, + const std::map& attributes); + + // Error handling + void validate_xml_structure(const pugi::xml_document& doc); + void check_required_elements( + const pugi::xml_node& parent, + const std::vector& required_children); +}; + +} // namespace crrgenerator From 7f32380302bfb716094a1c9b5c877b1709a1633f Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 09:22:30 -0700 Subject: [PATCH 028/120] [vpr][route][crr] fix compile problems with xml_handler --- .../crr_generator/xml_handler.cpp | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp index 50a56bda11..29738c448a 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -1,5 +1,8 @@ #include "xml_handler.h" +#include "vtr_log.h" +#include "vtr_assert.h" + namespace crrgenerator { inline void xml_escape_and_write(std::ostream& os, const std::string& s) { @@ -129,7 +132,7 @@ void XMLHandler::write_rr_graph(const std::string& filename, out.rdbuf()->pubsetbuf(out_buf.data(), static_cast(out_buf.size())); out.open(temp_filename, std::ios::out | std::ios::binary); if (!out) { - throw FileException("Failed to open output file: " + temp_filename); + VTR_LOG_ERROR("Failed to open output file: %s", temp_filename.c_str()); } out << "\n"; @@ -150,7 +153,7 @@ void XMLHandler::write_rr_graph(const std::string& filename, if (std::rename(temp_filename.c_str(), filename.c_str()) != 0) { std::remove(temp_filename.c_str()); - throw FileException("Failed to atomically replace XML file: " + filename); + VTR_LOG_ERROR("Failed to atomically replace XML file: %s", filename.c_str()); } VTR_LOG("Successfully wrote RR graph to %s\n", filename.c_str()); @@ -196,7 +199,7 @@ XYList XMLHandler::parse_xy_list(const pugi::xml_node& xy_list_node) { if (std::string(xy_list_node.name()) == "x_list") { type = XYList::Type::X_LIST; } else { - assert(std::string(xy_list_node.name()) == "y_list"); + VTR_ASSERT(std::string(xy_list_node.name()) == "y_list"); type = XYList::Type::Y_LIST; } int index = xy_list_node.attribute("index").as_int(); @@ -582,14 +585,13 @@ void XMLHandler::update_vpr_xml_with_switches( pugi::xml_parse_result result = doc.load_file(input_file.c_str()); if (!result) { - throw FileException(fmt::format("Failed to parse VPR XML file {}: {}", - input_file, result.description())); + VTR_LOG_ERROR("Failed to parse VPR XML file %s: %s", input_file.c_str(), result.description()); } // Find switchlist element pugi::xml_node switchlist = doc.select_node("//switchlist").node(); if (!switchlist) { - throw ParseException(" element not found in VPR XML file"); + VTR_LOG_ERROR(" element not found in VPR XML file"); } // Find the last default switch ID @@ -607,12 +609,12 @@ void XMLHandler::update_vpr_xml_with_switches( switch_element.append_attribute("type") = "mux"; switch_element.append_attribute("name") = - fmt::format("sw_{}", switch_id).c_str(); + ("sw_" + std::to_string(switch_id)).c_str(); switch_element.append_attribute("R") = "0."; switch_element.append_attribute("Cin") = ".77e-15"; switch_element.append_attribute("Cout") = "0."; switch_element.append_attribute("Tdel") = - fmt::format("{:.8e}", switch_id * 1e-12).c_str(); + (std::to_string(switch_id * 1e-12)).c_str(); switch_element.append_attribute("mux_trans_size") = "2.630740"; switch_element.append_attribute("buf_size") = "27.645901"; } @@ -622,7 +624,7 @@ void XMLHandler::update_vpr_xml_with_switches( } std::string XMLHandler::format_float_value(double value) { - std::string result = fmt::format("{}", value); + std::string result = std::to_string(value); // Remove trailing .0 for integer values (C++17 compatible) if (result.length() >= 2 && result.substr(result.length() - 2) == ".0") { @@ -631,7 +633,7 @@ std::string XMLHandler::format_float_value(double value) { // Format scientific notation if (result.find("e-") != std::string::npos) { - result = fmt::format("{:.8e}", value); + result = std::to_string(value); } return result; @@ -640,7 +642,7 @@ std::string XMLHandler::format_float_value(double value) { void XMLHandler::validate_xml_structure(const pugi::xml_document& doc) { pugi::xml_node root = doc.child("rr_graph"); if (!root) { - throw ParseException("Root element 'rr_graph' not found"); + VTR_LOG_ERROR("Root element 'rr_graph' not found"); } } From d38f92438dc63e155fed5a6527ade90f0e87e3ff Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 10:25:09 -0700 Subject: [PATCH 029/120] [vpr][route][crr] add node_lookup_mng --- .../crr_generator/node_lookup_manager.cpp | 193 ++++++++++++++++++ .../crr_generator/node_lookup_manager.h | 123 +++++++++++ 2 files changed, 316 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp new file mode 100644 index 0000000000..e31149762a --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -0,0 +1,193 @@ +#include "node_lookup_manager.h" + +#include "vtr_log.h" +#include "vtr_assert.h" + +namespace crrgenerator { + +NodeLookupManager::NodeLookupManager() : fpga_grid_x_(0), fpga_grid_y_(0) {} + +void NodeLookupManager::initialize(const RRGraph& graph, Coordinate fpga_grid_x, + Coordinate fpga_grid_y) { + VTR_LOG("Initializing NodeLookupManager for %d x %d grid with %zu nodes\n", + fpga_grid_x, fpga_grid_y, static_cast(graph.get_node_count())); + + fpga_grid_x_ = fpga_grid_x; + fpga_grid_y_ = fpga_grid_y; + + // Clear existing data + clear(); + + // Initialize lookup structures + column_lookup_.resize(static_cast(fpga_grid_x) + 1); + row_lookup_.resize(static_cast(fpga_grid_y) + 1); + for (int i = 0; i <= fpga_grid_x + 1; i++) { + edge_sink_lookup_.push_back(std::vector>( + static_cast(fpga_grid_y + 2), std::vector())); + } + + // Index all nodes + for (const auto& node : graph.get_nodes()) { + index_node(node); + } + + // Index all edges + for (const auto& edge : graph.get_edges()) { + index_edge(graph, edge); + } + + VTR_LOG("Node lookup manager initialized successfully\n"); + print_statistics(); +} + +const RRNode* NodeLookupManager::get_node_by_hash(const NodeHash& hash) const { + auto it = global_lookup_.find(hash); + return (it != global_lookup_.end()) ? it->second : nullptr; +} + +const std::unordered_map& +NodeLookupManager::get_column_nodes(Coordinate x) const { + if (x <= fpga_grid_x_ && x < static_cast(column_lookup_.size())) { + return column_lookup_[static_cast(x)]; + } + return empty_map_; +} + +const std::unordered_map& +NodeLookupManager::get_row_nodes(Coordinate y) const { + if (y <= fpga_grid_y_ && y < static_cast(row_lookup_.size())) { + return row_lookup_[static_cast(y)]; + } + return empty_map_; +} + +std::unordered_map +NodeLookupManager::get_combined_nodes(Coordinate x, Coordinate y) const { + std::unordered_map combined; + + // Add column nodes + const auto& col_nodes = get_column_nodes(x); + combined.insert(col_nodes.begin(), col_nodes.end()); + + // Add row nodes + const auto& row_nodes = get_row_nodes(y); + combined.insert(row_nodes.begin(), row_nodes.end()); + + return combined; +} + +std::vector NodeLookupManager::get_nodes_by_type( + NodeType type) const { + auto it = type_lookup_.find(type); + return (it != type_lookup_.end()) ? it->second : std::vector{}; +} + +const std::vector NodeLookupManager::get_sink_edges_at_location(Coordinate x, Coordinate y) const { + return edge_sink_lookup_[static_cast(x)][static_cast(y)]; +} + +bool NodeLookupManager::is_valid_coordinate(Coordinate x, Coordinate y) const { + return x >= 0 && x <= fpga_grid_x_ && y >= 0 && y <= fpga_grid_y_; +} + +void NodeLookupManager::print_statistics() const { + VTR_LOG("=== Node Lookup Manager Statistics ==="); + VTR_LOG("Grid dimensions: %d x %d\n", fpga_grid_x_, fpga_grid_y_); + VTR_LOG("Total nodes indexed: %zu\n", global_lookup_.size()); + + // Count nodes by type + for (const auto& [type, nodes] : type_lookup_) { + VTR_LOG(" %s nodes: %zu\n", to_string(type).c_str(), nodes.size()); + } + + // Count nodes per column + std::vector col_counts; + for (const auto& col_map : column_lookup_) { + col_counts.push_back(col_map.size()); + } + + if (!col_counts.empty()) { + auto [min_col, max_col] = + std::minmax_element(col_counts.begin(), col_counts.end()); + VTR_LOG("Nodes per column: min=%d, max=%d, avg=%f\n", *min_col, *max_col, + std::accumulate(col_counts.begin(), col_counts.end(), 0.0) / col_counts.size()); + } + + // Count nodes per row + std::vector row_counts; + for (const auto& row_map : row_lookup_) { + row_counts.push_back(row_map.size()); + } + + if (!row_counts.empty()) { + auto [min_row, max_row] = + std::minmax_element(row_counts.begin(), row_counts.end()); + VTR_LOG("Nodes per row: min=%d, max=%d, avg=%f\n", *min_row, *max_row, + *max_row, + std::accumulate(row_counts.begin(), row_counts.end(), 0.0) / row_counts.size()); + } +} + +void NodeLookupManager::clear() { + column_lookup_.clear(); + row_lookup_.clear(); + global_lookup_.clear(); + type_lookup_.clear(); +} + +NodeHash NodeLookupManager::build_node_hash(const RRNode& node) const { + return std::make_tuple(node.get_type(), node.get_ptc(), + node.get_location().x_low, node.get_location().x_high, + node.get_location().y_low, node.get_location().y_high); +} + +void NodeLookupManager::index_node(const RRNode& node) { + NodeHash hash = build_node_hash(node); + const RRNode* node_ptr = &node; + + // Add to global lookup + global_lookup_[hash] = node_ptr; + + // Add to type lookup + type_lookup_[node.get_type()].push_back(node_ptr); + + const Location& loc = node.get_location(); + + VTR_ASSERT(loc.x_low <= fpga_grid_x_); + VTR_ASSERT(loc.x_high <= fpga_grid_x_); + VTR_ASSERT(loc.y_low <= fpga_grid_y_); + VTR_ASSERT(loc.y_high <= fpga_grid_y_); + + // Skip spatial indexing for source/sink nodes + if (node.get_type() == NodeType::SOURCE || + node.get_type() == NodeType::SINK) { + return; + } + + // Add to column lookup (for single-column nodes) + if (loc.x_low == loc.x_high) { + column_lookup_[static_cast(loc.x_low)][hash] = node_ptr; + } + + // Add to row lookup (for single-row nodes) + if (loc.y_low == loc.y_high) { + row_lookup_[static_cast(loc.y_low)][hash] = node_ptr; + } +} + +void NodeLookupManager::index_edge(const RRGraph& graph, const RREdge& edge) { + const RRNode* sink = graph.get_node(edge.get_sink_node()); + + VTR_ASSERT(sink->get_location().x_high >= 0); + VTR_ASSERT(sink->get_location().y_high >= 0); + + VTR_ASSERT(sink->get_location().x_high <= fpga_grid_x_); + VTR_ASSERT(sink->get_location().y_high <= fpga_grid_y_); + + // Add to edge lookup + edge_sink_lookup_[static_cast(sink->get_location().x_low)] + [static_cast(sink->get_location().y_low)].push_back(&edge); +} + + +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h new file mode 100644 index 0000000000..ec243bf542 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h @@ -0,0 +1,123 @@ +#pragma once + +#include "crr_common.h" +#include "custom_rr_graph.h" + +namespace crrgenerator { + +/** + * @brief Manages efficient node lookup and indexing for RR graphs + * + * This class creates spatial indexes for nodes to enable fast lookup + * by coordinates, type, and other attributes. + */ +class NodeLookupManager { + public: + NodeLookupManager(); + + /** + * @brief Initialize lookup tables from RR graph + * @param graph RR graph to index + * @param fpga_grid_x Maximum X coordinate + * @param fpga_grid_y Maximum Y coordinate + */ + void initialize(const RRGraph& graph, Coordinate fpga_grid_x, + Coordinate fpga_grid_y); + + /** + * @brief Get node by hash key + * @param hash Node hash tuple + * @return Pointer to node or nullptr if not found + */ + const RRNode* get_node_by_hash(const NodeHash& hash) const; + + /** + * @brief Get nodes in a specific column + * @param x Column coordinate + * @return Map of hash to node for nodes in column + */ + const std::unordered_map& + get_column_nodes(Coordinate x) const; + + /** + * @brief Get nodes in a specific row + * @param y Row coordinate + * @return Map of hash to node for nodes in row + */ + const std::unordered_map& get_row_nodes( + Coordinate y) const; + + /** + * @brief Get combined nodes for column and row (for switch block processing) + * @param x Column coordinate + * @param y Row coordinate + * @return Combined map of nodes + */ + std::unordered_map get_combined_nodes( + Coordinate x, Coordinate y) const; + + /** + * @brief Get all nodes by type + * @param type Node type to filter + * @return Vector of nodes of specified type + */ + std::vector get_nodes_by_type(NodeType type) const; + + /** + * @brief Get sink edge at location + * @param x X coordinate + * @param y Y coordinate + * @return Edges which sinks are in the given location + */ + const std::vector get_sink_edges_at_location(Coordinate x, Coordinate y) const; + + /** + * @brief Check if coordinate is valid + * @param x X coordinate + * @param y Y coordinate + * @return true if coordinates are within grid bounds + */ + bool is_valid_coordinate(Coordinate x, Coordinate y) const; + + /** + * @brief Print lookup statistics + */ + void print_statistics() const; + + /** + * @brief Clear all lookup tables + */ + void clear(); + + private: + // Spatial indexes - SINK and SOURCE nodes are not stored in these two maps + std::vector> + column_lookup_; + std::vector> + row_lookup_; + + // Edge spatial indexes. [x][y] -> std::vector + std::vector>> edge_sink_lookup_; + + // Global lookup - Return a pointer to the node corresponding to the hash + std::unordered_map global_lookup_; + + // Type-based lookup - Return a vector of pointers to nodes of the specified + // type + std::unordered_map> type_lookup_; + + // Grid dimensions + Coordinate fpga_grid_x_; + Coordinate fpga_grid_y_; + + // Empty map for invalid coordinates + std::unordered_map empty_map_; + + // Helper methods + NodeHash build_node_hash(const RRNode& node) const; + void validate_coordinates(Coordinate x, Coordinate y) const; + void index_node(const RRNode& node); + void index_edge(const RRGraph& graph, const RREdge& edge); +}; + +} // namespace crrgenerator From 916404868fc5b6b0db008521b505042a321d3747 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 10:59:59 -0700 Subject: [PATCH 030/120] [vpr][route][crr] add crr thread pool --- .../crr_generator/crr_thread_pool.cpp | 143 +++++++++++++++ .../crr_generator/crr_thread_pool.h | 164 ++++++++++++++++++ 2 files changed, 307 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp new file mode 100644 index 0000000000..20d14867f4 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp @@ -0,0 +1,143 @@ +#include "crr_thread_pool.h" + +namespace crrgenerator { + +// CRRThreadPool implementation + +CRRThreadPool::CRRThreadPool(size_t num_threads) { + if (num_threads == 0) { + num_threads = std::thread::hardware_concurrency(); + } else { + num_threads = std::min( + num_threads, static_cast(std::thread::hardware_concurrency())); + } + + if (num_threads == 0) { + num_threads = 1; + } + + VTR_LOG("Creating CRRThreadPool with %zu threads", num_threads); + + for (size_t i = 0; i < num_threads; ++i) { + workers_.emplace_back(&CRRThreadPool::worker_thread, this); + } +} + +CRRThreadPool::~CRRThreadPool() { + stop(); + + // Wake up all threads + condition_.notify_all(); + + // Wait for all threads to finish + for (auto& worker : workers_) { + if (worker.joinable()) { + worker.join(); + } + } +} + +void CRRThreadPool::wait_for_all() { + std::unique_lock lock(queue_mutex_); + condition_.wait( + lock, [this] { return tasks_.empty() && active_tasks_.load() == 0; }); +} + +size_t CRRThreadPool::get_pending_tasks() const { + std::lock_guard lock(queue_mutex_); + return tasks_.size(); +} + +void CRRThreadPool::stop() { stop_.store(true); } + +void CRRThreadPool::worker_thread() { + while (true) { + std::function task; + + { + std::unique_lock lock(queue_mutex_); + + condition_.wait(lock, [this] { return stop_.load() || !tasks_.empty(); }); + + if (stop_.load() && tasks_.empty()) { + break; + } + + if (!tasks_.empty()) { + task = std::move(tasks_.front()); + tasks_.pop(); + active_tasks_.fetch_add(1); + } + } + + if (task) { + try { + task(); + } catch (const std::exception& e) { + VTR_LOG_ERROR("Exception in worker thread: %s", e.what().c_str()); + } catch (...) { + VTR_LOG_ERROR("Unknown exception in worker thread"); + } + + active_tasks_.fetch_sub(1); + completed_tasks_.fetch_add(1); + condition_.notify_all(); + } + } +} + +// ProgressTracker implementation + +ProgressTracker::ProgressTracker(size_t total_tasks, + const std::string& operation_name) + : total_(total_tasks), + operation_name_(operation_name), + start_time_(std::chrono::steady_clock::now()) { + VTR_LOG("Starting %s: %zu tasks", operation_name_.c_str(), total_); +} + +void ProgressTracker::increment(size_t count) { + size_t new_completed = completed_.fetch_add(count) + count; + + // Log progress at intervals + if (new_completed % std::max(size_t(1), total_ / 20) == 0 || + new_completed == total_) { + log_progress(); + } +} + +double ProgressTracker::get_progress_percentage() const { + if (total_ == 0) return 100.0; + return (static_cast(completed_.load()) / total_) * 100.0; +} + +void ProgressTracker::log_progress() const { + std::lock_guard lock(log_mutex_); + + size_t current_completed = completed_.load(); + double percentage = get_progress_percentage(); + + auto now = std::chrono::steady_clock::now(); + auto elapsed = + std::chrono::duration_cast(now - start_time_); + + if (current_completed < total_) { + // Calculate ETA + if (current_completed > 0) { + auto total_estimated = elapsed * total_ / current_completed; + auto eta = total_estimated - elapsed; + + VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds, ETA: %ds", + operation_name_.c_str(), current_completed, total_, percentage, + elapsed.count(), eta.count()); + } else { + VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds", operation_name_.c_str(), + current_completed, total_, percentage, elapsed.count()); + } + } else { + VTR_LOG("%s: Complete! %zu/%zu tasks in %ds", operation_name_.c_str(), + current_completed, total_, elapsed.count()); + } +} + +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h new file mode 100644 index 0000000000..0471e0966c --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h @@ -0,0 +1,164 @@ +#pragma once + +#include + +#include "crr_common.h" + +namespace crrgenerator { + +/** + * @brief Simple thread pool implementation for parallel processing + * + * This class provides a thread pool for executing tasks in parallel, + * with progress tracking and synchronization support. + */ +class CRRThreadPool { + public: + /** + * @brief Constructor + * @param num_threads Number of worker threads (0 = hardware concurrency) + */ + explicit CRRThreadPool(size_t num_threads = 0); + + /** + * @brief Destructor - waits for all tasks to complete + */ + ~CRRThreadPool(); + + /** + * @brief Submit a task to the thread pool + * @param func Function to execute + * @param args Arguments to pass to the function + * @return Future for the result + */ + template + auto submit(Func&& func, Args&&... args) + -> std::future>; + + /** + * @brief Wait for all submitted tasks to complete + */ + void wait_for_all(); + + /** + * @brief Get the number of worker threads + * @return Number of threads + */ + size_t get_thread_count() const { return workers_.size(); } + + /** + * @brief Get the number of pending tasks + * @return Number of tasks in queue + */ + size_t get_pending_tasks() const; + + /** + * @brief Stop the thread pool (no new tasks accepted) + */ + void stop(); + + /** + * @brief Check if the thread pool is stopped + * @return true if stopped + */ + bool is_stopped() const { return stop_; } + + private: + // Worker threads + std::vector workers_; + + // Task queue + std::queue> tasks_; + + // Synchronization + mutable std::mutex queue_mutex_; + std::condition_variable condition_; + std::atomic stop_{false}; + + // Progress tracking + std::atomic active_tasks_{0}; + std::atomic completed_tasks_{0}; + + // Worker function + void worker_thread(); +}; + +/** + * @brief Progress tracker for parallel operations + * + * Thread-safe progress tracking with logging support. + */ +class ProgressTracker { + public: + ProgressTracker(size_t total_tasks, + const std::string& operation_name = "Processing"); + + /** + * @brief Increment completed task count + * @param count Number of tasks completed (default: 1) + */ + void increment(size_t count = 1); + + /** + * @brief Get current progress as percentage + * @return Progress percentage (0.0 - 100.0) + */ + double get_progress_percentage() const; + + /** + * @brief Get number of completed tasks + * @return Completed task count + */ + size_t get_completed() const { return completed_.load(); } + + /** + * @brief Get total number of tasks + * @return Total task count + */ + size_t get_total() const { return total_; } + + /** + * @brief Check if all tasks are completed + * @return true if complete + */ + bool is_complete() const { return completed_.load() >= total_; } + + /** + * @brief Log current progress + */ + void log_progress() const; + + private: + std::atomic completed_{0}; + size_t total_; + std::string operation_name_; + mutable std::mutex log_mutex_; + std::chrono::steady_clock::time_point start_time_; +}; + +// Template implementation for CRRThreadPool::submit +template +auto CRRThreadPool::submit(Func&& func, Args&&... args) + -> std::future> { + using return_type = std::invoke_result_t; + + auto task = std::make_shared>( + std::bind(std::forward(func), std::forward(args)...)); + + std::future result = task->get_future(); + + { + std::unique_lock lock(queue_mutex_); + + if (stop_) { + throw std::runtime_error("Cannot submit task to stopped CRRThreadPool"); + } + + tasks_.emplace([task]() { (*task)(); }); + } + + condition_.notify_one(); + return result; +} + +} // namespace crrgenerator From 2af1e09d240b3afd1c6f8b5f0d38eade20d7f308 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 12:33:25 -0700 Subject: [PATCH 031/120] [vpr][route][crr] add crr_generator --- .../crr_generator/crr_generator.cpp | 252 ++++++++++++++++++ .../crr_generator/crr_generator.h | 64 +++++ 2 files changed, 316 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp new file mode 100644 index 0000000000..98b209caeb --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -0,0 +1,252 @@ +#include "crr_generator.h" + +#include + +#include "globals.h" +#include "vtr_log.h" +#include "vtr_assert.h" + +namespace crrgenerator { + +CRRGraphGenerator::CRRGraphGenerator(const t_crr_opts& crr_opts, + const RRGraph& input_graph, + const NodeLookupManager& node_lookup, + const SwitchBlockManager& sb_manager, + const std::string& output_graph_xml) + : crr_opts_(crr_opts), + input_graph_(input_graph), + node_lookup_(node_lookup), + sb_manager_(sb_manager), + output_graph_xml_(output_graph_xml) {} + +void CRRGraphGenerator::run() { + auto start_time = std::chrono::steady_clock::now(); + + VTR_LOG("Starting RR Graph parsing process"); + + try { + // Initialize all components + initialize_components(); + + // Build connections + build_connections(); + + // Create output graph + create_output_graph(); + + // Write output files + write_output_files(); + + // Print summary + print_processing_summary(); + + auto end_time = std::chrono::steady_clock::now(); + auto duration = + std::chrono::duration_cast(end_time - start_time); + + VTR_LOG("RR Graph parsing completed successfully in %ds", duration.count()); + } catch (const std::exception& e) { + VTR_LOG_ERROR("RR Graph parsing failed: %s", e.what().c_str()); + } +} + +void CRRGraphGenerator::initialize_components() { + VTR_LOG("CRR Graph Generator: Initializing components"); + + // Initialize XML handler + xml_handler_ = std::make_unique(); + + // Initialize connection builder + connection_builder_ = std::make_unique(input_graph_, node_lookup_, sb_manager_); + + // Initialize switch manager + switch_manager_ = std::make_unique(); + + // Initialize thread pool if parallel processing is enabled + VTR_ASSERT(crr_opts_.crr_num_threads > 0); + thread_pool_ = std::make_unique(crr_opts_.crr_num_threads); + VTR_LOG("CRR Graph Generator: Parallel processing enabled with %d threads", + thread_pool_->get_thread_count()); + + VTR_LOG("CRR Graph Generator: All components initialized successfully"); +} + +void CRRGraphGenerator::build_connections() { + VTR_LOG("CRR Graph Generator: Building connections"); + + // Initialize connection builder + const DeviceGrid& grid = g_vpr_ctx.device().grid; + connection_builder_->initialize(grid.width(), + grid.height(), + crr_opts_.annotated_rr_graph); + + VTR_LOG("CRR Graph Generator: Connection building completed"); +} + +void CRRGraphGenerator::create_output_graph() { + VTR_LOG("CRR Graph Generator: Creating output graph"); + + // Create new graph based on input graph + output_graph_ = std::make_unique(input_graph_); + + // Add new switches to output graph + if (crr_opts_.annotated_rr_graph) { + size_t nxt_switch_id = + connection_builder_->get_default_swithes_map().size(); + int max_sw_delay_ps = sb_manager_.get_max_switch_delay_ps(); + std::string default_sw_type = ""; + Timing default_timing; + Sizing default_sizing; + + // Get default timing and sizing from input graph + for (const auto& graph_sw : input_graph_.get_switches()) { + std::string sw_name = graph_sw.get_name(); + std::transform(sw_name.begin(), sw_name.end(), sw_name.begin(), + ::tolower); + if (sw_name.find("l1") != std::string::npos || + sw_name.find("l4") != std::string::npos) { + default_sw_type = graph_sw.get_type(); + default_timing = graph_sw.get_timing(); + default_sizing = graph_sw.get_sizing(); + } + } + + // Add sw_zero switch - we don't use delayless switch because OpenFPGA doesn't work with it. + Switch sw_zero(static_cast(nxt_switch_id), "sw_zero", default_sw_type, Timing(0, 0), default_sizing); + output_graph_->add_switch(sw_zero); + + // Add new switches to output graph + for (int curr_sw_delay_ps = static_cast(nxt_switch_id) + 1; + curr_sw_delay_ps <= max_sw_delay_ps; curr_sw_delay_ps++) { + float curr_sw_delay_s = static_cast(curr_sw_delay_ps) * 1e-12f; + Switch curr_switch( + static_cast(curr_sw_delay_ps), + "sw_" + std::to_string(curr_sw_delay_ps), default_sw_type, + Timing(default_timing.Cin, curr_sw_delay_s), default_sizing); + output_graph_->add_switch(curr_switch); + } + } + + // Get all connections from connection builder + auto all_connections = connection_builder_->get_all_connections(); + + auto preserved_edges = input_graph_.get_preserved_edges( + crr_opts_.preserve_input_pins, + crr_opts_.preserve_output_pins); + + VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu", preserved_edges.size()); + + // Clear existing edges and add new ones + output_graph_->get_edges().clear(); + + // Add preserved edges + for (const auto& edge : preserved_edges) { + output_graph_->add_edge(edge); + } + + add_custom_edges(); + + output_graph_->sort_nodes(); + output_graph_->sort_edges(); + output_graph_->shrink_to_fit(); + + VTR_LOG("CRR Graph Generator: Output graph created with %zu edges", + output_graph_->get_edge_count()); +} + +void CRRGraphGenerator::add_custom_edges() { + VTR_LOG("CRR Graph Generator: Adding custom edges"); + + // Add new connections + const DeviceGrid& grid = g_vpr_ctx.device().grid; + size_t total_tiles = + static_cast((grid.width() + 1) * (grid.height() + 1)); + ProgressTracker tracker(total_tiles, "Adding new connections"); + std::vector> futures; + std::mutex graph_mutex; + + for (Coordinate tile_x = 0; tile_x <= grid.width(); tile_x++) { + for (Coordinate tile_y = 0; tile_y <= grid.height(); tile_y++) { + auto fut = thread_pool_->submit([this, tile_x, tile_y, &graph_mutex, &tracker]() { + std::vector tile_connections = + connection_builder_->get_tile_connections(tile_x, tile_y); + + { + std::lock_guard lock(graph_mutex); + for (const auto& connection : tile_connections) { + output_graph_->add_edge(connection.src_node(), + connection.sink_node(), + connection.switch_id()); + } + } + + tracker.increment(); + }); + futures.push_back(std::move(fut)); + } + } + + // Wait for all tasks to complete + for (auto& fut : futures) { + fut.get(); + } +} + +void CRRGraphGenerator::write_output_files() { + if (!output_graph_xml_.empty()) { + VTR_LOG("CRR Graph Generator: Writing output files"); + xml_handler_->write_rr_graph(output_graph_xml_, *output_graph_); + VTR_LOG("CRR Graph Generator: Output files written successfully"); + } else { + VTR_LOG("CRR Graph Generator: No output file specified"); + } +} + +void CRRGraphGenerator::print_processing_summary() { + VTR_LOG("CRR Graph Generator: === Processing Summary ==="); + + VTR_LOG("CRR Graph Generator: Input graph:"); + VTR_LOG(" Nodes: %zu", input_graph_.get_node_count()); + VTR_LOG(" Edges: %zu", input_graph_.get_edge_count()); + VTR_LOG(" Switches: %zu", input_graph_.get_switch_count()); + + VTR_LOG("CRR Graph Generator: Output graph:"); + VTR_LOG(" Nodes: %zu", output_graph_->get_node_count()); + VTR_LOG(" Edges: %zu", output_graph_->get_edge_count()); + VTR_LOG(" Switches: %zu", output_graph_->get_switch_count()); + + int new_edges = + static_cast(output_graph_->get_edge_count()) - + static_cast(input_graph_.get_edge_count()); + VTR_LOG(" New edges added: %d", new_edges); + + VTR_LOG("Switch blocks processed: %zu", sb_manager_.get_all_patterns().size()); + VTR_LOG("Total connections: %zu", sb_manager_.get_total_connections()); + + VTR_LOG("Grid locations processed: %dx%d", config_.get_fpga_grid_x(), + config_.get_fpga_grid_y()); + +} + +void CRRGraphGenerator::validate_processing_results() { + // Basic validation + if (!output_graph_) { + throw RRGeneratorException("Output graph was not created"); + } + + if (output_graph_->get_node_count() == 0) { + throw RRGeneratorException("Output graph has no nodes"); + } + + if (output_graph_->get_edge_count() == 0) { + throw RRGeneratorException("Output graph has no edges"); + } + + if (output_graph_->get_switch_count() == 0) { + throw RRGeneratorException("Output graph has no switches"); + } + + VTR_LOG("Processing results validation passed"); +} + +} // namespace crrgenerator \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h new file mode 100644 index 0000000000..905b48fa4a --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h @@ -0,0 +1,64 @@ +#pragma once + +#include +#include + +#include "vpr_types.h" +#include "crr_common.h" +#include "crr_connection_builder.h" +#include "node_lookup_manager.h" +#include "custom_rr_graph.h" +#include "switch_block_manager.h" +#include "switch_manager.h" +#include "crr_thread_pool.h" +#include "xml_handler.h" + +namespace crrgenerator { + +/** + * @brief Main orchestrator for RR graph parsing and generation + * + * This class coordinates all subsystems to read input graphs, + * process switch block configurations, and generate output graphs. + */ +class CRRGraphGenerator { +public: + CRRGraphGenerator(const t_crr_opts& crr_opts, + const RRGraph& input_graph, + const NodeLookupManager& node_lookup, + const SwitchBlockManager& sb_manager, + const std::string& output_graph_xml); + ~CRRGraphGenerator() = default; + + /** + * @brief Run the complete parsing and generation process + */ + void run(); + +private: + const t_crr_opts& crr_opts_; + const RRGraph& input_graph_; + const NodeLookupManager& node_lookup_; + const SwitchBlockManager& sb_manager_; + const std::string& output_graph_xml_; + + std::unique_ptr output_graph_; + std::unique_ptr connection_builder_; + std::unique_ptr switch_manager_; + std::unique_ptr thread_pool_; + std::unique_ptr xml_handler_; + + // Processing methods + void initialize_components(); + void process_switch_blocks(); + void build_connections(); + void create_output_graph(); + void add_custom_edges(); + void write_output_files(); + + // Utility methods + void print_processing_summary(); + void validate_processing_results(); +}; + +} // namespace crrgenerator \ No newline at end of file From 01eca68eb0d5773d5fe5064ce2ea0aa16960df21 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 12:34:25 -0700 Subject: [PATCH 032/120] [vpr][route][crr] add crr_conneciton_builder --- .../crr_generator/crr_connection_builder.cpp | 595 ++++++++++++++++++ .../crr_generator/crr_connection_builder.h | 180 ++++++ 2 files changed, 775 insertions(+) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp new file mode 100644 index 0000000000..b888e16313 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -0,0 +1,595 @@ +#include "crr_connection_builder.h" + +#include +#include +// #include + +// using json = nlohmann::json; +// using ordered_json = nlohmann::ordered_json; + +namespace crrgenerator { + +static bool is_integer(const std::string& s) { + int value; + auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value); + return ec == std::errc() && ptr == s.data() + s.size(); +} + +// static void write_node_storage_to_json( +// const std::vector& storage_sw_names, +// const std::vector>& storage_source_nodes, +// const std::vector>& storage_sink_nodes, +// const std::string& filename) { +// assert(storage_sw_names.size() == storage_source_nodes.size()); +// assert(storage_sw_names.size() == storage_sink_nodes.size()); + +// ordered_json j; + +// for (size_t i = 0; i < storage_sw_names.size(); ++i) { +// ordered_json source_nodes_json; +// for (const auto& [idx, node] : storage_source_nodes[i]) { +// source_nodes_json[std::to_string(idx)] = node; +// } + +// ordered_json sink_nodes_json; +// for (const auto& [idx, node] : storage_sink_nodes[i]) { +// sink_nodes_json[std::to_string(idx)] = node; +// } + +// j[storage_sw_names[i]] = {{"source_nodes", source_nodes_json}, +// {"sink_nodes", sink_nodes_json}}; +// } + +// std::ofstream file(filename); +// file << j.dump(4); // Pretty print with indent of 4 +// } + +CRRConnectionBuilder::CRRConnectionBuilder(const RRGraph& rr_graph, + const NodeLookupManager& node_lookup, + const SwitchBlockManager& sb_manager) + : rr_graph_(rr_graph), node_lookup_(node_lookup), sb_manager_(sb_manager) {} + +void CRRConnectionBuilder::initialize( + Coordinate fpga_grid_x, + Coordinate fpga_grid_y, + bool is_annotated_excel) { + + fpga_grid_x_ = fpga_grid_x; + fpga_grid_y_ = fpga_grid_y; + is_annotated_excel_ = is_annotated_excel; + + for (const auto& original_switch : rr_graph_.get_switches()) { + std::string switch_name = original_switch.get_name(); + std::transform(switch_name.begin(), switch_name.end(), switch_name.begin(), + ::tolower); + + if (switch_name.find("delayless") != std::string::npos) { + VTR_LOG("Adding delayless switch: %s", switch_name.c_str()); + default_switch_id_["delayless"] = original_switch.get_id(); + } else if (switch_name.find("ipin") != std::string::npos) { + VTR_LOG("Adding ipin switch: %s", switch_name.c_str()); + default_switch_id_["ipin"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l1(_.*)?)"))) { + VTR_LOG("Adding l1 switch: %s", switch_name.c_str()); + default_switch_id_["l1"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l2(_.*)?)"))) { + VTR_LOG("Adding l2 switch: %s", switch_name.c_str()); + default_switch_id_["l2"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l4(_.*)?)"))) { + VTR_LOG("Adding l4 switch: %s", switch_name.c_str()); + default_switch_id_["l4"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l8(_.*)?)"))) { + VTR_LOG("Adding l8 switch: %s", switch_name.c_str()); + default_switch_id_["l8"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l12(_.*)?)"))) { + VTR_LOG("Adding l12 switch: %s", switch_name.c_str()); + default_switch_id_["l12"] = original_switch.get_id(); + } else { + VTR_LOG_ERROR("Unknown switch type: %s", switch_name.c_str()); + } + } + + assert(default_switch_id_.size() == rr_graph_.get_switches().size()); + sw_zero_id_ = static_cast(rr_graph_.get_switches().size()); + + // Total locations is the number of locations on the FPGA grid minus the 4 + // corner locations. + total_locations_ = static_cast(fpga_grid_x_ * fpga_grid_y_) - 4; + processed_locations_ = 0; + + all_connections_.resize(static_cast(fpga_grid_x_ + 1), + std::vector>(static_cast(fpga_grid_y_ + 1)) + ); + + VTR_LOG("CRRConnectionBuilder initialized for %d x %d grid (%zu locations)", + fpga_grid_x_, fpga_grid_y_, total_locations_); +} + +void CRRConnectionBuilder::build_connections_for_location(Coordinate x, + Coordinate y, + std::vector& tile_connections) { + + // Find matching switch block pattern + std::string sw_name = fmt::format("SB_{}__{}_", x, y); + std::string pattern = sb_manager_.find_matching_pattern(sw_name); + tile_connections.clear(); + + if (pattern.empty()) { + VTR_LOG_DEBUG("No pattern found for switch block at (%d, %d)", x, y); + return; + } + + const DataFrame* df = sb_manager_.get_switch_block_dataframe(pattern); + if (df == nullptr) { + VTR_LOG_WARN("No dataframe found for pattern '%s' at (%d, %d)", pattern.c_str(), x, y); + return; + } + + VTR_LOG("Processing switch block '%s' with pattern '%s' at (%d, %d)", + sw_name.c_str(), pattern.c_str(), x, y); + + // Get combined nodes for this location + auto combined_nodes = node_lookup_.get_combined_nodes(x, y); + + // Get vertical and horizontal nodes + auto source_nodes = get_vertical_nodes(x, y, *df, combined_nodes); + auto sink_nodes = get_horizontal_nodes(x, y, *df, combined_nodes); + + // Build connections based on dataframe + for (auto row_iter = df->begin(); row_iter != df->end(); ++row_iter) { + size_t row_idx = row_iter.get_row_index(); + if (row_idx < NUM_EMPTY_ROWS) continue; + + for (size_t col_idx = NUM_EMPTY_COLS; col_idx < df->cols(); ++col_idx) { + const Cell& cell = df->at(row_idx, col_idx); + + if (!cell.is_empty()) { + auto source_it = source_nodes.find(row_idx); + auto sink_it = sink_nodes.find(col_idx); + + if (source_it != source_nodes.end() && sink_it != sink_nodes.end()) { + NodeId source_node = source_it->second; + NodeType source_node_type = rr_graph_.get_node(source_node)->get_type(); + NodeId sink_node = sink_it->second; + NodeType sink_node_type = rr_graph_.get_node(sink_node)->get_type(); + // If the source node is an IPIN, then it should be considered as + // a sink of the connection. + if (source_node_type == NodeType::IPIN) { + SwitchId switch_id = + get_edge_switch_id(cell.as_string(), + to_string(source_node_type), + sink_node, + source_node); + + tile_connections.emplace_back(source_node, sink_node, switch_id); + } else { + int segment_length = -1; + if (sink_node_type == NodeType::CHANX || + sink_node_type == NodeType::CHANY) { + segment_length = rr_graph_.get_segment(rr_graph_.get_node(sink_node)->get_segment().segment_id)->get_length(); + } + SwitchId switch_id = + get_edge_switch_id(cell.as_string(), + to_string(sink_node_type), + source_node, + sink_node, + segment_length); + + tile_connections.emplace_back(sink_node, source_node, switch_id); + } + } + } + } + } + + { + std::lock_guard lock(connections_mutex_); + storage_sw_names_.push_back(sw_name); + storage_source_nodes_.push_back(source_nodes); + storage_sink_nodes_.push_back(sink_nodes); + } + + std::sort(tile_connections.begin(), tile_connections.end()); + tile_connections.erase(std::unique(tile_connections.begin(), tile_connections.end()), tile_connections.end()); + tile_connections.shrink_to_fit(); + + VTR_LOG_DEBUG("Generated %zu connections for location (%d, %d)", + tile_connections.size(), x, y); +} + +std::vector CRRConnectionBuilder::get_tile_connections(Coordinate tile_x, Coordinate tile_y) { + std::vector tile_connections; + build_connections_for_location(tile_x, tile_y, tile_connections); + + return tile_connections; +} + +std::map CRRConnectionBuilder::get_vertical_nodes( + Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& + node_lookup) { + std::map source_nodes; + std::string prev_seg_type = ""; + int prev_seg_index = -1; + Side prev_side = Side::INVALID; + int prev_ptc_number = 0; + + for (size_t row = NUM_EMPTY_ROWS; row < df.rows(); ++row) { + SegmentInfo info = parse_segment_info(df, row, true); + NodeId node_id = 0; + + if (info.side == Side::IPIN || info.side == Side::OPIN) { + node_id = process_opin_ipin_node(info, x, y, node_lookup); + } else if (info.side == Side::LEFT || info.side == Side::RIGHT || + info.side == Side::TOP || info.side == Side::BOTTOM) { + node_id = + process_channel_node(info, x, y, node_lookup, prev_seg_index, + prev_side, prev_seg_type, prev_ptc_number, true); + } + + if (node_id > 0) { + source_nodes[row] = node_id; + } + + prev_seg_type = info.seg_type; + prev_side = info.side; + } + + return source_nodes; +} + +std::map CRRConnectionBuilder::get_horizontal_nodes( + Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& + node_lookup) { + std::map sink_nodes; + std::string prev_seg_type = ""; + int prev_seg_index = -1; + Side prev_side = Side::INVALID; + int prev_ptc_number = 0; + + for (size_t col = NUM_EMPTY_COLS; col < df.cols(); ++col) { + SegmentInfo info = parse_segment_info(df, col, false); + if (info.side == Side::INVALID) { + continue; + } + NodeId node_id = 0; + + if (info.side == Side::IPIN) { + node_id = process_opin_ipin_node(info, x, y, node_lookup); + } else if (info.side == Side::LEFT || info.side == Side::RIGHT || + info.side == Side::TOP || info.side == Side::BOTTOM) { + node_id = process_channel_node(info, x, y, node_lookup, prev_seg_index, + prev_side, prev_seg_type, prev_ptc_number, + false); + } + + if (node_id > 0) { + sink_nodes[col] = node_id; + } + + prev_seg_type = info.seg_type; + prev_side = info.side; + } + + return sink_nodes; +} + +CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info( + const DataFrame& df, size_t row_or_col, bool is_vertical) { + SegmentInfo info; + + if (is_vertical) { + // Vertical processing (rows) + const Cell& side_cell = df.at(row_or_col, 0); + const Cell& type_cell = df.at(row_or_col, 1); + const Cell& index_cell = df.at(row_or_col, 2); + const Cell& tap_cell = df.at(row_or_col, 3); + + if (!side_cell.is_empty()) { + info.side = string_to_side(side_cell.as_string()); + } + if (!type_cell.is_empty()) { + info.seg_type = type_cell.as_string(); + } + if (!index_cell.is_empty()) { + info.seg_index = static_cast(index_cell.as_int()); + } + if (!tap_cell.is_empty() && tap_cell.is_number()) { + info.tap = static_cast(tap_cell.as_int()); + } + } else { + // Horizontal processing (columns) + const Cell& side_cell = df.at(0, row_or_col); + const Cell& type_cell = df.at(1, row_or_col); + const Cell& index_cell = + df.at(3, row_or_col); // Note: row 3 for horizontal + const Cell& tap_cell = df.at(4, row_or_col); // Note: row 4 for horizontal + + if (!side_cell.is_empty()) { + info.side = string_to_side(side_cell.as_string()); + } + if (!type_cell.is_empty()) { + info.seg_type = type_cell.as_string(); + } + if (!index_cell.is_empty()) { + info.seg_index = static_cast(index_cell.as_int()); + } + if (!tap_cell.is_empty() && tap_cell.is_number()) { + info.tap = static_cast(tap_cell.as_int()); + } else { + info.tap = 1; + } + } + + return info; +} + +NodeId CRRConnectionBuilder::process_opin_ipin_node( + const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& + node_lookup) { + assert(info.side == Side::OPIN || info.side == Side::IPIN); + NodeType node_type = + (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; + NodeHash hash = + std::make_tuple(node_type, std::to_string(info.seg_index), x, x, y, y); + + auto it = node_lookup.find(hash); + if (it != node_lookup.end()) { + return it->second->get_id(); + } + + return 0; +} + +NodeId CRRConnectionBuilder::process_channel_node( + const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup, + int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, + int& prev_ptc_number, bool is_vertical) { + // Check grid boundaries + if ((info.side == Side::RIGHT && x == fpga_grid_x_) || + (info.side == Side::TOP && y == fpga_grid_y_)) { + return 0; + } + + int seg_length = std::stoi( + info.seg_type.substr(1)); // Extract number from "L1", "L4", etc. + + // Update PTC number based on previous segment + if (prev_seg_type != info.seg_type) { + prev_ptc_number = prev_seg_index; + } + if (prev_side != info.side) { + prev_ptc_number = 0; + prev_seg_index = 0; + } + std::string seg_type_label = get_segment_type_label(info.side); + Direction direction = get_direction_for_side(info.side, is_vertical); + + // Calculate segment coordinates + Coordinate x_low, x_high, y_low, y_high; + int physical_length, truncated; + calculate_segment_coordinates(info, x, y, x_low, x_high, y_low, y_high, + physical_length, truncated, is_vertical); + + // Calculate starting PTC point + int seg_index = (info.seg_index - 1) * seg_length * 2; + seg_index += prev_ptc_number; + prev_seg_index = + std::max({prev_seg_index, seg_index + 2*seg_length}); + + seg_index += (direction == Direction::INC_DIR) ? 0 : 1; + seg_index += (direction == Direction::DEC_DIR) ? 2 * (seg_length - 1) : 0; + + // Calculate PTC sequence + std::string seg_sequence = get_ptc_sequence( + seg_index, seg_length, physical_length, direction, truncated); + + // Create node hash and lookup + NodeHash hash = std::make_tuple(string_to_node_type(seg_type_label), + seg_sequence, x_low, x_high, y_low, y_high); + auto it = node_lookup.find(hash); + + if (it != node_lookup.end()) { + return it->second->get_id(); + } else { + VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)", seg_type_label.c_str(), + seg_sequence.c_str(), x_low, y_low, x_high, y_high); + return 0; + } +} + +void CRRConnectionBuilder::calculate_segment_coordinates( + const SegmentInfo& info, Coordinate x, Coordinate y, Coordinate& x_low, + Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, + int& physical_length, int& truncated, bool is_vertical) { + int seg_length = std::stoi(info.seg_type.substr(1)); + int tap = info.tap; + + // Calculate initial coordinates based on side + if (is_vertical) { + switch (info.side) { + case Side::LEFT: + x_high = x + (seg_length - tap); + x_low = x - (tap - 1); + y_high = y; + y_low = y; + break; + case Side::RIGHT: + x_high = x + tap; + x_low = x + tap + 1 - seg_length; + y_high = y; + y_low = y; + break; + case Side::TOP: + x_high = x; + x_low = x; + y_high = y + tap; + y_low = y + 1 - seg_length + tap; + break; + case Side::BOTTOM: + x_high = x; + x_low = x; + y_high = y + seg_length - tap; + y_low = y - tap + 1; + break; + default: + x_high = x_low = x; + y_high = y_low = y; + break; + } + } else { + switch (info.side) { + case Side::LEFT: + x_high = x + tap - 1; + x_low = x - seg_length + tap; + y_high = y; + y_low = y; + break; + case Side::RIGHT: + x_high = x + seg_length; + x_low = x + 1; + y_high = y; + y_low = y; + break; + case Side::TOP: + x_high = x; + x_low = x; + y_high = y + seg_length; + y_low = y + 1; + break; + case Side::BOTTOM: + x_high = x; + x_low = x; + y_high = y; + y_low = y - seg_length + tap; + break; + default: + x_high = x_low = x; + y_high = y_low = y; + break; + } + } + + // Calculate truncation + truncated = (std::max(x_low, static_cast(1)) - x_low) - + (x_high - std::min(x_high, fpga_grid_x_)); + truncated += (std::max(y_low, static_cast(1)) - y_low) - + (y_high - std::min(y_high, fpga_grid_y_)); + + // Apply grid boundaries + x_low = std::max(x_low, static_cast(1)); + y_low = std::max(y_low, static_cast(1)); + x_high = std::min(x_high, fpga_grid_x_); + y_high = std::min(y_high, fpga_grid_y_); + + // Calculate physical length + physical_length = (x_high - x_low) + (y_high - y_low) + 1; +} + +Direction CRRConnectionBuilder::get_direction_for_side(Side side, + bool is_vertical) { + if (is_vertical) { + return (side == Side::RIGHT || side == Side::TOP) ? Direction::DEC_DIR + : Direction::INC_DIR; + } else { + return (side == Side::RIGHT || side == Side::TOP) ? Direction::INC_DIR + : Direction::DEC_DIR; + } +} + +std::string CRRConnectionBuilder::get_segment_type_label(Side side) { + return (side == Side::LEFT || side == Side::RIGHT) ? "CHANX" : "CHANY"; +} + +std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, + int /*seg_length*/, + int physical_length, + Direction direction, + int truncated) { + std::vector sequence; + + if (direction == Direction::DEC_DIR) { + seg_index -= (2 * truncated > 0) ? 2 * truncated : 0; + for (int i = 0; i < physical_length; ++i) { + sequence.push_back(std::to_string(seg_index - (i * 2))); + } + } else { + seg_index += (2 * truncated > 0) ? 2 * truncated : 0; + for (int i = 0; i < physical_length; ++i) { + sequence.push_back(std::to_string(seg_index + (i * 2))); + } + } + + std::string result; + for (size_t i = 0; i < sequence.size(); ++i) { + if (i > 0) result += ","; + result += sequence[i]; + } + return result; +} + +SwitchId CRRConnectionBuilder::get_edge_switch_id( + const std::string& cell_value, const std::string& sink_node_type, + NodeId /*source_node*/, NodeId /*sink_node*/, + int segment_length) { + std::string lower_case_sink_node_type = sink_node_type; + std::transform(lower_case_sink_node_type.begin(), + lower_case_sink_node_type.end(), + lower_case_sink_node_type.begin(), ::tolower); + + if (is_integer(cell_value) && is_annotated_excel_) { + // TODO: This is a temporary solution. We need to have an API call to get + // the switch id from delay. + if (cell_value == "0") { + return sw_zero_id_; + } + int switch_delay_ps = std::stoi(cell_value); + int switch_id = switch_delay_ps; + return static_cast(switch_id); + } else { + std::string switch_id_key = ""; + if (segment_length > 0) { + switch_id_key = "l" + std::to_string(segment_length); + } else { + switch_id_key = lower_case_sink_node_type; + } + + std::string capitalized_switch_id_key = switch_id_key; + std::transform(capitalized_switch_id_key.begin(), + capitalized_switch_id_key.end(), + capitalized_switch_id_key.begin(), ::toupper); + + if (default_switch_id_.find(switch_id_key) != + default_switch_id_.end()) { + return default_switch_id_[switch_id_key]; + } else if (default_switch_id_.find(capitalized_switch_id_key) != + default_switch_id_.end()) { + return default_switch_id_[capitalized_switch_id_key]; + } else { + throw std::runtime_error("Default switch id not found for Node Type: " + + lower_case_sink_node_type + " and Switch ID Key: " + + capitalized_switch_id_key); + } + } +} + +bool CRRConnectionBuilder::is_valid_grid_location(Coordinate x, + Coordinate y) const { + return x >= 1 && x <= fpga_grid_x_ && y >= 1 && y <= fpga_grid_y_; +} + +void CRRConnectionBuilder::update_progress() { + size_t current = processed_locations_.fetch_add(1) + 1; + if (current % std::max(size_t(1), total_locations_ / 20) == 0 || + current == total_locations_) { + double percentage = + (static_cast(current) / total_locations_) * 100.0; + VTR_LOG("Connection building progress: %zu/%zu (%.1f%%)", current, + total_locations_, percentage); + } +} + +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h new file mode 100644 index 0000000000..e2afafeb36 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -0,0 +1,180 @@ +#pragma once + +#include "crr_common.h" +#include "data_frame_processor.h" +#include "node_lookup_manager.h" +#include "crr_switch_block_manager.h" +#include "crr_thread_pool.h" + +namespace crrgenerator { + +/** + * @brief Builds connections between routing nodes based on switch block + * configurations + * + * This class processes switch block configurations and generates routing + * connections between nodes, supporting both parallel and sequential + * processing. + */ +class CRRConnectionBuilder { + public: + CRRConnectionBuilder(const RRGraph& rr_graph, + const NodeLookupManager& node_lookup, + const SwitchBlockManager& sb_manager); + + /** + * @brief Initialize the connection builder + * @param node_lookup Node lookup manager + * @param sb_manager Switch block manager + * @param original_switches Original switches from the input graph + */ + void initialize(Coordinate fpga_grid_x, + Coordinate fpga_grid_y, + bool is_annotated_excel); + + /** + * @brief Get connections for a tile + * @param tile_x Tile x coordinate + * @param tile_y Tile y coordinate + * @return Vector of connections + */ + std::vector get_tile_connections(Coordinate tile_x, Coordinate tile_y); + + /** + * @brief Get all generated connections + * @return Vector of all connections + */ + const std::vector>>& get_all_connections() const { + return all_connections_; + } + + /** + * @brief Get connection count + * @return Number of connections generated + */ + size_t get_connection_count() const { + size_t count = 0; + for (const auto& x : all_connections_) { + for (const auto& y : x) { + count += y.size(); + } + } + return count; + } + + /** + * @brief Get the default switch id map + * @return Map of default switch id + */ + std::map get_default_swithes_map() const { + return default_switch_id_; + } + + /** + * @brief Clear all connections + */ + void clear() { all_connections_.clear(); } + void remove_tile_connections(Coordinate x, Coordinate y) { + all_connections_[static_cast(x)][static_cast(y)].clear(); + all_connections_[static_cast(x)][static_cast(y)].shrink_to_fit(); + } + + private: + + // Info from config + Coordinate fpga_grid_x_; + Coordinate fpga_grid_y_; + bool is_annotated_excel_; + + // Dependencies + const RRGraph& rr_graph_; + const NodeLookupManager& node_lookup_; + const SwitchBlockManager& sb_manager_; + SwitchId sw_zero_id_; + + std::vector storage_sw_names_; + std::vector> storage_source_nodes_; + std::vector> storage_sink_nodes_; + + // Generated connections + std::vector>> all_connections_; + std::mutex connections_mutex_; + + // Processing state + std::atomic processed_locations_{0}; + size_t total_locations_{0}; + + // Default switch id based on the node type + std::map default_switch_id_; + + // Connection building methods + void build_connections_for_location(Coordinate x, + Coordinate y, + std::vector& tile_connections); + + // Node processing methods + std::map get_vertical_nodes( + Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& + node_lookup); + + std::map get_horizontal_nodes( + Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& + node_lookup); + + // PTC sequence calculation + std::string get_ptc_sequence(int seg_index, int seg_length, + int physical_length, Direction direction, + int truncated); + + // Segment processing helpers + struct SegmentInfo { + Side side; + std::string seg_type; + int seg_index; + int tap; + + SegmentInfo() : side(Side::INVALID), seg_index(-1), tap(-1) {} + SegmentInfo(Side s, const std::string& type, int index, int t = 1) + : side(s), seg_type(type), seg_index(index), tap(t) {} + }; + + SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, + bool is_vertical); + NodeId process_opin_ipin_node( + const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& + node_lookup); + NodeId process_channel_node(const SegmentInfo& info, Coordinate x, + Coordinate y, + const std::unordered_map& node_lookup, + int& prev_seg_index, Side& prev_side, + std::string& prev_seg_type, int& prev_ptc_number, + bool is_vertical); + + // Coordinate and direction calculations + void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, + Coordinate y, Coordinate& x_low, + Coordinate& x_high, Coordinate& y_low, + Coordinate& y_high, int& physical_length, + int& truncated, bool is_vertical); + + Direction get_direction_for_side(Side side, bool is_vertical); + std::string get_segment_type_label(Side side); + + // Return the switch id of an edge between two nodes + SwitchId get_edge_switch_id(const std::string& cell_value, + const std::string& sink_node_type, + NodeId source_node, NodeId sink_node, + int segment_length=-1); + + // Validation and bounds checking + bool is_valid_grid_location(Coordinate x, Coordinate y) const; + + // Progress tracking + void update_progress(); +}; + +} // namespace crrgenerator From d942d0e4b88fbadbe8e229b1a58baede9d0be4bb Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 13:02:09 -0700 Subject: [PATCH 033/120] [vpr][route][crr] remove switch manager --- .../crr_generator/crr_generator.cpp | 14 +++++--------- .../crr_generator/crr_generator.h | 8 +++----- 2 files changed, 8 insertions(+), 14 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index 98b209caeb..88576978b6 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -46,7 +46,7 @@ void CRRGraphGenerator::run() { VTR_LOG("RR Graph parsing completed successfully in %ds", duration.count()); } catch (const std::exception& e) { - VTR_LOG_ERROR("RR Graph parsing failed: %s", e.what().c_str()); + VTR_LOG_ERROR("RR Graph parsing failed: %s", e.what()); } } @@ -57,15 +57,12 @@ void CRRGraphGenerator::initialize_components() { xml_handler_ = std::make_unique(); // Initialize connection builder - connection_builder_ = std::make_unique(input_graph_, node_lookup_, sb_manager_); - - // Initialize switch manager - switch_manager_ = std::make_unique(); + connection_builder_ = std::make_unique(input_graph_, node_lookup_, sb_manager_); // Initialize thread pool if parallel processing is enabled VTR_ASSERT(crr_opts_.crr_num_threads > 0); - thread_pool_ = std::make_unique(crr_opts_.crr_num_threads); - VTR_LOG("CRR Graph Generator: Parallel processing enabled with %d threads", + thread_pool_ = std::make_unique(crr_opts_.crr_num_threads); + VTR_LOG("CRR Graph Generator: Parallel processing enabled with %lu threads", thread_pool_->get_thread_count()); VTR_LOG("CRR Graph Generator: All components initialized successfully"); @@ -223,8 +220,7 @@ void CRRGraphGenerator::print_processing_summary() { VTR_LOG("Switch blocks processed: %zu", sb_manager_.get_all_patterns().size()); VTR_LOG("Total connections: %zu", sb_manager_.get_total_connections()); - VTR_LOG("Grid locations processed: %dx%d", config_.get_fpga_grid_x(), - config_.get_fpga_grid_y()); + VTR_LOG("Grid locations processed: %dx%d", g_vpr_ctx.device().grid.width(), g_vpr_ctx.device().grid.height()); } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h index 905b48fa4a..38107900e0 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h @@ -8,8 +8,7 @@ #include "crr_connection_builder.h" #include "node_lookup_manager.h" #include "custom_rr_graph.h" -#include "switch_block_manager.h" -#include "switch_manager.h" +#include "crr_switch_block_manager.h" #include "crr_thread_pool.h" #include "xml_handler.h" @@ -43,9 +42,8 @@ class CRRGraphGenerator { const std::string& output_graph_xml_; std::unique_ptr output_graph_; - std::unique_ptr connection_builder_; - std::unique_ptr switch_manager_; - std::unique_ptr thread_pool_; + std::unique_ptr connection_builder_; + std::unique_ptr thread_pool_; std::unique_ptr xml_handler_; // Processing methods From 14aa81b07a36bfe065723790d8d111931aad2bd8 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 13:03:08 -0700 Subject: [PATCH 034/120] [vpr][route][crr] remove const vars from df processor --- .../tileable_rr_graph/crr_generator/data_frame_processor.h | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h index 607952b1fc..735d544aba 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h @@ -5,12 +5,9 @@ #include "OpenXLSX.hpp" +#include "crr_common.h" namespace crrgenerator { -constexpr int NUM_EMPTY_ROWS = 5; -constexpr int NUM_EMPTY_COLS = 4; - - /** * @brief Represents a cell in the dataframe */ From 63750308394e31f313cddaef99cbe43239aaa561 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 13:03:41 -0700 Subject: [PATCH 035/120] [vpr][route][crr] fix compile failures --- .../crr_generator/crr_connection_builder.cpp | 5 ++++- .../tileable_rr_graph/crr_generator/crr_thread_pool.cpp | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index b888e16313..50625f9dc9 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -2,6 +2,9 @@ #include #include + +#include "vtr_log.h" +#include "vtr_assert.h" // #include // using json = nlohmann::json; @@ -110,7 +113,7 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, std::vector& tile_connections) { // Find matching switch block pattern - std::string sw_name = fmt::format("SB_{}__{}_", x, y); + std::string sw_name = "SB_" + std::to_string(x) + "__" + std::to_string(y) + "_"; std::string pattern = sb_manager_.find_matching_pattern(sw_name); tile_connections.clear(); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp index 20d14867f4..ee136cfd1f 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp @@ -1,5 +1,8 @@ #include "crr_thread_pool.h" +#include "vtr_log.h" +#include "vtr_assert.h" + namespace crrgenerator { // CRRThreadPool implementation @@ -74,7 +77,7 @@ void CRRThreadPool::worker_thread() { try { task(); } catch (const std::exception& e) { - VTR_LOG_ERROR("Exception in worker thread: %s", e.what().c_str()); + VTR_LOG_ERROR("Exception in worker thread: %s", e.what()); } catch (...) { VTR_LOG_ERROR("Unknown exception in worker thread"); } From 08510ff7b1a7342767a42a042da58ac78a4c8301 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 14:58:31 -0700 Subject: [PATCH 036/120] [vpr][route][crr] fix vtr_log_error --- .../crr_generator/crr_switch_block_manager.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp index a0f26f0d21..842a04f2ee 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp @@ -31,7 +31,7 @@ void SwitchBlockManager::initialize(const std::string& sb_maps_file, } YAML::Node sb_maps = config["SB_MAPS"]; - VTR_LOGV_DEBUG("Found SB_MAPS section with %zu entries\n", sb_maps.size()); + VTR_LOG_DEBUG("Found SB_MAPS section with %zu entries\n", sb_maps.size()); // Process each switch block mapping std::unordered_set unique_files; @@ -62,12 +62,12 @@ void SwitchBlockManager::initialize(const std::string& sb_maps_file, for (const auto& full_path : unique_files) { if (std::filesystem::exists(full_path)) { try { - VTR_LOGV_DEBUG("Attempting to read Excel file: %s\n", full_path.c_str()); + VTR_LOG_DEBUG("Attempting to read Excel file: %s\n", full_path.c_str()); DataFrame df = processor_.read_excel(full_path); df = processor_.process_dataframe(std::move(df), NUM_EMPTY_ROWS, NUM_EMPTY_COLS); file_cache_[full_path] = std::move(df); - VTR_LOGV_DEBUG("Processed %zu connections in %s file\n", + VTR_LOG_DEBUG("Processed %zu connections in %s file\n", file_cache_[full_path].connections, std::filesystem::path(full_path).filename().string()); } catch (const std::exception& e) { From 343a34507421a76cc7671ef435ad58c0351e9e03 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 16:02:43 -0700 Subject: [PATCH 037/120] [vpr][route][crr] fix log messages --- .../crr_generator/crr_connection_builder.cpp | 30 +++++----- .../crr_generator/crr_generator.cpp | 58 +++++++++---------- .../crr_generator/crr_thread_pool.cpp | 14 ++--- .../crr_generator/data_frame_processor.cpp | 40 ++++++------- .../crr_generator/node_lookup_manager.cpp | 2 +- .../crr_generator/xml_handler.cpp | 12 ++-- 6 files changed, 78 insertions(+), 78 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index 50625f9dc9..977eb629ea 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -67,28 +67,28 @@ void CRRConnectionBuilder::initialize( ::tolower); if (switch_name.find("delayless") != std::string::npos) { - VTR_LOG("Adding delayless switch: %s", switch_name.c_str()); + VTR_LOG("Adding delayless switch: %s\n", switch_name.c_str()); default_switch_id_["delayless"] = original_switch.get_id(); } else if (switch_name.find("ipin") != std::string::npos) { - VTR_LOG("Adding ipin switch: %s", switch_name.c_str()); + VTR_LOG("Adding ipin switch: %s\n", switch_name.c_str()); default_switch_id_["ipin"] = original_switch.get_id(); } else if (std::regex_match(switch_name, std::regex(R"(l1(_.*)?)"))) { - VTR_LOG("Adding l1 switch: %s", switch_name.c_str()); + VTR_LOG("Adding l1 switch: %s\n", switch_name.c_str()); default_switch_id_["l1"] = original_switch.get_id(); } else if (std::regex_match(switch_name, std::regex(R"(l2(_.*)?)"))) { - VTR_LOG("Adding l2 switch: %s", switch_name.c_str()); + VTR_LOG("Adding l2 switch: %s\n", switch_name.c_str()); default_switch_id_["l2"] = original_switch.get_id(); } else if (std::regex_match(switch_name, std::regex(R"(l4(_.*)?)"))) { - VTR_LOG("Adding l4 switch: %s", switch_name.c_str()); + VTR_LOG("Adding l4 switch: %s\n", switch_name.c_str()); default_switch_id_["l4"] = original_switch.get_id(); } else if (std::regex_match(switch_name, std::regex(R"(l8(_.*)?)"))) { - VTR_LOG("Adding l8 switch: %s", switch_name.c_str()); + VTR_LOG("Adding l8 switch: %s\n", switch_name.c_str()); default_switch_id_["l8"] = original_switch.get_id(); } else if (std::regex_match(switch_name, std::regex(R"(l12(_.*)?)"))) { - VTR_LOG("Adding l12 switch: %s", switch_name.c_str()); + VTR_LOG("Adding l12 switch: %s\n", switch_name.c_str()); default_switch_id_["l12"] = original_switch.get_id(); } else { - VTR_LOG_ERROR("Unknown switch type: %s", switch_name.c_str()); + VTR_LOG_ERROR("Unknown switch type: %s\n", switch_name.c_str()); } } @@ -104,7 +104,7 @@ void CRRConnectionBuilder::initialize( std::vector>(static_cast(fpga_grid_y_ + 1)) ); - VTR_LOG("CRRConnectionBuilder initialized for %d x %d grid (%zu locations)", + VTR_LOG("CRRConnectionBuilder initialized for %d x %d grid (%zu locations)\n", fpga_grid_x_, fpga_grid_y_, total_locations_); } @@ -118,17 +118,17 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, tile_connections.clear(); if (pattern.empty()) { - VTR_LOG_DEBUG("No pattern found for switch block at (%d, %d)", x, y); + VTR_LOG_DEBUG("No pattern found for switch block at (%d, %d)\n", x, y); return; } const DataFrame* df = sb_manager_.get_switch_block_dataframe(pattern); if (df == nullptr) { - VTR_LOG_WARN("No dataframe found for pattern '%s' at (%d, %d)", pattern.c_str(), x, y); + VTR_LOG_WARN("No dataframe found for pattern '%s' at (%d, %d)\n", pattern.c_str(), x, y); return; } - VTR_LOG("Processing switch block '%s' with pattern '%s' at (%d, %d)", + VTR_LOG("Processing switch block '%s' with pattern '%s' at (%d, %d)\n", sw_name.c_str(), pattern.c_str(), x, y); // Get combined nodes for this location @@ -196,7 +196,7 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, tile_connections.erase(std::unique(tile_connections.begin(), tile_connections.end()), tile_connections.end()); tile_connections.shrink_to_fit(); - VTR_LOG_DEBUG("Generated %zu connections for location (%d, %d)", + VTR_LOG_DEBUG("Generated %zu connections for location (%d, %d)\n", tile_connections.size(), x, y); } @@ -398,7 +398,7 @@ NodeId CRRConnectionBuilder::process_channel_node( if (it != node_lookup.end()) { return it->second->get_id(); } else { - VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)", seg_type_label.c_str(), + VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)\n", seg_type_label.c_str(), seg_sequence.c_str(), x_low, y_low, x_high, y_high); return 0; } @@ -590,7 +590,7 @@ void CRRConnectionBuilder::update_progress() { current == total_locations_) { double percentage = (static_cast(current) / total_locations_) * 100.0; - VTR_LOG("Connection building progress: %zu/%zu (%.1f%%)", current, + VTR_LOG("Connection building progress: %zu/%zu (%.1f%%)\n", current, total_locations_, percentage); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index 88576978b6..640ac5de45 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -22,7 +22,7 @@ CRRGraphGenerator::CRRGraphGenerator(const t_crr_opts& crr_opts, void CRRGraphGenerator::run() { auto start_time = std::chrono::steady_clock::now(); - VTR_LOG("Starting RR Graph parsing process"); + VTR_LOG("Starting RR Graph parsing process\n"); try { // Initialize all components @@ -44,14 +44,14 @@ void CRRGraphGenerator::run() { auto duration = std::chrono::duration_cast(end_time - start_time); - VTR_LOG("RR Graph parsing completed successfully in %ds", duration.count()); + VTR_LOG("RR Graph parsing completed successfully in %ds\n", duration.count()); } catch (const std::exception& e) { - VTR_LOG_ERROR("RR Graph parsing failed: %s", e.what()); + VTR_LOG_ERROR("RR Graph parsing failed: %s\n", e.what()); } } void CRRGraphGenerator::initialize_components() { - VTR_LOG("CRR Graph Generator: Initializing components"); + VTR_LOG("CRR Graph Generator: Initializing components\n"); // Initialize XML handler xml_handler_ = std::make_unique(); @@ -62,14 +62,14 @@ void CRRGraphGenerator::initialize_components() { // Initialize thread pool if parallel processing is enabled VTR_ASSERT(crr_opts_.crr_num_threads > 0); thread_pool_ = std::make_unique(crr_opts_.crr_num_threads); - VTR_LOG("CRR Graph Generator: Parallel processing enabled with %lu threads", + VTR_LOG("CRR Graph Generator: Parallel processing enabled with %lu threads\n", thread_pool_->get_thread_count()); - VTR_LOG("CRR Graph Generator: All components initialized successfully"); + VTR_LOG("CRR Graph Generator: All components initialized successfully\n"); } void CRRGraphGenerator::build_connections() { - VTR_LOG("CRR Graph Generator: Building connections"); + VTR_LOG("CRR Graph Generator: Building connections\n"); // Initialize connection builder const DeviceGrid& grid = g_vpr_ctx.device().grid; @@ -77,11 +77,11 @@ void CRRGraphGenerator::build_connections() { grid.height(), crr_opts_.annotated_rr_graph); - VTR_LOG("CRR Graph Generator: Connection building completed"); + VTR_LOG("CRR Graph Generator: Connection building completed\n"); } void CRRGraphGenerator::create_output_graph() { - VTR_LOG("CRR Graph Generator: Creating output graph"); + VTR_LOG("CRR Graph Generator: Creating output graph\n"); // Create new graph based on input graph output_graph_ = std::make_unique(input_graph_); @@ -131,7 +131,7 @@ void CRRGraphGenerator::create_output_graph() { crr_opts_.preserve_input_pins, crr_opts_.preserve_output_pins); - VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu", preserved_edges.size()); + VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu\n", preserved_edges.size()); // Clear existing edges and add new ones output_graph_->get_edges().clear(); @@ -147,12 +147,12 @@ void CRRGraphGenerator::create_output_graph() { output_graph_->sort_edges(); output_graph_->shrink_to_fit(); - VTR_LOG("CRR Graph Generator: Output graph created with %zu edges", + VTR_LOG("CRR Graph Generator: Output graph created with %zu edges\n", output_graph_->get_edge_count()); } void CRRGraphGenerator::add_custom_edges() { - VTR_LOG("CRR Graph Generator: Adding custom edges"); + VTR_LOG("CRR Graph Generator: Adding custom edges\n"); // Add new connections const DeviceGrid& grid = g_vpr_ctx.device().grid; @@ -191,36 +191,36 @@ void CRRGraphGenerator::add_custom_edges() { void CRRGraphGenerator::write_output_files() { if (!output_graph_xml_.empty()) { - VTR_LOG("CRR Graph Generator: Writing output files"); + VTR_LOG("CRR Graph Generator: Writing output files\n"); xml_handler_->write_rr_graph(output_graph_xml_, *output_graph_); - VTR_LOG("CRR Graph Generator: Output files written successfully"); + VTR_LOG("CRR Graph Generator: Output files written successfully\n"); } else { - VTR_LOG("CRR Graph Generator: No output file specified"); + VTR_LOG("CRR Graph Generator: No output file specified\n"); } } void CRRGraphGenerator::print_processing_summary() { - VTR_LOG("CRR Graph Generator: === Processing Summary ==="); + VTR_LOG("CRR Graph Generator: === Processing Summary ===\n"); - VTR_LOG("CRR Graph Generator: Input graph:"); - VTR_LOG(" Nodes: %zu", input_graph_.get_node_count()); - VTR_LOG(" Edges: %zu", input_graph_.get_edge_count()); - VTR_LOG(" Switches: %zu", input_graph_.get_switch_count()); + VTR_LOG("CRR Graph Generator: Input graph:\n"); + VTR_LOG(" Nodes: %zu\n", input_graph_.get_node_count()); + VTR_LOG(" Edges: %zu\n", input_graph_.get_edge_count()); + VTR_LOG(" Switches: %zu\n", input_graph_.get_switch_count()); - VTR_LOG("CRR Graph Generator: Output graph:"); - VTR_LOG(" Nodes: %zu", output_graph_->get_node_count()); - VTR_LOG(" Edges: %zu", output_graph_->get_edge_count()); - VTR_LOG(" Switches: %zu", output_graph_->get_switch_count()); + VTR_LOG("CRR Graph Generator: Output graph:\n"); + VTR_LOG(" Nodes: %zu\n", output_graph_->get_node_count()); + VTR_LOG(" Edges: %zu\n", output_graph_->get_edge_count()); + VTR_LOG(" Switches: %zu\n", output_graph_->get_switch_count()); int new_edges = static_cast(output_graph_->get_edge_count()) - static_cast(input_graph_.get_edge_count()); - VTR_LOG(" New edges added: %d", new_edges); + VTR_LOG(" New edges added: %d\n", new_edges); - VTR_LOG("Switch blocks processed: %zu", sb_manager_.get_all_patterns().size()); - VTR_LOG("Total connections: %zu", sb_manager_.get_total_connections()); + VTR_LOG("Switch blocks processed: %zu\n", sb_manager_.get_all_patterns().size()); + VTR_LOG("Total connections: %zu\n", sb_manager_.get_total_connections()); - VTR_LOG("Grid locations processed: %dx%d", g_vpr_ctx.device().grid.width(), g_vpr_ctx.device().grid.height()); + VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width(), g_vpr_ctx.device().grid.height()); } @@ -242,7 +242,7 @@ void CRRGraphGenerator::validate_processing_results() { throw RRGeneratorException("Output graph has no switches"); } - VTR_LOG("Processing results validation passed"); + VTR_LOG("Processing results validation passed\n"); } } // namespace crrgenerator \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp index ee136cfd1f..f0c8c268e9 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp @@ -19,7 +19,7 @@ CRRThreadPool::CRRThreadPool(size_t num_threads) { num_threads = 1; } - VTR_LOG("Creating CRRThreadPool with %zu threads", num_threads); + VTR_LOG("Creating CRRThreadPool with %zu threads\n", num_threads); for (size_t i = 0; i < num_threads; ++i) { workers_.emplace_back(&CRRThreadPool::worker_thread, this); @@ -77,9 +77,9 @@ void CRRThreadPool::worker_thread() { try { task(); } catch (const std::exception& e) { - VTR_LOG_ERROR("Exception in worker thread: %s", e.what()); + VTR_LOG_ERROR("Exception in worker thread: %s\n", e.what()); } catch (...) { - VTR_LOG_ERROR("Unknown exception in worker thread"); + VTR_LOG_ERROR("Unknown exception in worker thread\n"); } active_tasks_.fetch_sub(1); @@ -96,7 +96,7 @@ ProgressTracker::ProgressTracker(size_t total_tasks, : total_(total_tasks), operation_name_(operation_name), start_time_(std::chrono::steady_clock::now()) { - VTR_LOG("Starting %s: %zu tasks", operation_name_.c_str(), total_); + VTR_LOG("Starting %s: %zu tasks\n", operation_name_.c_str(), total_); } void ProgressTracker::increment(size_t count) { @@ -130,15 +130,15 @@ void ProgressTracker::log_progress() const { auto total_estimated = elapsed * total_ / current_completed; auto eta = total_estimated - elapsed; - VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds, ETA: %ds", + VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds, ETA: %ds\n", operation_name_.c_str(), current_completed, total_, percentage, elapsed.count(), eta.count()); } else { - VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds", operation_name_.c_str(), + VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds\n", operation_name_.c_str(), current_completed, total_, percentage, elapsed.count()); } } else { - VTR_LOG("%s: Complete! %zu/%zu tasks in %ds", operation_name_.c_str(), + VTR_LOG("%s: Complete! %zu/%zu tasks in %ds\n", operation_name_.c_str(), current_completed, total_, elapsed.count()); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp index 4ca38af0fa..db9e37c3ca 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp @@ -110,7 +110,7 @@ size_t DataFrame::count_non_empty_in_range(size_t start_row, size_t start_col, void DataFrame::validate_bounds(size_t row, size_t col) const { if (row >= rows_ || col >= cols_) { - VTR_LOG_ERROR("DataFrame index out of range: %zu,%zu - max %zu,%zu", row, col, rows_, cols_); + VTR_LOG_ERROR("DataFrame index out of range: %zu,%zu - max %zu,%zu\n", row, col, rows_, cols_); } } @@ -119,7 +119,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { validate_excel_file(filename); - VTR_LOG_DEBUG("Reading Excel file: %s", filename.c_str()); + VTR_LOG_DEBUG("Reading Excel file: %s\n", filename.c_str()); try { // Open the Excel document @@ -127,44 +127,44 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { doc.open(filename); if (!doc.isOpen()) { - VTR_LOG_ERROR("Failed to open Excel file: %s", filename.c_str()); + VTR_LOG_ERROR("Failed to open Excel file: %s\n", filename.c_str()); } - VTR_LOG_DEBUG("Document %s opened successfully", filename.c_str()); + VTR_LOG_DEBUG("Document %s opened successfully\n", filename.c_str()); // Get the first worksheet auto workbook = doc.workbook(); auto worksheet_names = workbook.worksheetNames(); if (worksheet_names.empty()) { - VTR_LOG_ERROR("No worksheets found in Excel file: %s", filename.c_str()); + VTR_LOG_ERROR("No worksheets found in Excel file: %s\n", filename.c_str()); } auto worksheet = workbook.worksheet(worksheet_names[0]); - VTR_LOG_DEBUG("Got worksheet: '%s'", worksheet_names[0].c_str()); + VTR_LOG_DEBUG("Got worksheet: '%s'\n", worksheet_names[0].c_str()); // Get the used range - fix for OpenXLSX API auto range = worksheet.range(); size_t last_row = range.numRows(); size_t last_col = range.numColumns(); - VTR_LOG_DEBUG("Worksheet dimensions: %zux%zu", last_row, last_col); + VTR_LOG_DEBUG("Worksheet dimensions: %zux%zu\n", last_row, last_col); // Safety check if (last_row > 10000 || last_col > 1000) { - VTR_LOG_ERROR("Excel file too large: %zux%zu (limit: 10000x1000)", + VTR_LOG_ERROR("Excel file too large: %zux%zu (limit: 10000x1000)\n", last_row, last_col); } if (last_row == 0 || last_col == 0) { - VTR_LOG_ERROR("Excel file appears to be empty: %s", filename.c_str()); + VTR_LOG_ERROR("Excel file appears to be empty: %s\n", filename.c_str()); } DataFrame df(last_row, last_col); - VTR_LOG_DEBUG("Created DataFrame with dimensions: %zux%zu", last_row, last_col); + VTR_LOG_DEBUG("Created DataFrame with dimensions: %zux%zu\n", last_row, last_col); // Read all cells - VTR_LOG_DEBUG("Reading cell data..."); + VTR_LOG_DEBUG("Reading cell data...\n"); size_t cells_read = 0; for (size_t row = 1; row <= last_row; ++row) { @@ -176,27 +176,27 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { df.at(row - 1, col - 1) = parse_excel_cell(cell_value); cells_read++; } catch (const std::exception& e) { - VTR_LOG_DEBUG("Error reading cell (%zu, %zu): %s", row, col, e.what()); + VTR_LOG_DEBUG("Error reading cell (%zu, %zu): %s\n", row, col, e.what()); df.at(row - 1, col - 1) = Cell(); // Empty cell } } // Progress logging for large files if (row % 100 == 0) { - VTR_LOG_DEBUG("Read %zu rows (%zu cells)", row, cells_read); + VTR_LOG_DEBUG("Read %zu rows (%zu cells)\n", row, cells_read); } } doc.close(); df.source_file = std::filesystem::path(filename).stem().string(); - VTR_LOG_DEBUG("Successfully read Excel file with dimensions: %zux%zu, %zu cells", + VTR_LOG_DEBUG("Successfully read Excel file with dimensions: %zux%zu, %zu cells\n", df.rows(), df.cols(), cells_read); return df; } catch (const std::exception& e) { - VTR_LOG_ERROR("Error reading Excel file %s: %s", filename.c_str(), e.what()); + VTR_LOG_ERROR("Error reading Excel file %s: %s\n", filename.c_str(), e.what()); return DataFrame(); } } @@ -204,7 +204,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { DataFrame DataFrameProcessor::process_dataframe(DataFrame df, int merge_rows_count, int merge_cols_count) { - VTR_LOG_DEBUG("Processing dataframe with merge_rows=%d, merge_cols=%d", + VTR_LOG_DEBUG("Processing dataframe with merge_rows=%d, merge_cols=%d\n", merge_rows_count, merge_cols_count); // Perform row merging @@ -221,7 +221,7 @@ DataFrame DataFrameProcessor::process_dataframe(DataFrame df, df.rows(), df.cols()); - VTR_LOG_DEBUG("Processed dataframe with %zu connections", df.connections); + VTR_LOG_DEBUG("Processed dataframe with %zu connections\n", df.connections); return df; } @@ -246,7 +246,7 @@ void DataFrameProcessor::update_switch_delays(const DataFrame& df, } } - VTR_LOG_DEBUG("Updated switch delays: min=%d, max=%d", + VTR_LOG_DEBUG("Updated switch delays: min=%d, max=%d\n", switch_delay_min_ps, switch_delay_max_ps); } @@ -305,7 +305,7 @@ void DataFrameProcessor::merge_columns(DataFrame& df, const std::vector& void DataFrameProcessor::validate_excel_file(const std::string& filename) { if (!std::filesystem::exists(filename)) { - VTR_LOG_ERROR("Excel file does not exist: %s", filename.c_str()); + VTR_LOG_ERROR("Excel file does not exist: %s\n", filename.c_str()); } // Check file extension @@ -313,7 +313,7 @@ void DataFrameProcessor::validate_excel_file(const std::string& filename) { std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower); if (extension != ".xlsx" && extension != ".xls") { - VTR_LOG_ERROR("Unsupported file format: %s. Expected .xlsx or .xls", extension.c_str()); + VTR_LOG_ERROR("Unsupported file format: %s. Expected .xlsx or .xls\n", extension.c_str()); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index e31149762a..0617c9ed39 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -91,7 +91,7 @@ bool NodeLookupManager::is_valid_coordinate(Coordinate x, Coordinate y) const { } void NodeLookupManager::print_statistics() const { - VTR_LOG("=== Node Lookup Manager Statistics ==="); + VTR_LOG("=== Node Lookup Manager Statistics ===\n"); VTR_LOG("Grid dimensions: %d x %d\n", fpga_grid_x_, fpga_grid_y_); VTR_LOG("Total nodes indexed: %zu\n", global_lookup_.size()); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp index 29738c448a..dbfe6a3316 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -75,7 +75,7 @@ std::unique_ptr XMLHandler::read_rr_graph( lineno++; } - VTR_LOG_ERROR("Failed to parse XML file %s: %s (at byte offset %zu)", filename.c_str(), + VTR_LOG_ERROR("Failed to parse XML file %s: %s (at byte offset %zu)\n", filename.c_str(), result.description(), result.offset); } @@ -132,7 +132,7 @@ void XMLHandler::write_rr_graph(const std::string& filename, out.rdbuf()->pubsetbuf(out_buf.data(), static_cast(out_buf.size())); out.open(temp_filename, std::ios::out | std::ios::binary); if (!out) { - VTR_LOG_ERROR("Failed to open output file: %s", temp_filename.c_str()); + VTR_LOG_ERROR("Failed to open output file: %s\n", temp_filename.c_str()); } out << "\n"; @@ -153,7 +153,7 @@ void XMLHandler::write_rr_graph(const std::string& filename, if (std::rename(temp_filename.c_str(), filename.c_str()) != 0) { std::remove(temp_filename.c_str()); - VTR_LOG_ERROR("Failed to atomically replace XML file: %s", filename.c_str()); + VTR_LOG_ERROR("Failed to atomically replace XML file: %s\n", filename.c_str()); } VTR_LOG("Successfully wrote RR graph to %s\n", filename.c_str()); @@ -585,13 +585,13 @@ void XMLHandler::update_vpr_xml_with_switches( pugi::xml_parse_result result = doc.load_file(input_file.c_str()); if (!result) { - VTR_LOG_ERROR("Failed to parse VPR XML file %s: %s", input_file.c_str(), result.description()); + VTR_LOG_ERROR("Failed to parse VPR XML file %s: %s\n", input_file.c_str(), result.description()); } // Find switchlist element pugi::xml_node switchlist = doc.select_node("//switchlist").node(); if (!switchlist) { - VTR_LOG_ERROR(" element not found in VPR XML file"); + VTR_LOG_ERROR(" element not found in VPR XML file\n"); } // Find the last default switch ID @@ -642,7 +642,7 @@ std::string XMLHandler::format_float_value(double value) { void XMLHandler::validate_xml_structure(const pugi::xml_document& doc) { pugi::xml_node root = doc.child("rr_graph"); if (!root) { - VTR_LOG_ERROR("Root element 'rr_graph' not found"); + VTR_LOG_ERROR("Root element 'rr_graph' not found\n"); } } From 1bdb9b242e0f16bd320a93d94f1b1c65a3874f4f Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 20 Oct 2025 16:05:14 -0700 Subject: [PATCH 038/120] [vpr][route][crr] replate throw with vtr_log_error --- .../tileable_rr_graph/crr_generator/crr_generator.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index 640ac5de45..602996d6af 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -227,19 +227,19 @@ void CRRGraphGenerator::print_processing_summary() { void CRRGraphGenerator::validate_processing_results() { // Basic validation if (!output_graph_) { - throw RRGeneratorException("Output graph was not created"); + VTR_LOG_ERROR("Output graph was not created\n"); } if (output_graph_->get_node_count() == 0) { - throw RRGeneratorException("Output graph has no nodes"); + VTR_LOG_ERROR("Output graph has no nodes\n"); } if (output_graph_->get_edge_count() == 0) { - throw RRGeneratorException("Output graph has no edges"); + VTR_LOG_ERROR("Output graph has no edges\n"); } if (output_graph_->get_switch_count() == 0) { - throw RRGeneratorException("Output graph has no switches"); + VTR_LOG_ERROR("Output graph has no switches\n"); } VTR_LOG("Processing results validation passed\n"); From 49862632c1e0c3741025823f2702c8863ff7c448 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 21 Oct 2025 07:17:11 -0700 Subject: [PATCH 039/120] [vpr][route][crr] fix file name display --- .../crr_generator/crr_switch_block_manager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp index 842a04f2ee..b7b089db13 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp @@ -69,7 +69,7 @@ void SwitchBlockManager::initialize(const std::string& sb_maps_file, file_cache_[full_path] = std::move(df); VTR_LOG_DEBUG("Processed %zu connections in %s file\n", file_cache_[full_path].connections, - std::filesystem::path(full_path).filename().string()); + std::filesystem::path(full_path).filename().string().c_str()); } catch (const std::exception& e) { VTR_LOG_ERROR("Failed to read required Excel file '%s': %s\n", full_path.c_str(), e.what()); } @@ -153,7 +153,7 @@ void SwitchBlockManager::print_statistics() const { // Print file details for (const auto& [file, df] : file_cache_) { VTR_LOG(" %s: %zu connections (%zux%zu)\n", - std::filesystem::path(file).filename().string(), + std::filesystem::path(file).filename().string().c_str(), df.connections, df.rows(), df.cols()); } } From 549c5b43661b14ab9b70aa0627b90d7c2ed53e60 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 21 Oct 2025 07:17:34 -0700 Subject: [PATCH 040/120] temp: add code to just build crr and step out --- .../route/rr_graph_generation/rr_graph.cpp | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp index 18a2c9c630..ce56965cd8 100644 --- a/vpr/src/route/rr_graph_generation/rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/rr_graph.cpp @@ -46,6 +46,11 @@ #include "rr_types.h" #include "rr_node_indices.h" +#include "crr_generator.h" +#include "xml_handler.h" +#include "node_lookup_manager.h" +#include "crr_switch_block_manager.h" + //#define VERBOSE //used for getting the exact count of each edge type and printing it to std out. @@ -395,6 +400,22 @@ void create_rr_graph(e_graph_type graph_type, const char* echo_file_name = getEchoFileName(E_ECHO_RR_GRAPH_INDEXED_DATA); bool load_rr_graph = !det_routing_arch.read_rr_graph_filename.empty(); + + { + // Building CRR Graph + crrgenerator::SwitchBlockManager sb_manager; + sb_manager.initialize(crr_opts.sb_maps, crr_opts.sb_templates, crr_opts.annotated_rr_graph); + std::unique_ptr crr_input_graph; + crrgenerator::XMLHandler xml_handler; + crr_input_graph = xml_handler.read_rr_graph(det_routing_arch.read_rr_graph_filename); + crrgenerator::NodeLookupManager node_lookup; + node_lookup.initialize(*crr_input_graph, grid.width(), grid.height()); + crrgenerator::CRRGraphGenerator parser(crr_opts, *crr_input_graph, node_lookup, sb_manager, det_routing_arch.write_rr_graph_filename); + parser.run(); + VTR_LOG("CRR Graph built successfully"); + exit(0); + } + if (device_ctx.chan_width == nodes_per_chan && !device_ctx.rr_graph.empty()) { // No change in channel width, so skip re-building RR graph if (is_flat && !device_ctx.rr_graph_is_flat) { From 1fe6d461fdf654ea00d43e1b70aa9254fc891df3 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 21 Oct 2025 13:43:31 -0700 Subject: [PATCH 041/120] [vpr][route][rr_graph_gen] fix log msg ending --- .gitmodules | 3 +++ libs/EXTERNAL/xlnt | 1 + vpr/src/route/rr_graph_generation/rr_graph.cpp | 2 +- 3 files changed, 5 insertions(+), 1 deletion(-) create mode 160000 libs/EXTERNAL/xlnt diff --git a/.gitmodules b/.gitmodules index 6c25b9bc47..3a7a37d0b5 100644 --- a/.gitmodules +++ b/.gitmodules @@ -22,3 +22,6 @@ [submodule "libs/EXTERNAL/yaml-cpp"] path = libs/EXTERNAL/yaml-cpp url = https://github.com/jbeder/yaml-cpp.git +[submodule "libs/EXTERNAL/xlnt"] + path = libs/EXTERNAL/xlnt + url = https://github.com/tfussell/xlnt.git diff --git a/libs/EXTERNAL/xlnt b/libs/EXTERNAL/xlnt new file mode 160000 index 0000000000..297b331435 --- /dev/null +++ b/libs/EXTERNAL/xlnt @@ -0,0 +1 @@ +Subproject commit 297b331435d6dee09bf89c8a5ad974b01f18039b diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp index ce56965cd8..1f1b6ad273 100644 --- a/vpr/src/route/rr_graph_generation/rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/rr_graph.cpp @@ -412,7 +412,7 @@ void create_rr_graph(e_graph_type graph_type, node_lookup.initialize(*crr_input_graph, grid.width(), grid.height()); crrgenerator::CRRGraphGenerator parser(crr_opts, *crr_input_graph, node_lookup, sb_manager, det_routing_arch.write_rr_graph_filename); parser.run(); - VTR_LOG("CRR Graph built successfully"); + VTR_LOG("CRR Graph built successfully\n"); exit(0); } From ea02eed4ee9960b3f67d0efdb9b5d417a34a6170 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 08:55:22 -0700 Subject: [PATCH 042/120] [libs][external] remove openxlsx --- .gitmodules | 3 --- libs/EXTERNAL/OpenXLSX | 1 - 2 files changed, 4 deletions(-) delete mode 160000 libs/EXTERNAL/OpenXLSX diff --git a/.gitmodules b/.gitmodules index 3a7a37d0b5..eeb1abfa63 100644 --- a/.gitmodules +++ b/.gitmodules @@ -16,9 +16,6 @@ [submodule "libs/EXTERNAL/yosys-slang"] path = libs/EXTERNAL/yosys-slang url = https://github.com/povik/yosys-slang.git -[submodule "libs/EXTERNAL/OpenXLSX"] - path = libs/EXTERNAL/OpenXLSX - url = https://github.com/troldal/OpenXLSX.git [submodule "libs/EXTERNAL/yaml-cpp"] path = libs/EXTERNAL/yaml-cpp url = https://github.com/jbeder/yaml-cpp.git diff --git a/libs/EXTERNAL/OpenXLSX b/libs/EXTERNAL/OpenXLSX deleted file mode 160000 index 5723411d47..0000000000 --- a/libs/EXTERNAL/OpenXLSX +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 5723411d47643ce3b5b9994064c26ca8cd841f13 From 8908e310f37c4fe67d857fbdfced91fe868c074e Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 08:56:54 -0700 Subject: [PATCH 043/120] [Cmake] replace openxlsx with xlnt --- libs/EXTERNAL/CMakeLists.txt | 2 +- vpr/CMakeLists.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/EXTERNAL/CMakeLists.txt b/libs/EXTERNAL/CMakeLists.txt index deaafd4fa4..eab3700462 100644 --- a/libs/EXTERNAL/CMakeLists.txt +++ b/libs/EXTERNAL/CMakeLists.txt @@ -12,8 +12,8 @@ add_subdirectory(libsdcparse) add_subdirectory(libblifparse) add_subdirectory(libtatum) add_subdirectory(libcatch2) -add_subdirectory(OpenXLSX) add_subdirectory(yaml-cpp) +add_subdirectory(xlnt) #add_subdirectory(parmys) #Proc numbers diff --git a/vpr/CMakeLists.txt b/vpr/CMakeLists.txt index 44d485fa4f..0531c2b04d 100644 --- a/vpr/CMakeLists.txt +++ b/vpr/CMakeLists.txt @@ -119,7 +119,7 @@ target_link_libraries(libvpr libpugixml librrgraph ZLIB::ZLIB - OpenXLSX::OpenXLSX + xlnt yaml-cpp::yaml-cpp ) From 341ffed1583631c46da30329bf17a2d83ea7d543 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 08:59:40 -0700 Subject: [PATCH 044/120] [vpr][route][crr] remove update vpr xml function --- .../crr_generator/xml_handler.cpp | 56 ++----------------- .../crr_generator/xml_handler.h | 14 ----- 2 files changed, 6 insertions(+), 64 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp index dbfe6a3316..696cc3a387 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -1,3 +1,6 @@ +#include // for std::ostringstream +#include // for std::setprecision and std::scientific + #include "xml_handler.h" #include "vtr_log.h" @@ -574,55 +577,6 @@ void XMLHandler::write_edge(std::ostream& out, const RREdge& e) { out << "/>\n"; } -void XMLHandler::update_vpr_xml_with_switches( - const std::vector& switches, const std::string& input_file, - const std::string& output_file, SwitchId switch_delay_min, - SwitchId switch_delay_max) { - VTR_LOG("Updating VPR XML with new switches: %s -> %s\n", input_file.c_str(), - output_file.c_str()); - - pugi::xml_document doc; - pugi::xml_parse_result result = doc.load_file(input_file.c_str()); - - if (!result) { - VTR_LOG_ERROR("Failed to parse VPR XML file %s: %s\n", input_file.c_str(), result.description()); - } - - // Find switchlist element - pugi::xml_node switchlist = doc.select_node("//switchlist").node(); - if (!switchlist) { - VTR_LOG_ERROR(" element not found in VPR XML file\n"); - } - - // Find the last default switch ID - SwitchId last_default_id = 0; - for (const auto& switch_obj : switches) { - last_default_id = std::max(last_default_id, switch_obj.get_id()); - } - - SwitchId first_new_id = std::min(switch_delay_min - 1, last_default_id + 1); - - // Add new switches - for (SwitchId switch_id = first_new_id; switch_id <= switch_delay_max + 1; - ++switch_id) { - pugi::xml_node switch_element = switchlist.append_child("switch"); - - switch_element.append_attribute("type") = "mux"; - switch_element.append_attribute("name") = - ("sw_" + std::to_string(switch_id)).c_str(); - switch_element.append_attribute("R") = "0."; - switch_element.append_attribute("Cin") = ".77e-15"; - switch_element.append_attribute("Cout") = "0."; - switch_element.append_attribute("Tdel") = - (std::to_string(switch_id * 1e-12)).c_str(); - switch_element.append_attribute("mux_trans_size") = "2.630740"; - switch_element.append_attribute("buf_size") = "27.645901"; - } - - VTR_LOG("Successfully updated VPR XML with %zu new switches\n", - (switch_delay_max + 1 - first_new_id + 1)); -} - std::string XMLHandler::format_float_value(double value) { std::string result = std::to_string(value); @@ -633,7 +587,9 @@ std::string XMLHandler::format_float_value(double value) { // Format scientific notation if (result.find("e-") != std::string::npos) { - result = std::to_string(value); + std::ostringstream oss; + oss << std::scientific << std::setprecision(8) << value; + result = oss.str(); } return result; diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h index 25cf0c2329..294d3b0d77 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h @@ -40,20 +40,6 @@ class XMLHandler { */ void write_rr_graph(const std::string& filename, const RRGraph& graph); - /** - * @brief Update VPR XML file with new switches - * @param switches Vector of switches to add - * @param input_file Input VPR XML file - * @param output_file Output VPR XML file - * @param switch_delay_min Minimum switch delay ID - * @param switch_delay_max Maximum switch delay ID - */ - void update_vpr_xml_with_switches(const std::vector& switches, - const std::string& input_file, - const std::string& output_file, - SwitchId switch_delay_min, - SwitchId switch_delay_max); - private: // Attribute mapping for XML conversion std::unordered_map attribute_map_; From bc4bc0b5424dc51aece710e9e93e726532970e45 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 09:01:56 -0700 Subject: [PATCH 045/120] [vpr][route][crr] use xlnt instead of openxlsx in data frame processor --- .../crr_generator/data_frame_processor.cpp | 87 ++++++++++--------- .../crr_generator/data_frame_processor.h | 6 +- 2 files changed, 49 insertions(+), 44 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp index db9e37c3ca..d338ae8c99 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp @@ -3,6 +3,7 @@ #include "vtr_log.h" #include +#include namespace crrgenerator { @@ -123,36 +124,27 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { try { // Open the Excel document - OpenXLSX::XLDocument doc; - doc.open(filename); - - if (!doc.isOpen()) { - VTR_LOG_ERROR("Failed to open Excel file: %s\n", filename.c_str()); - } + xlnt::workbook wb; + wb.load(filename); VTR_LOG_DEBUG("Document %s opened successfully\n", filename.c_str()); // Get the first worksheet - auto workbook = doc.workbook(); - auto worksheet_names = workbook.worksheetNames(); - - if (worksheet_names.empty()) { - VTR_LOG_ERROR("No worksheets found in Excel file: %s\n", filename.c_str()); - } + auto worksheet = wb.active_sheet(); + std::string sheet_name = worksheet.title(); + + VTR_LOG_DEBUG("Got worksheet: '%s'\n", sheet_name.c_str()); - auto worksheet = workbook.worksheet(worksheet_names[0]); - VTR_LOG_DEBUG("Got worksheet: '%s'\n", worksheet_names[0].c_str()); - - // Get the used range - fix for OpenXLSX API - auto range = worksheet.range(); - size_t last_row = range.numRows(); - size_t last_col = range.numColumns(); + // Get the used range dimensions + auto used_range = worksheet.calculate_dimension(); + size_t last_row = used_range.bottom_right().row(); + size_t last_col = used_range.bottom_right().column_index(); VTR_LOG_DEBUG("Worksheet dimensions: %zux%zu\n", last_row, last_col); // Safety check if (last_row > 10000 || last_col > 1000) { - VTR_LOG_ERROR("Excel file too large: %zux%zu (limit: 10000x1000)\n", + VTR_LOG_ERROR("Excel file too large: %zux%zu (limit: 10000x1000)\n", last_row, last_col); } @@ -170,10 +162,9 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { for (size_t row = 1; row <= last_row; ++row) { for (size_t col = 1; col <= last_col; ++col) { try { - auto cell = worksheet.cell(row, col); - // Convert cell.value() to XLCellValue and parse it - OpenXLSX::XLCellValue cell_value = cell.value(); - df.at(row - 1, col - 1) = parse_excel_cell(cell_value); + // xlnt uses 1-based indexing like Excel + auto cell = worksheet.cell(col, row); + df.at(row - 1, col - 1) = parse_excel_cell(cell); cells_read++; } catch (const std::exception& e) { VTR_LOG_DEBUG("Error reading cell (%zu, %zu): %s\n", row, col, e.what()); @@ -187,8 +178,6 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { } } - doc.close(); - df.source_file = std::filesystem::path(filename).stem().string(); VTR_LOG_DEBUG("Successfully read Excel file with dimensions: %zux%zu, %zu cells\n", df.rows(), df.cols(), cells_read); @@ -251,29 +240,45 @@ void DataFrameProcessor::update_switch_delays(const DataFrame& df, switch_delay_max_ps); } -// Fixed parse_excel_cell to work with XLCellValue -Cell DataFrameProcessor::parse_excel_cell(const OpenXLSX::XLCellValue& cell_value) { - // Get the value type - auto value_type = cell_value.type(); +// Parse xlnt cell to our Cell type +Cell DataFrameProcessor::parse_excel_cell(const xlnt::cell& cell) { + // Check if cell has a value + if (!cell.has_value()) { + return Cell(); + } - switch (value_type) { - case OpenXLSX::XLValueType::Boolean: - return Cell(static_cast(cell_value.get() ? 1 : 0)); + // Get the data type + auto data_type = cell.data_type(); - case OpenXLSX::XLValueType::Integer: - return Cell(static_cast(cell_value.get())); + switch (data_type) { + case xlnt::cell::type::boolean: + return Cell(static_cast(cell.value() ? 1 : 0)); - case OpenXLSX::XLValueType::Float: - return Cell(cell_value.get()); + case xlnt::cell::type::number: { + double value = cell.value(); + // Check if it's actually an integer + if (value == std::floor(value) && std::abs(value) < 9007199254740992.0) { + return Cell(static_cast(value)); + } + return Cell(value); + } - case OpenXLSX::XLValueType::String: { - std::string value = cell_value.get(); + case xlnt::cell::type::shared_string: + case xlnt::cell::type::inline_string: + case xlnt::cell::type::formula_string: { + std::string value = cell.to_string(); if (value.empty()) { return Cell(); } return Cell(value); } - case OpenXLSX::XLValueType::Empty: + + case xlnt::cell::type::date: { + // Convert date to string representation + return Cell(cell.to_string()); + } + + case xlnt::cell::type::empty: default: return Cell(); } @@ -317,4 +322,4 @@ void DataFrameProcessor::validate_excel_file(const std::string& filename) { } } -} // namespace rrgenerator +} // namespace crrgenerator \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h index 735d544aba..2ad77c9cea 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h @@ -3,7 +3,7 @@ #include #include -#include "OpenXLSX.hpp" +#include #include "crr_common.h" namespace crrgenerator { @@ -195,7 +195,7 @@ class DataFrameProcessor { private: // Excel parsing helpers - Cell parse_excel_cell(const OpenXLSX::XLCellValue& cell_value); + Cell parse_excel_cell(const xlnt::cell& cell); void merge_rows(DataFrame& df, const std::vector& merge_row_indices); void merge_columns(DataFrame& df, const std::vector& merge_col_indices); @@ -203,4 +203,4 @@ class DataFrameProcessor { void validate_excel_file(const std::string& filename); }; -} // namespace crrgenerator +} // namespace crrgenerator \ No newline at end of file From bedddcd3d0c29d51115ca317939d7125e475a3b6 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 09:12:14 -0700 Subject: [PATCH 046/120] [vpr][route][crr] deduct 2 from grid width and height --- .../crr_generator/crr_generator.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index 602996d6af..2ca9d85ef3 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -73,8 +73,8 @@ void CRRGraphGenerator::build_connections() { // Initialize connection builder const DeviceGrid& grid = g_vpr_ctx.device().grid; - connection_builder_->initialize(grid.width(), - grid.height(), + connection_builder_->initialize(grid.width()-2, + grid.height()-2, crr_opts_.annotated_rr_graph); VTR_LOG("CRR Graph Generator: Connection building completed\n"); @@ -157,13 +157,13 @@ void CRRGraphGenerator::add_custom_edges() { // Add new connections const DeviceGrid& grid = g_vpr_ctx.device().grid; size_t total_tiles = - static_cast((grid.width() + 1) * (grid.height() + 1)); + static_cast((grid.width() + 1 - 2) * (grid.height() + 1 - 2)); ProgressTracker tracker(total_tiles, "Adding new connections"); std::vector> futures; std::mutex graph_mutex; - for (Coordinate tile_x = 0; tile_x <= grid.width(); tile_x++) { - for (Coordinate tile_y = 0; tile_y <= grid.height(); tile_y++) { + for (Coordinate tile_x = 0; tile_x <= grid.width() - 2; tile_x++) { + for (Coordinate tile_y = 0; tile_y <= grid.height() - 2; tile_y++) { auto fut = thread_pool_->submit([this, tile_x, tile_y, &graph_mutex, &tracker]() { std::vector tile_connections = connection_builder_->get_tile_connections(tile_x, tile_y); @@ -220,7 +220,7 @@ void CRRGraphGenerator::print_processing_summary() { VTR_LOG("Switch blocks processed: %zu\n", sb_manager_.get_all_patterns().size()); VTR_LOG("Total connections: %zu\n", sb_manager_.get_total_connections()); - VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width(), g_vpr_ctx.device().grid.height()); + VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width() - 2, g_vpr_ctx.device().grid.height() - 2); } From 099b81dfe8a299178b019d7f0417c8ff55439e4b Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 09:41:17 -0700 Subject: [PATCH 047/120] [vpr][route][crr] fix format_float_value in xml_handler --- .../crr_generator/xml_handler.cpp | 31 ++++++++++--------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp index 696cc3a387..be8013e441 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -578,21 +578,24 @@ void XMLHandler::write_edge(std::ostream& out, const RREdge& e) { } std::string XMLHandler::format_float_value(double value) { - std::string result = std::to_string(value); - - // Remove trailing .0 for integer values (C++17 compatible) - if (result.length() >= 2 && result.substr(result.length() - 2) == ".0") { - result = result.substr(0, result.length() - 2); - } - - // Format scientific notation - if (result.find("e-") != std::string::npos) { std::ostringstream oss; - oss << std::scientific << std::setprecision(8) << value; - result = oss.str(); - } - - return result; + oss << value; + std::string result = oss.str(); + + // Remove trailing .0 for integer values + if (result.length() >= 2 && result.ends_with(".0")) { + result = result.substr(0, result.length() - 2); + } + + // Format scientific notation + if (result.find("e-") != std::string::npos) { + oss.str(""); + oss.clear(); + oss << std::scientific << std::setprecision(8) << value; + result = oss.str(); + } + + return result; } void XMLHandler::validate_xml_structure(const pugi::xml_document& doc) { From 78c25810e6156774ae8ab4bee7ca087651dd2c1c Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 09:41:52 -0700 Subject: [PATCH 048/120] [vpr][route][crr] print newly added switches --- .../tileable_rr_graph/crr_generator/crr_generator.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index 2ca9d85ef3..d5c3e89a87 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -120,6 +120,7 @@ void CRRGraphGenerator::create_output_graph() { static_cast(curr_sw_delay_ps), "sw_" + std::to_string(curr_sw_delay_ps), default_sw_type, Timing(default_timing.Cin, curr_sw_delay_s), default_sizing); + VTR_LOG_DEBUG("Adding switch: %s with delay: %e s\n", curr_switch.get_name().c_str(), curr_sw_delay_s); output_graph_->add_switch(curr_switch); } } From 852890afa80764e81e3a20126ecfa6514ebc4dcf Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 10:19:11 -0700 Subject: [PATCH 049/120] [vpr][route][crr] add custom_rr_graph_builder file --- .../crr_generator/crr_graph_edge_builder.cpp | 7 ----- .../crr_generator/crr_graph_edge_builder.h | 10 ------- .../crr_generator/custom_rr_graph_builder.cpp | 27 +++++++++++++++++ .../crr_generator/custom_rr_graph_builder.h | 30 +++++++++++++++++++ 4 files changed, 57 insertions(+), 17 deletions(-) delete mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp delete mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp deleted file mode 100644 index af3ecfa1d8..0000000000 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include "crr_graph_edge_builder.h" - -void build_crr_graph_edges(const RRGraphView& rr_graph, - RRGraphBuilder& rr_graph_builder, - const t_crr_opts& crr_opts) { - // TODO: Implement -} \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h deleted file mode 100644 index bad838bb82..0000000000 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_graph_edge_builder.h +++ /dev/null @@ -1,10 +0,0 @@ -# pragma once - -#include "vpr_types.h" -#include "rr_graph.h" -#include "rr_graph_view.h" -#include "rr_graph_builder.h" - -void build_crr_graph_edges(const RRGraphView& rr_graph, - RRGraphBuilder& rr_graph_builder, - const t_crr_opts& crr_opts); \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp new file mode 100644 index 0000000000..073c8a3023 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp @@ -0,0 +1,27 @@ +#include "custom_rr_graph_builder.h" + +void build_custom_rr_graph(const std::vector& types, + const DeviceGrid& grids, + const t_chan_width& chan_width, + const t_crr_opts& crr_opts, + const e_switch_block_type& sb_type, + const int& Fs, + const e_switch_block_type& sb_subtype, + const int& sub_fs, + const std::vector& segment_inf, + const int& delayless_switch, + const int& wire_to_arch_ipin_switch, + const float R_minW_nmos, + const float R_minW_pmos, + const e_base_cost_type& base_cost_type, + const std::vector& directs, + RRSwitchId& wire_to_rr_ipin_switch, + const bool& shrink_boundary, + const bool& perimeter_cb, + const bool& through_channel, + const bool& opin2all_sides, + const bool& concat_wire, + const bool& wire_opposite_side, + int* Warnings) { + + } \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h new file mode 100644 index 0000000000..c99385cb33 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +#include "physical_types.h" +#include "device_grid.h" + +void build_custom_rr_graph(const std::vector& types, + const DeviceGrid& grids, + const t_chan_width& chan_width, + const t_crr_opts& crr_opts, + const e_switch_block_type& sb_type, + const int& Fs, + const e_switch_block_type& sb_subtype, + const int& sub_fs, + const std::vector& segment_inf, + const int& delayless_switch, + const int& wire_to_arch_ipin_switch, + const float R_minW_nmos, + const float R_minW_pmos, + const e_base_cost_type& base_cost_type, + const std::vector& directs, + RRSwitchId& wire_to_rr_ipin_switch, + const bool& shrink_boundary, + const bool& perimeter_cb, + const bool& through_channel, + const bool& opin2all_sides, + const bool& concat_wire, + const bool& wire_opposite_side, + int* Warnings); From d93536caca672700ceb5be6be3de8d58c9a0752b Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 11:41:36 -0700 Subject: [PATCH 050/120] [CLI][CRR] remove preserve_opin/ipin and replace it with preserve pin connections --- vpr/src/base/read_options.cpp | 9 ++------- vpr/src/base/read_options.h | 3 +-- vpr/src/base/setup_vpr.cpp | 3 +-- vpr/src/base/vpr_types.h | 3 +-- .../crr_generator/crr_generator.cpp | 4 +--- .../crr_generator/custom_rr_graph.cpp | 18 ++++++------------ .../crr_generator/custom_rr_graph.h | 4 +--- 7 files changed, 13 insertions(+), 31 deletions(-) diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp index 69511b4d35..139571579d 100644 --- a/vpr/src/base/read_options.cpp +++ b/vpr/src/base/read_options.cpp @@ -3297,13 +3297,8 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio .default_value("1") .show_in(argparse::ShowIn::HELP_ONLY); - crr_grp.add_argument(args.preserve_input_pins, "--preserve_input_pins") - .help("Whether the input pins connections should be generated by the default flow and not from the CRR template") - .default_value("off") - .show_in(argparse::ShowIn::HELP_ONLY); - - crr_grp.add_argument(args.preserve_output_pins, "--preserve_output_pins") - .help("Whether the output pins connections should be generated by the default flow and not from the CRR template") + crr_grp.add_argument(args.preserve_pin_connections, "--preserve_pin_connections") + .help("If it set to on, the pin connections will be generated by the default flow and not from the CRR template") .default_value("off") .show_in(argparse::ShowIn::HELP_ONLY); diff --git a/vpr/src/base/read_options.h b/vpr/src/base/read_options.h index c0a25c0ea0..1387b8313a 100644 --- a/vpr/src/base/read_options.h +++ b/vpr/src/base/read_options.h @@ -289,8 +289,7 @@ struct t_options { argparse::ArgValue sb_maps; argparse::ArgValue sb_templates; argparse::ArgValue crr_num_threads; - argparse::ArgValue preserve_input_pins; - argparse::ArgValue preserve_output_pins; + argparse::ArgValue preserve_pin_connections; argparse::ArgValue annotated_rr_graph; }; diff --git a/vpr/src/base/setup_vpr.cpp b/vpr/src/base/setup_vpr.cpp index c5b6d94754..7e1c5d4fe9 100644 --- a/vpr/src/base/setup_vpr.cpp +++ b/vpr/src/base/setup_vpr.cpp @@ -762,8 +762,7 @@ static void setup_crr_opts(const t_options& Options, t_crr_opts& crr_opts) { crr_opts.sb_maps = Options.sb_maps; crr_opts.sb_templates = Options.sb_templates; crr_opts.crr_num_threads = Options.crr_num_threads; - crr_opts.preserve_input_pins = Options.preserve_input_pins; - crr_opts.preserve_output_pins = Options.preserve_output_pins; + crr_opts.preserve_pin_connections = Options.preserve_pin_connections; crr_opts.annotated_rr_graph = Options.annotated_rr_graph; } diff --git a/vpr/src/base/vpr_types.h b/vpr/src/base/vpr_types.h index 2d2ce79d2a..9b327380bd 100644 --- a/vpr/src/base/vpr_types.h +++ b/vpr/src/base/vpr_types.h @@ -1414,8 +1414,7 @@ struct t_crr_opts { std::string sb_maps; std::string sb_templates; int crr_num_threads; - bool preserve_input_pins; - bool preserve_output_pins; + bool preserve_pin_connections; bool annotated_rr_graph; }; diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index d5c3e89a87..d32364361c 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -129,9 +129,7 @@ void CRRGraphGenerator::create_output_graph() { auto all_connections = connection_builder_->get_all_connections(); auto preserved_edges = input_graph_.get_preserved_edges( - crr_opts_.preserve_input_pins, - crr_opts_.preserve_output_pins); - + crr_opts_.preserve_pin_connections); VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu\n", preserved_edges.size()); // Clear existing edges and add new ones diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp index 18546ce5fa..4036cbeca1 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp @@ -191,9 +191,7 @@ std::unordered_set RRGraph::get_opin_nodes() const { return result; } -std::vector RRGraph::get_preserved_edges( - const bool preserve_ipin_connections, - const bool preserve_opin_connections) const { +std::vector RRGraph::get_preserved_edges(const bool preserve_pin_connections) const { std::vector result; auto source_nodes = get_source_nodes(); auto sink_nodes = get_sink_nodes(); @@ -208,15 +206,11 @@ std::vector RRGraph::get_preserved_edges( ipin_nodes.find(edge_sink_node) != ipin_nodes.end())) { result.push_back(edge); } else { - if (preserve_ipin_connections && - ipin_nodes.find(edge_sink_node) != ipin_nodes.end()) { - result.push_back(edge); - } - - if (preserve_opin_connections && - opin_nodes.find(edge_src_node) != opin_nodes.end()) { - result.push_back(edge); - } + if (preserve_pin_connections) { + if (ipin_nodes.find(edge_sink_node) != ipin_nodes.end() || + opin_nodes.find(edge_src_node) != opin_nodes.end()) { + result.push_back(edge); + } } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h index 19553c72a1..b9395927ef 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h @@ -458,9 +458,7 @@ class RRGraph { std::unordered_set get_opin_nodes() const; // Edge filtering - std::vector get_preserved_edges( - const bool preserve_ipin_connections, - const bool preserve_opin_connections) const; + std::vector get_preserved_edges(const bool preserve_pin_connections) const; // Metadata void set_tool_info(const std::string& name, const std::string& version, From fc38a9f1dc9c1eae471c1bda7d5db872cfd161a5 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 12:12:30 -0700 Subject: [PATCH 051/120] [vpr][route][crr] remove custom_rr_graph_builder --- .../crr_generator/custom_rr_graph_builder.cpp | 27 ----------------- .../crr_generator/custom_rr_graph_builder.h | 30 ------------------- 2 files changed, 57 deletions(-) delete mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp delete mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp deleted file mode 100644 index 073c8a3023..0000000000 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#include "custom_rr_graph_builder.h" - -void build_custom_rr_graph(const std::vector& types, - const DeviceGrid& grids, - const t_chan_width& chan_width, - const t_crr_opts& crr_opts, - const e_switch_block_type& sb_type, - const int& Fs, - const e_switch_block_type& sb_subtype, - const int& sub_fs, - const std::vector& segment_inf, - const int& delayless_switch, - const int& wire_to_arch_ipin_switch, - const float R_minW_nmos, - const float R_minW_pmos, - const e_base_cost_type& base_cost_type, - const std::vector& directs, - RRSwitchId& wire_to_rr_ipin_switch, - const bool& shrink_boundary, - const bool& perimeter_cb, - const bool& through_channel, - const bool& opin2all_sides, - const bool& concat_wire, - const bool& wire_opposite_side, - int* Warnings) { - - } \ No newline at end of file diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h deleted file mode 100644 index c99385cb33..0000000000 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph_builder.h +++ /dev/null @@ -1,30 +0,0 @@ -#pragma once - -#include - -#include "physical_types.h" -#include "device_grid.h" - -void build_custom_rr_graph(const std::vector& types, - const DeviceGrid& grids, - const t_chan_width& chan_width, - const t_crr_opts& crr_opts, - const e_switch_block_type& sb_type, - const int& Fs, - const e_switch_block_type& sb_subtype, - const int& sub_fs, - const std::vector& segment_inf, - const int& delayless_switch, - const int& wire_to_arch_ipin_switch, - const float R_minW_nmos, - const float R_minW_pmos, - const e_base_cost_type& base_cost_type, - const std::vector& directs, - RRSwitchId& wire_to_rr_ipin_switch, - const bool& shrink_boundary, - const bool& perimeter_cb, - const bool& through_channel, - const bool& opin2all_sides, - const bool& concat_wire, - const bool& wire_opposite_side, - int* Warnings); From 84cc0b4dd00d303b23ec8929871cd6033bb0cde4 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 12:27:30 -0700 Subject: [PATCH 052/120] [vpr][route][rr_graph] remove temp code --- vpr/src/route/rr_graph_generation/rr_graph.cpp | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/rr_graph.cpp b/vpr/src/route/rr_graph_generation/rr_graph.cpp index 1f1b6ad273..50e586e487 100644 --- a/vpr/src/route/rr_graph_generation/rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/rr_graph.cpp @@ -400,22 +400,6 @@ void create_rr_graph(e_graph_type graph_type, const char* echo_file_name = getEchoFileName(E_ECHO_RR_GRAPH_INDEXED_DATA); bool load_rr_graph = !det_routing_arch.read_rr_graph_filename.empty(); - - { - // Building CRR Graph - crrgenerator::SwitchBlockManager sb_manager; - sb_manager.initialize(crr_opts.sb_maps, crr_opts.sb_templates, crr_opts.annotated_rr_graph); - std::unique_ptr crr_input_graph; - crrgenerator::XMLHandler xml_handler; - crr_input_graph = xml_handler.read_rr_graph(det_routing_arch.read_rr_graph_filename); - crrgenerator::NodeLookupManager node_lookup; - node_lookup.initialize(*crr_input_graph, grid.width(), grid.height()); - crrgenerator::CRRGraphGenerator parser(crr_opts, *crr_input_graph, node_lookup, sb_manager, det_routing_arch.write_rr_graph_filename); - parser.run(); - VTR_LOG("CRR Graph built successfully\n"); - exit(0); - } - if (device_ctx.chan_width == nodes_per_chan && !device_ctx.rr_graph.empty()) { // No change in channel width, so skip re-building RR graph if (is_flat && !device_ctx.rr_graph_is_flat) { From 8215eee756bd5b91ec461610f955a33823982c5d Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 12:31:13 -0700 Subject: [PATCH 053/120] [vpr][route][crr] remove if condition for crr --- .../tileable_rr_graph_builder.cpp | 70 +++++++++---------- 1 file changed, 32 insertions(+), 38 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp index ca80099189..c75fab7489 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp @@ -26,8 +26,6 @@ #include "tileable_rr_graph_edge_builder.h" #include "tileable_rr_graph_builder.h" -#include "crr_graph_edge_builder.h" - #include "globals.h" /************************************************************************ @@ -242,44 +240,40 @@ void build_tileable_unidir_rr_graph(const std::vector& typ *Warnings |= RR_GRAPH_WARN_FC_CLIPPED; } - if (crr_opts.sb_maps.empty()) { - // Build the connections tile by tile: - // We classify rr_nodes into a general switch block (GSB) data structure - // where we create edges to each rr_nodes in the GSB with respect to - // Fc_in and Fc_out, switch block patterns - // In addition, we will also handle direct-connections: - // Add edges that bridge OPINs and IPINs to the rr_graph - // Create edges for a tileable rr_graph - build_rr_graph_edges(device_ctx.rr_graph, - device_ctx.rr_graph_builder, - rr_node_driver_switches, - grids, vib_grid, 0, - device_chan_width, - segment_inf, segment_inf_x, segment_inf_y, - Fc_in, Fc_out, - sb_type, Fs, sb_subtype, sub_fs, - perimeter_cb, - opin2all_sides, concat_wire, - wire_opposite_side, - delayless_rr_switch); - - // Build direction connection lists - // TODO: use tile direct builder - // Create data structure of direct-connections - std::vector clb_to_clb_directs = alloc_and_load_clb_to_clb_directs(directs, delayless_switch); - std::vector clb2clb_directs; - for (size_t idirect = 0; idirect < directs.size(); ++idirect) { - // Sanity checks on rr switch id - VTR_ASSERT(device_ctx.rr_graph.valid_switch(RRSwitchId(clb_to_clb_directs[idirect].switch_index))); - clb2clb_directs.push_back(clb_to_clb_directs[idirect]); - } - - build_rr_graph_direct_connections(device_ctx.rr_graph, device_ctx.rr_graph_builder, device_ctx.grid, 0, - directs, clb2clb_directs); - } else { - build_crr_graph_edges(device_ctx.rr_graph, device_ctx.rr_graph_builder, crr_opts); + // Build the connections tile by tile: + // We classify rr_nodes into a general switch block (GSB) data structure + // where we create edges to each rr_nodes in the GSB with respect to + // Fc_in and Fc_out, switch block patterns + // In addition, we will also handle direct-connections: + // Add edges that bridge OPINs and IPINs to the rr_graph + // Create edges for a tileable rr_graph + build_rr_graph_edges(device_ctx.rr_graph, + device_ctx.rr_graph_builder, + rr_node_driver_switches, + grids, vib_grid, 0, + device_chan_width, + segment_inf, segment_inf_x, segment_inf_y, + Fc_in, Fc_out, + sb_type, Fs, sb_subtype, sub_fs, + perimeter_cb, + opin2all_sides, concat_wire, + wire_opposite_side, + delayless_rr_switch); + + // Build direction connection lists + // TODO: use tile direct builder + // Create data structure of direct-connections + std::vector clb_to_clb_directs = alloc_and_load_clb_to_clb_directs(directs, delayless_switch); + std::vector clb2clb_directs; + for (size_t idirect = 0; idirect < directs.size(); ++idirect) { + // Sanity checks on rr switch id + VTR_ASSERT(device_ctx.rr_graph.valid_switch(RRSwitchId(clb_to_clb_directs[idirect].switch_index))); + clb2clb_directs.push_back(clb_to_clb_directs[idirect]); } + build_rr_graph_direct_connections(device_ctx.rr_graph, device_ctx.rr_graph_builder, device_ctx.grid, 0, + directs, clb2clb_directs); + // Allocate and load routing resource switches, which are derived from the switches from the architecture file, // based on their fanin in the rr graph. This routine also adjusts the rr nodes to point to these new rr switches device_ctx.rr_graph_builder.init_fan_in(); From 008a4e2ac1b026dc5859b4962284174698843ad8 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Thu, 23 Oct 2025 12:32:34 -0700 Subject: [PATCH 054/120] [vpr][route][crr] pass crr_opts to build_rr_graph_regular_edges --- .../tileable_rr_graph/tileable_rr_graph_edge_builder.cpp | 4 +++- .../tileable_rr_graph/tileable_rr_graph_edge_builder.h | 2 ++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp index 09b25caa5d..928203eefe 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp @@ -104,6 +104,7 @@ void build_rr_graph_edges_for_sink_nodes(const RRGraphView& rr_graph, void build_rr_graph_edges(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder, vtr::vector& rr_node_driver_switches, + const t_crr_opts& crr_opts, const DeviceGrid& grids, const VibDeviceGrid& vib_grid, const size_t& layer, @@ -140,6 +141,7 @@ void build_rr_graph_edges(const RRGraphView& rr_graph, build_rr_graph_regular_edges(rr_graph, rr_graph_builder, rr_node_driver_switches, + crr_opts, grids, layer, device_chan_width, @@ -295,6 +297,7 @@ void build_rr_graph_vib_edges(const RRGraphView& rr_graph, void build_rr_graph_regular_edges(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder, vtr::vector& rr_node_driver_switches, + const t_crr_opts& crr_opts, const DeviceGrid& grids, const size_t& layer, const vtr::Point& device_chan_width, @@ -343,7 +346,6 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, sb_type, Fs, sb_subtype, sub_fs, concat_wire, wire_opposite_side, segment_inf); - /* Build edges for a GSB */ /* Build edges for a GSB */ build_edges_for_one_tileable_rr_gsb(rr_graph_builder, rr_gsb, track2ipin_map, opin2track_map, diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.h index 73f8ff65f8..95d7f3f774 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.h @@ -23,6 +23,7 @@ void build_rr_graph_edges(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder, vtr::vector& rr_node_driver_switches, + const t_crr_opts& crr_opts, const DeviceGrid& grids, const VibDeviceGrid& vib_grid, const size_t& layer, @@ -79,6 +80,7 @@ void build_rr_graph_vib_edges(const RRGraphView& rr_graph, void build_rr_graph_regular_edges(const RRGraphView& rr_graph, RRGraphBuilder& rr_graph_builder, vtr::vector& rr_node_driver_switches, + const t_crr_opts& crr_opts, const DeviceGrid& grids, const size_t& layer, const vtr::Point& device_chan_width, From 8975125229a3a1a4d75505cebe56b4e307d0450c Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Fri, 24 Oct 2025 06:50:08 -0700 Subject: [PATCH 055/120] [vpr][route][crr] add get_connection_builder to crrgenerator --- .../tileable_rr_graph/crr_generator/crr_generator.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h index 38107900e0..0266273396 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h @@ -34,6 +34,10 @@ class CRRGraphGenerator { */ void run(); + const CRRConnectionBuilder* get_connection_builder() const { + return connection_builder_.get(); + } + private: const t_crr_opts& crr_opts_; const RRGraph& input_graph_; From 3aaee29d0a22aa8e9c9c2bf803aa72b5488f6e55 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Fri, 24 Oct 2025 12:13:34 -0700 Subject: [PATCH 056/120] make format --- .../crr_generator/crr_common.h | 340 ++++--- .../crr_generator/crr_connection_builder.cpp | 950 +++++++++--------- .../crr_generator/crr_connection_builder.h | 315 +++--- .../crr_generator/crr_edge_builder.cpp | 15 + .../crr_generator/crr_edge_builder.h | 21 + .../crr_generator/crr_generator.cpp | 283 +++--- .../crr_generator/crr_generator.h | 6 +- .../crr_generator/crr_pattern_matcher.h | 87 +- .../crr_switch_block_manager.cpp | 40 +- .../crr_generator/crr_switch_block_manager.h | 26 +- .../crr_generator/crr_thread_pool.cpp | 195 ++-- .../crr_generator/crr_thread_pool.h | 256 ++--- .../crr_generator/custom_rr_graph.cpp | 253 +++-- .../crr_generator/custom_rr_graph.h | 845 ++++++++-------- .../crr_generator/data_frame_processor.cpp | 26 +- .../crr_generator/data_frame_processor.h | 284 +++--- .../crr_generator/node_lookup_manager.cpp | 262 ++--- .../crr_generator/node_lookup_manager.h | 214 ++-- .../crr_generator/xml_handler.cpp | 831 +++++++-------- .../crr_generator/xml_handler.h | 8 +- .../tileable_rr_graph_builder.cpp | 25 +- .../tileable_rr_graph_edge_builder.cpp | 52 +- 22 files changed, 2720 insertions(+), 2614 deletions(-) create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp create mode 100644 vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h index f337d15d8c..3b75418d76 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h @@ -61,79 +61,94 @@ constexpr SwitchId DELAY_0_ID = 1; constexpr int DEFAULT_SWITCH_DELAY_MIN = 10000; // Node types -enum class NodeType { SOURCE, SINK, IPIN, OPIN, CHANX, CHANY, INVALID }; +enum class NodeType { SOURCE, + SINK, + IPIN, + OPIN, + CHANX, + CHANY, + INVALID }; // Direction types -enum class Direction { INC_DIR, DEC_DIR }; +enum class Direction { INC_DIR, + DEC_DIR }; // Side types -enum class Side { LEFT, RIGHT, TOP, BOTTOM, IPIN, OPIN, INVALID }; +enum class Side { LEFT, + RIGHT, + TOP, + BOTTOM, + IPIN, + OPIN, + INVALID }; // Location structure struct Location { - Coordinate x_low{-1}; - Coordinate x_high{-1}; - Coordinate y_low{-1}; - Coordinate y_high{-1}; - Coordinate layer{-1}; - std::string ptc; - std::string side; - - Location() = default; - Location(Coordinate xl, Coordinate xh, Coordinate yl, Coordinate yh, - Coordinate l, const std::string& p, const std::string& s) - : x_low(xl), - x_high(xh), - y_low(yl), - y_high(yh), - layer(l), - ptc(p), - side(s) {} - - bool operator==(const Location& other) const { - return x_low == other.x_low && x_high == other.x_high && - y_low == other.y_low && y_high == other.y_high && - layer == other.layer && ptc == other.ptc && side == other.side; - } + Coordinate x_low{-1}; + Coordinate x_high{-1}; + Coordinate y_low{-1}; + Coordinate y_high{-1}; + Coordinate layer{-1}; + std::string ptc; + std::string side; + + Location() = default; + Location(Coordinate xl, Coordinate xh, Coordinate yl, Coordinate yh, Coordinate l, const std::string& p, const std::string& s) + : x_low(xl) + , x_high(xh) + , y_low(yl) + , y_high(yh) + , layer(l) + , ptc(p) + , side(s) {} + + bool operator==(const Location& other) const { + return x_low == other.x_low && x_high == other.x_high && y_low == other.y_low && y_high == other.y_high && layer == other.layer && ptc == other.ptc && side == other.side; + } }; // Node timing information struct NodeTiming { - DelayValue r{0.0}; - DelayValue c{0.0}; + DelayValue r{0.0}; + DelayValue c{0.0}; - NodeTiming() = default; - NodeTiming(DelayValue r_val, DelayValue c_val) : r(r_val), c(c_val) {} + NodeTiming() = default; + NodeTiming(DelayValue r_val, DelayValue c_val) + : r(r_val) + , c(c_val) {} }; // Node segment information struct NodeSegmentId { - int segment_id{-1}; + int segment_id{-1}; - NodeSegmentId() = default; - NodeSegmentId(int segment_id_val) : segment_id(segment_id_val) {} + NodeSegmentId() = default; + NodeSegmentId(int segment_id_val) + : segment_id(segment_id_val) {} - bool empty() const { return segment_id == -1; } + bool empty() const { return segment_id == -1; } }; // Timing information struct Timing { - DelayValue Cin{0.0}; - DelayValue Tdel{0.0}; + DelayValue Cin{0.0}; + DelayValue Tdel{0.0}; - Timing() = default; - Timing(DelayValue cin_val, DelayValue tdel_val) - : Cin(cin_val), Tdel(tdel_val) {} + Timing() = default; + Timing(DelayValue cin_val, DelayValue tdel_val) + : Cin(cin_val) + , Tdel(tdel_val) {} }; // Sizing information struct Sizing { - DelayValue mux_trans_size{0.0}; - DelayValue buf_size{0.0}; + DelayValue mux_trans_size{0.0}; + DelayValue buf_size{0.0}; - Sizing() = default; - Sizing(DelayValue mux_size, DelayValue buffer_size) - : mux_trans_size(mux_size), buf_size(buffer_size) {} + Sizing() = default; + Sizing(DelayValue mux_size, DelayValue buffer_size) + : mux_trans_size(mux_size) + , buf_size(buffer_size) {} }; /** @@ -143,65 +158,64 @@ struct Sizing { * It is used to store the connection information and to compare connections. */ class Connection { -public: - Connection(NodeId sink_node, NodeId src_node, SwitchId switch_id) - : sink_node_(sink_node), src_node_(src_node), switch_id_(switch_id) {} - NodeId sink_node() const { return sink_node_; } - NodeId src_node() const { return src_node_; } - SwitchId switch_id() const { return switch_id_; } - - bool operator<(const Connection& other) const { - return std::tie(sink_node_, src_node_, switch_id_) < - std::tie(other.sink_node_, other.src_node_, other.switch_id_); - } - - bool operator==(const Connection& other) const { - return sink_node_ == other.sink_node_ && src_node_ == other.src_node_ && - switch_id_ == other.switch_id_; - } - -private: - NodeId sink_node_; - NodeId src_node_; - SwitchId switch_id_; + public: + Connection(NodeId sink_node, NodeId src_node, SwitchId switch_id) + : sink_node_(sink_node) + , src_node_(src_node) + , switch_id_(switch_id) {} + NodeId sink_node() const { return sink_node_; } + NodeId src_node() const { return src_node_; } + SwitchId switch_id() const { return switch_id_; } + + bool operator<(const Connection& other) const { + return std::tie(sink_node_, src_node_, switch_id_) < std::tie(other.sink_node_, other.src_node_, other.switch_id_); + } + + bool operator==(const Connection& other) const { + return sink_node_ == other.sink_node_ && src_node_ == other.src_node_ && switch_id_ == other.switch_id_; + } + + private: + NodeId sink_node_; + NodeId src_node_; + SwitchId switch_id_; }; // Hash function for Location struct LocationHash { - std::size_t operator()(const Location& loc) const { - auto h1 = std::hash{}(loc.x_low); - auto h2 = std::hash{}(loc.x_high); - auto h3 = std::hash{}(loc.y_low); - auto h4 = std::hash{}(loc.y_high); - auto h5 = std::hash{}(loc.ptc); - return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3) ^ (h5 << 4); - } + std::size_t operator()(const Location& loc) const { + auto h1 = std::hash{}(loc.x_low); + auto h2 = std::hash{}(loc.x_high); + auto h3 = std::hash{}(loc.y_low); + auto h4 = std::hash{}(loc.y_high); + auto h5 = std::hash{}(loc.ptc); + return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3) ^ (h5 << 4); + } }; // Node hash type for lookups -using NodeHash = std::tuple; +using NodeHash = std::tuple; // Hash function for NodeHash struct NodeHasher { - std::size_t operator()(const NodeHash& hash) const { - auto h1 = std::hash{}(static_cast(std::get<0>(hash))); - auto h2 = std::hash{}(std::get<1>(hash)); - auto h3 = std::hash{}(std::get<2>(hash)); - auto h4 = std::hash{}(std::get<3>(hash)); - auto h5 = std::hash{}(std::get<4>(hash)); - auto h6 = std::hash{}(std::get<5>(hash)); - - // Combine hashes using a better mixing function - std::size_t result = h1; - result ^= h2 + 0x9e3779b9 + (result << 6) + (result >> 2); - result ^= h3 + 0x9e3779b9 + (result << 6) + (result >> 2); - result ^= h4 + 0x9e3779b9 + (result << 6) + (result >> 2); - result ^= h5 + 0x9e3779b9 + (result << 6) + (result >> 2); - result ^= h6 + 0x9e3779b9 + (result << 6) + (result >> 2); - - return result; - } + std::size_t operator()(const NodeHash& hash) const { + auto h1 = std::hash{}(static_cast(std::get<0>(hash))); + auto h2 = std::hash{}(std::get<1>(hash)); + auto h3 = std::hash{}(std::get<2>(hash)); + auto h4 = std::hash{}(std::get<3>(hash)); + auto h5 = std::hash{}(std::get<4>(hash)); + auto h6 = std::hash{}(std::get<5>(hash)); + + // Combine hashes using a better mixing function + std::size_t result = h1; + result ^= h2 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h3 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h4 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h5 + 0x9e3779b9 + (result << 6) + (result >> 2); + result ^= h6 + 0x9e3779b9 + (result << 6) + (result >> 2); + + return result; + } }; // Edge hash type for lookups @@ -209,65 +223,65 @@ using EdgeKey = std::tuple; // Utility functions inline std::string to_string(NodeType type) { - switch (type) { - case NodeType::SOURCE: - return "SOURCE"; - case NodeType::SINK: - return "SINK"; - case NodeType::IPIN: - return "IPIN"; - case NodeType::OPIN: - return "OPIN"; - case NodeType::CHANX: - return "CHANX"; - case NodeType::CHANY: - return "CHANY"; - default: - return "UNKNOWN"; - } + switch (type) { + case NodeType::SOURCE: + return "SOURCE"; + case NodeType::SINK: + return "SINK"; + case NodeType::IPIN: + return "IPIN"; + case NodeType::OPIN: + return "OPIN"; + case NodeType::CHANX: + return "CHANX"; + case NodeType::CHANY: + return "CHANY"; + default: + return "UNKNOWN"; + } } inline NodeType string_to_node_type(const std::string& str) { - if (str == "SOURCE" || str == "source") return NodeType::SOURCE; - if (str == "SINK" || str == "sink") return NodeType::SINK; - if (str == "IPIN" || str == "ipin") return NodeType::IPIN; - if (str == "OPIN" || str == "opin") return NodeType::OPIN; - if (str == "CHANX" || str == "chanx") return NodeType::CHANX; - if (str == "CHANY" || str == "chany") return NodeType::CHANY; - throw std::invalid_argument("Unknown node type: " + str); + if (str == "SOURCE" || str == "source") return NodeType::SOURCE; + if (str == "SINK" || str == "sink") return NodeType::SINK; + if (str == "IPIN" || str == "ipin") return NodeType::IPIN; + if (str == "OPIN" || str == "opin") return NodeType::OPIN; + if (str == "CHANX" || str == "chanx") return NodeType::CHANX; + if (str == "CHANY" || str == "chany") return NodeType::CHANY; + throw std::invalid_argument("Unknown node type: " + str); } inline std::string to_string(Direction dir) { - return (dir == Direction::INC_DIR) ? "INC_DIR" : "DEC_DIR"; + return (dir == Direction::INC_DIR) ? "INC_DIR" : "DEC_DIR"; } inline std::string to_string(Side side) { - switch (side) { - case Side::LEFT: - return "Left"; - case Side::RIGHT: - return "Right"; - case Side::TOP: - return "Top"; - case Side::BOTTOM: - return "Bottom"; - case Side::IPIN: - return "IPIN"; - case Side::OPIN: - return "OPIN"; - default: - return "UNKNOWN"; - } + switch (side) { + case Side::LEFT: + return "Left"; + case Side::RIGHT: + return "Right"; + case Side::TOP: + return "Top"; + case Side::BOTTOM: + return "Bottom"; + case Side::IPIN: + return "IPIN"; + case Side::OPIN: + return "OPIN"; + default: + return "UNKNOWN"; + } } inline Side string_to_side(const std::string& str) { - if (str == "Left") return Side::LEFT; - if (str == "Right") return Side::RIGHT; - if (str == "Top") return Side::TOP; - if (str == "Bottom") return Side::BOTTOM; - if (str == "IPIN") return Side::IPIN; - if (str == "OPIN") return Side::OPIN; - throw std::invalid_argument("Unknown side: " + str); + if (str == "Left") return Side::LEFT; + if (str == "Right") return Side::RIGHT; + if (str == "Top") return Side::TOP; + if (str == "Bottom") return Side::BOTTOM; + if (str == "IPIN") return Side::IPIN; + if (str == "OPIN") return Side::OPIN; + throw std::invalid_argument("Unknown side: " + str); } /** @@ -276,11 +290,11 @@ inline Side string_to_side(const std::string& str) { */ inline size_t get_memory_usage() { #ifdef _WIN32 - PROCESS_MEMORY_COUNTERS pmc; - if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) { - return pmc.WorkingSetSize / 1024; // Convert bytes to KB - } - return 0; + PROCESS_MEMORY_COUNTERS pmc; + if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc))) { + return pmc.WorkingSetSize / 1024; // Convert bytes to KB + } + return 0; #else struct rusage usage; getrusage(RUSAGE_SELF, &usage); @@ -314,7 +328,7 @@ inline size_t get_peak_memory_usage() { return std::stoul(value); // Already in KB } } - + // Fallback to getrusage if /proc/self/status is not available struct rusage usage; getrusage(RUSAGE_SELF, &usage); @@ -328,33 +342,33 @@ inline size_t get_peak_memory_usage() { // Exception classes class RRGeneratorException : public std::runtime_error { - public: - explicit RRGeneratorException(const std::string& message) - : std::runtime_error(message) {} + public: + explicit RRGeneratorException(const std::string& message) + : std::runtime_error(message) {} }; class ConfigException : public RRGeneratorException { - public: - explicit ConfigException(const std::string& message) - : RRGeneratorException("Configuration error: " + message) {} + public: + explicit ConfigException(const std::string& message) + : RRGeneratorException("Configuration error: " + message) {} }; class FileException : public RRGeneratorException { - public: - explicit FileException(const std::string& message) - : RRGeneratorException("File error: " + message) {} + public: + explicit FileException(const std::string& message) + : RRGeneratorException("File error: " + message) {} }; class ParseException : public RRGeneratorException { - public: - explicit ParseException(const std::string& message) - : RRGeneratorException("Parse error: " + message) {} + public: + explicit ParseException(const std::string& message) + : RRGeneratorException("Parse error: " + message) {} }; class SwitchException : public RRGeneratorException { - public: - explicit SwitchException(const std::string& message) - : RRGeneratorException("Switch error: " + message) {} + public: + explicit SwitchException(const std::string& message) + : RRGeneratorException("Switch error: " + message) {} }; -} // namespace crrgenerator \ No newline at end of file +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index 977eb629ea..cba4468d4a 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -13,9 +13,9 @@ namespace crrgenerator { static bool is_integer(const std::string& s) { - int value; - auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value); - return ec == std::errc() && ptr == s.data() + s.size(); + int value; + auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), value); + return ec == std::errc() && ptr == s.data() + s.size(); } // static void write_node_storage_to_json( @@ -48,551 +48,567 @@ static bool is_integer(const std::string& s) { // } CRRConnectionBuilder::CRRConnectionBuilder(const RRGraph& rr_graph, - const NodeLookupManager& node_lookup, - const SwitchBlockManager& sb_manager) - : rr_graph_(rr_graph), node_lookup_(node_lookup), sb_manager_(sb_manager) {} + const NodeLookupManager& node_lookup, + const SwitchBlockManager& sb_manager) + : rr_graph_(rr_graph) + , node_lookup_(node_lookup) + , sb_manager_(sb_manager) {} void CRRConnectionBuilder::initialize( Coordinate fpga_grid_x, Coordinate fpga_grid_y, bool is_annotated_excel) { - fpga_grid_x_ = fpga_grid_x; - fpga_grid_y_ = fpga_grid_y; - is_annotated_excel_ = is_annotated_excel; - - for (const auto& original_switch : rr_graph_.get_switches()) { - std::string switch_name = original_switch.get_name(); - std::transform(switch_name.begin(), switch_name.end(), switch_name.begin(), - ::tolower); - - if (switch_name.find("delayless") != std::string::npos) { - VTR_LOG("Adding delayless switch: %s\n", switch_name.c_str()); - default_switch_id_["delayless"] = original_switch.get_id(); - } else if (switch_name.find("ipin") != std::string::npos) { - VTR_LOG("Adding ipin switch: %s\n", switch_name.c_str()); - default_switch_id_["ipin"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l1(_.*)?)"))) { - VTR_LOG("Adding l1 switch: %s\n", switch_name.c_str()); - default_switch_id_["l1"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l2(_.*)?)"))) { - VTR_LOG("Adding l2 switch: %s\n", switch_name.c_str()); - default_switch_id_["l2"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l4(_.*)?)"))) { - VTR_LOG("Adding l4 switch: %s\n", switch_name.c_str()); - default_switch_id_["l4"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l8(_.*)?)"))) { - VTR_LOG("Adding l8 switch: %s\n", switch_name.c_str()); - default_switch_id_["l8"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l12(_.*)?)"))) { - VTR_LOG("Adding l12 switch: %s\n", switch_name.c_str()); - default_switch_id_["l12"] = original_switch.get_id(); - } else { - VTR_LOG_ERROR("Unknown switch type: %s\n", switch_name.c_str()); + fpga_grid_x_ = fpga_grid_x; + fpga_grid_y_ = fpga_grid_y; + is_annotated_excel_ = is_annotated_excel; + + for (const auto& original_switch : rr_graph_.get_switches()) { + std::string switch_name = original_switch.get_name(); + std::transform(switch_name.begin(), switch_name.end(), switch_name.begin(), + ::tolower); + + if (switch_name.find("delayless") != std::string::npos) { + VTR_LOG("Adding delayless switch: %s\n", switch_name.c_str()); + default_switch_id_["delayless"] = original_switch.get_id(); + } else if (switch_name.find("ipin") != std::string::npos) { + VTR_LOG("Adding ipin switch: %s\n", switch_name.c_str()); + default_switch_id_["ipin"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l1(_.*)?)"))) { + VTR_LOG("Adding l1 switch: %s\n", switch_name.c_str()); + default_switch_id_["l1"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l2(_.*)?)"))) { + VTR_LOG("Adding l2 switch: %s\n", switch_name.c_str()); + default_switch_id_["l2"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l4(_.*)?)"))) { + VTR_LOG("Adding l4 switch: %s\n", switch_name.c_str()); + default_switch_id_["l4"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l8(_.*)?)"))) { + VTR_LOG("Adding l8 switch: %s\n", switch_name.c_str()); + default_switch_id_["l8"] = original_switch.get_id(); + } else if (std::regex_match(switch_name, std::regex(R"(l12(_.*)?)"))) { + VTR_LOG("Adding l12 switch: %s\n", switch_name.c_str()); + default_switch_id_["l12"] = original_switch.get_id(); + } else { + VTR_LOG_ERROR("Unknown switch type: %s\n", switch_name.c_str()); + } } - } - assert(default_switch_id_.size() == rr_graph_.get_switches().size()); - sw_zero_id_ = static_cast(rr_graph_.get_switches().size()); + assert(default_switch_id_.size() == rr_graph_.get_switches().size()); + sw_zero_id_ = static_cast(rr_graph_.get_switches().size()); - // Total locations is the number of locations on the FPGA grid minus the 4 - // corner locations. - total_locations_ = static_cast(fpga_grid_x_ * fpga_grid_y_) - 4; - processed_locations_ = 0; + // Total locations is the number of locations on the FPGA grid minus the 4 + // corner locations. + total_locations_ = static_cast(fpga_grid_x_ * fpga_grid_y_) - 4; + processed_locations_ = 0; - all_connections_.resize(static_cast(fpga_grid_x_ + 1), - std::vector>(static_cast(fpga_grid_y_ + 1)) - ); + all_connections_.resize(static_cast(fpga_grid_x_ + 1), + std::vector>(static_cast(fpga_grid_y_ + 1))); - VTR_LOG("CRRConnectionBuilder initialized for %d x %d grid (%zu locations)\n", - fpga_grid_x_, fpga_grid_y_, total_locations_); + VTR_LOG("CRRConnectionBuilder initialized for %d x %d grid (%zu locations)\n", + fpga_grid_x_, fpga_grid_y_, total_locations_); } void CRRConnectionBuilder::build_connections_for_location(Coordinate x, - Coordinate y, - std::vector& tile_connections) { - - // Find matching switch block pattern - std::string sw_name = "SB_" + std::to_string(x) + "__" + std::to_string(y) + "_"; - std::string pattern = sb_manager_.find_matching_pattern(sw_name); - tile_connections.clear(); - - if (pattern.empty()) { - VTR_LOG_DEBUG("No pattern found for switch block at (%d, %d)\n", x, y); - return; - } - - const DataFrame* df = sb_manager_.get_switch_block_dataframe(pattern); - if (df == nullptr) { - VTR_LOG_WARN("No dataframe found for pattern '%s' at (%d, %d)\n", pattern.c_str(), x, y); - return; - } - - VTR_LOG("Processing switch block '%s' with pattern '%s' at (%d, %d)\n", - sw_name.c_str(), pattern.c_str(), x, y); - - // Get combined nodes for this location - auto combined_nodes = node_lookup_.get_combined_nodes(x, y); - - // Get vertical and horizontal nodes - auto source_nodes = get_vertical_nodes(x, y, *df, combined_nodes); - auto sink_nodes = get_horizontal_nodes(x, y, *df, combined_nodes); - - // Build connections based on dataframe - for (auto row_iter = df->begin(); row_iter != df->end(); ++row_iter) { - size_t row_idx = row_iter.get_row_index(); - if (row_idx < NUM_EMPTY_ROWS) continue; - - for (size_t col_idx = NUM_EMPTY_COLS; col_idx < df->cols(); ++col_idx) { - const Cell& cell = df->at(row_idx, col_idx); - - if (!cell.is_empty()) { - auto source_it = source_nodes.find(row_idx); - auto sink_it = sink_nodes.find(col_idx); - - if (source_it != source_nodes.end() && sink_it != sink_nodes.end()) { - NodeId source_node = source_it->second; - NodeType source_node_type = rr_graph_.get_node(source_node)->get_type(); - NodeId sink_node = sink_it->second; - NodeType sink_node_type = rr_graph_.get_node(sink_node)->get_type(); - // If the source node is an IPIN, then it should be considered as - // a sink of the connection. - if (source_node_type == NodeType::IPIN) { - SwitchId switch_id = - get_edge_switch_id(cell.as_string(), - to_string(source_node_type), - sink_node, - source_node); - - tile_connections.emplace_back(source_node, sink_node, switch_id); - } else { - int segment_length = -1; - if (sink_node_type == NodeType::CHANX || - sink_node_type == NodeType::CHANY) { - segment_length = rr_graph_.get_segment(rr_graph_.get_node(sink_node)->get_segment().segment_id)->get_length(); + Coordinate y, + std::vector& tile_connections) const { + + // Find matching switch block pattern + std::string sw_name = "SB_" + std::to_string(x) + "__" + std::to_string(y) + "_"; + std::string pattern = sb_manager_.find_matching_pattern(sw_name); + tile_connections.clear(); + + if (pattern.empty()) { + VTR_LOG_DEBUG("No pattern found for switch block at (%d, %d)\n", x, y); + return; + } + + const DataFrame* df = sb_manager_.get_switch_block_dataframe(pattern); + if (df == nullptr) { + VTR_LOG_WARN("No dataframe found for pattern '%s' at (%d, %d)\n", pattern.c_str(), x, y); + return; + } + + VTR_LOG("Processing switch block '%s' with pattern '%s' at (%d, %d)\n", + sw_name.c_str(), pattern.c_str(), x, y); + + // Get combined nodes for this location + auto combined_nodes = node_lookup_.get_combined_nodes(x, y); + + // Get vertical and horizontal nodes + auto source_nodes = get_vertical_nodes(x, y, *df, combined_nodes); + auto sink_nodes = get_horizontal_nodes(x, y, *df, combined_nodes); + + // Build connections based on dataframe + for (auto row_iter = df->begin(); row_iter != df->end(); ++row_iter) { + size_t row_idx = row_iter.get_row_index(); + if (row_idx < NUM_EMPTY_ROWS) { + continue; + } + + for (size_t col_idx = NUM_EMPTY_COLS; col_idx < df->cols(); ++col_idx) { + const Cell& cell = df->at(row_idx, col_idx); + + if (!cell.is_empty()) { + auto source_it = source_nodes.find(row_idx); + auto sink_it = sink_nodes.find(col_idx); + + if (source_it != source_nodes.end() && sink_it != sink_nodes.end()) { + NodeId source_node = source_it->second; + NodeType source_node_type = rr_graph_.get_node(source_node)->get_type(); + NodeId sink_node = sink_it->second; + NodeType sink_node_type = rr_graph_.get_node(sink_node)->get_type(); + // If the source node is an IPIN, then it should be considered as + // a sink of the connection. + if (source_node_type == NodeType::IPIN) { + SwitchId switch_id = + get_edge_switch_id(cell.as_string(), + to_string(source_node_type), + sink_node, + source_node); + + tile_connections.emplace_back(source_node, sink_node, switch_id); + } else { + int segment_length = -1; + if (sink_node_type == NodeType::CHANX || sink_node_type == NodeType::CHANY) { + segment_length = rr_graph_.get_segment(rr_graph_.get_node(sink_node)->get_segment().segment_id)->get_length(); + } + SwitchId switch_id = + get_edge_switch_id(cell.as_string(), + to_string(sink_node_type), + source_node, + sink_node, + segment_length); + + tile_connections.emplace_back(sink_node, source_node, switch_id); + } + } } - SwitchId switch_id = - get_edge_switch_id(cell.as_string(), - to_string(sink_node_type), - source_node, - sink_node, - segment_length); - - tile_connections.emplace_back(sink_node, source_node, switch_id); - } } - } } - } - { - std::lock_guard lock(connections_mutex_); - storage_sw_names_.push_back(sw_name); - storage_source_nodes_.push_back(source_nodes); - storage_sink_nodes_.push_back(sink_nodes); - } + { + std::lock_guard lock(connections_mutex_); + storage_sw_names_.push_back(sw_name); + storage_source_nodes_.push_back(source_nodes); + storage_sink_nodes_.push_back(sink_nodes); + } - std::sort(tile_connections.begin(), tile_connections.end()); - tile_connections.erase(std::unique(tile_connections.begin(), tile_connections.end()), tile_connections.end()); - tile_connections.shrink_to_fit(); + std::sort(tile_connections.begin(), tile_connections.end()); + tile_connections.erase(std::unique(tile_connections.begin(), + tile_connections.end()), + tile_connections.end()); + tile_connections.shrink_to_fit(); - VTR_LOG_DEBUG("Generated %zu connections for location (%d, %d)\n", - tile_connections.size(), x, y); + VTR_LOG_DEBUG("Generated %zu connections for location (%d, %d)\n", + tile_connections.size(), x, y); } -std::vector CRRConnectionBuilder::get_tile_connections(Coordinate tile_x, Coordinate tile_y) { - std::vector tile_connections; - build_connections_for_location(tile_x, tile_y, tile_connections); +std::vector CRRConnectionBuilder::get_tile_connections(Coordinate tile_x, Coordinate tile_y) const { + std::vector tile_connections; + build_connections_for_location(tile_x, tile_y, tile_connections); - return tile_connections; + return tile_connections; } std::map CRRConnectionBuilder::get_vertical_nodes( - Coordinate x, Coordinate y, const DataFrame& df, + Coordinate x, + Coordinate y, + const DataFrame& df, const std::unordered_map& node_lookup) { - std::map source_nodes; - std::string prev_seg_type = ""; - int prev_seg_index = -1; - Side prev_side = Side::INVALID; - int prev_ptc_number = 0; - - for (size_t row = NUM_EMPTY_ROWS; row < df.rows(); ++row) { - SegmentInfo info = parse_segment_info(df, row, true); - NodeId node_id = 0; - - if (info.side == Side::IPIN || info.side == Side::OPIN) { - node_id = process_opin_ipin_node(info, x, y, node_lookup); - } else if (info.side == Side::LEFT || info.side == Side::RIGHT || - info.side == Side::TOP || info.side == Side::BOTTOM) { - node_id = - process_channel_node(info, x, y, node_lookup, prev_seg_index, - prev_side, prev_seg_type, prev_ptc_number, true); - } + std::map source_nodes; + std::string prev_seg_type = ""; + int prev_seg_index = -1; + Side prev_side = Side::INVALID; + int prev_ptc_number = 0; + + for (size_t row = NUM_EMPTY_ROWS; row < df.rows(); ++row) { + SegmentInfo info = parse_segment_info(df, row, true); + NodeId node_id = 0; + + if (info.side == Side::IPIN || info.side == Side::OPIN) { + node_id = process_opin_ipin_node(info, x, y, node_lookup); + } else if (info.side == Side::LEFT || info.side == Side::RIGHT || info.side == Side::TOP || info.side == Side::BOTTOM) { + node_id = + process_channel_node(info, x, y, node_lookup, prev_seg_index, + prev_side, prev_seg_type, prev_ptc_number, true); + } - if (node_id > 0) { - source_nodes[row] = node_id; - } + if (node_id > 0) { + source_nodes[row] = node_id; + } - prev_seg_type = info.seg_type; - prev_side = info.side; - } + prev_seg_type = info.seg_type; + prev_side = info.side; + } - return source_nodes; + return source_nodes; } std::map CRRConnectionBuilder::get_horizontal_nodes( - Coordinate x, Coordinate y, const DataFrame& df, + Coordinate x, + Coordinate y, + const DataFrame& df, const std::unordered_map& node_lookup) { - std::map sink_nodes; - std::string prev_seg_type = ""; - int prev_seg_index = -1; - Side prev_side = Side::INVALID; - int prev_ptc_number = 0; - - for (size_t col = NUM_EMPTY_COLS; col < df.cols(); ++col) { - SegmentInfo info = parse_segment_info(df, col, false); - if (info.side == Side::INVALID) { - continue; - } - NodeId node_id = 0; - - if (info.side == Side::IPIN) { - node_id = process_opin_ipin_node(info, x, y, node_lookup); - } else if (info.side == Side::LEFT || info.side == Side::RIGHT || - info.side == Side::TOP || info.side == Side::BOTTOM) { - node_id = process_channel_node(info, x, y, node_lookup, prev_seg_index, - prev_side, prev_seg_type, prev_ptc_number, - false); - } + std::map sink_nodes; + std::string prev_seg_type = ""; + int prev_seg_index = -1; + Side prev_side = Side::INVALID; + int prev_ptc_number = 0; + + for (size_t col = NUM_EMPTY_COLS; col < df.cols(); ++col) { + SegmentInfo info = parse_segment_info(df, col, false); + if (info.side == Side::INVALID) { + continue; + } + NodeId node_id = 0; + + if (info.side == Side::IPIN) { + node_id = process_opin_ipin_node(info, x, y, node_lookup); + } else if (info.side == Side::LEFT || info.side == Side::RIGHT || info.side == Side::TOP || info.side == Side::BOTTOM) { + node_id = process_channel_node(info, x, y, node_lookup, prev_seg_index, + prev_side, prev_seg_type, prev_ptc_number, + false); + } - if (node_id > 0) { - sink_nodes[col] = node_id; - } + if (node_id > 0) { + sink_nodes[col] = node_id; + } - prev_seg_type = info.seg_type; - prev_side = info.side; - } + prev_seg_type = info.seg_type; + prev_side = info.side; + } - return sink_nodes; + return sink_nodes; } CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info( - const DataFrame& df, size_t row_or_col, bool is_vertical) { - SegmentInfo info; - - if (is_vertical) { - // Vertical processing (rows) - const Cell& side_cell = df.at(row_or_col, 0); - const Cell& type_cell = df.at(row_or_col, 1); - const Cell& index_cell = df.at(row_or_col, 2); - const Cell& tap_cell = df.at(row_or_col, 3); - - if (!side_cell.is_empty()) { - info.side = string_to_side(side_cell.as_string()); - } - if (!type_cell.is_empty()) { - info.seg_type = type_cell.as_string(); - } - if (!index_cell.is_empty()) { - info.seg_index = static_cast(index_cell.as_int()); - } - if (!tap_cell.is_empty() && tap_cell.is_number()) { - info.tap = static_cast(tap_cell.as_int()); - } - } else { - // Horizontal processing (columns) - const Cell& side_cell = df.at(0, row_or_col); - const Cell& type_cell = df.at(1, row_or_col); - const Cell& index_cell = - df.at(3, row_or_col); // Note: row 3 for horizontal - const Cell& tap_cell = df.at(4, row_or_col); // Note: row 4 for horizontal - - if (!side_cell.is_empty()) { - info.side = string_to_side(side_cell.as_string()); - } - if (!type_cell.is_empty()) { - info.seg_type = type_cell.as_string(); - } - if (!index_cell.is_empty()) { - info.seg_index = static_cast(index_cell.as_int()); - } - if (!tap_cell.is_empty() && tap_cell.is_number()) { - info.tap = static_cast(tap_cell.as_int()); + const DataFrame& df, + size_t row_or_col, + bool is_vertical) { + SegmentInfo info; + + if (is_vertical) { + // Vertical processing (rows) + const Cell& side_cell = df.at(row_or_col, 0); + const Cell& type_cell = df.at(row_or_col, 1); + const Cell& index_cell = df.at(row_or_col, 2); + const Cell& tap_cell = df.at(row_or_col, 3); + + if (!side_cell.is_empty()) { + info.side = string_to_side(side_cell.as_string()); + } + if (!type_cell.is_empty()) { + info.seg_type = type_cell.as_string(); + } + if (!index_cell.is_empty()) { + info.seg_index = static_cast(index_cell.as_int()); + } + if (!tap_cell.is_empty() && tap_cell.is_number()) { + info.tap = static_cast(tap_cell.as_int()); + } } else { - info.tap = 1; + // Horizontal processing (columns) + const Cell& side_cell = df.at(0, row_or_col); + const Cell& type_cell = df.at(1, row_or_col); + const Cell& index_cell = + df.at(3, row_or_col); // Note: row 3 for horizontal + const Cell& tap_cell = df.at(4, row_or_col); // Note: row 4 for horizontal + + if (!side_cell.is_empty()) { + info.side = string_to_side(side_cell.as_string()); + } + if (!type_cell.is_empty()) { + info.seg_type = type_cell.as_string(); + } + if (!index_cell.is_empty()) { + info.seg_index = static_cast(index_cell.as_int()); + } + if (!tap_cell.is_empty() && tap_cell.is_number()) { + info.tap = static_cast(tap_cell.as_int()); + } else { + info.tap = 1; + } } - } - return info; + return info; } NodeId CRRConnectionBuilder::process_opin_ipin_node( - const SegmentInfo& info, Coordinate x, Coordinate y, + const SegmentInfo& info, + Coordinate x, + Coordinate y, const std::unordered_map& node_lookup) { - assert(info.side == Side::OPIN || info.side == Side::IPIN); - NodeType node_type = - (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; - NodeHash hash = - std::make_tuple(node_type, std::to_string(info.seg_index), x, x, y, y); - - auto it = node_lookup.find(hash); - if (it != node_lookup.end()) { - return it->second->get_id(); - } - - return 0; + assert(info.side == Side::OPIN || info.side == Side::IPIN); + NodeType node_type = + (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; + NodeHash hash = + std::make_tuple(node_type, std::to_string(info.seg_index), x, x, y, y); + + auto it = node_lookup.find(hash); + if (it != node_lookup.end()) { + return it->second->get_id(); + } + + return 0; } NodeId CRRConnectionBuilder::process_channel_node( - const SegmentInfo& info, Coordinate x, Coordinate y, + const SegmentInfo& info, + Coordinate x, + Coordinate y, const std::unordered_map& node_lookup, - int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, - int& prev_ptc_number, bool is_vertical) { - // Check grid boundaries - if ((info.side == Side::RIGHT && x == fpga_grid_x_) || - (info.side == Side::TOP && y == fpga_grid_y_)) { - return 0; - } - - int seg_length = std::stoi( - info.seg_type.substr(1)); // Extract number from "L1", "L4", etc. - - // Update PTC number based on previous segment - if (prev_seg_type != info.seg_type) { - prev_ptc_number = prev_seg_index; - } - if (prev_side != info.side) { - prev_ptc_number = 0; - prev_seg_index = 0; - } - std::string seg_type_label = get_segment_type_label(info.side); - Direction direction = get_direction_for_side(info.side, is_vertical); - - // Calculate segment coordinates - Coordinate x_low, x_high, y_low, y_high; - int physical_length, truncated; - calculate_segment_coordinates(info, x, y, x_low, x_high, y_low, y_high, - physical_length, truncated, is_vertical); - - // Calculate starting PTC point - int seg_index = (info.seg_index - 1) * seg_length * 2; - seg_index += prev_ptc_number; - prev_seg_index = - std::max({prev_seg_index, seg_index + 2*seg_length}); - - seg_index += (direction == Direction::INC_DIR) ? 0 : 1; - seg_index += (direction == Direction::DEC_DIR) ? 2 * (seg_length - 1) : 0; - - // Calculate PTC sequence - std::string seg_sequence = get_ptc_sequence( - seg_index, seg_length, physical_length, direction, truncated); - - // Create node hash and lookup - NodeHash hash = std::make_tuple(string_to_node_type(seg_type_label), - seg_sequence, x_low, x_high, y_low, y_high); - auto it = node_lookup.find(hash); - - if (it != node_lookup.end()) { - return it->second->get_id(); - } else { - VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)\n", seg_type_label.c_str(), - seg_sequence.c_str(), x_low, y_low, x_high, y_high); - return 0; - } + int& prev_seg_index, + Side& prev_side, + std::string& prev_seg_type, + int& prev_ptc_number, + bool is_vertical) { + // Check grid boundaries + if ((info.side == Side::RIGHT && x == fpga_grid_x_) || (info.side == Side::TOP && y == fpga_grid_y_)) { + return 0; + } + + int seg_length = std::stoi( + info.seg_type.substr(1)); // Extract number from "L1", "L4", etc. + + // Update PTC number based on previous segment + if (prev_seg_type != info.seg_type) { + prev_ptc_number = prev_seg_index; + } + if (prev_side != info.side) { + prev_ptc_number = 0; + prev_seg_index = 0; + } + std::string seg_type_label = get_segment_type_label(info.side); + Direction direction = get_direction_for_side(info.side, is_vertical); + + // Calculate segment coordinates + Coordinate x_low, x_high, y_low, y_high; + int physical_length, truncated; + calculate_segment_coordinates(info, x, y, x_low, x_high, y_low, y_high, + physical_length, truncated, is_vertical); + + // Calculate starting PTC point + int seg_index = (info.seg_index - 1) * seg_length * 2; + seg_index += prev_ptc_number; + prev_seg_index = + std::max({prev_seg_index, seg_index + 2 * seg_length}); + + seg_index += (direction == Direction::INC_DIR) ? 0 : 1; + seg_index += (direction == Direction::DEC_DIR) ? 2 * (seg_length - 1) : 0; + + // Calculate PTC sequence + std::string seg_sequence = get_ptc_sequence( + seg_index, seg_length, physical_length, direction, truncated); + + // Create node hash and lookup + NodeHash hash = std::make_tuple(string_to_node_type(seg_type_label), + seg_sequence, x_low, x_high, y_low, y_high); + auto it = node_lookup.find(hash); + + if (it != node_lookup.end()) { + return it->second->get_id(); + } else { + VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)\n", seg_type_label.c_str(), + seg_sequence.c_str(), x_low, y_low, x_high, y_high); + return 0; + } } void CRRConnectionBuilder::calculate_segment_coordinates( - const SegmentInfo& info, Coordinate x, Coordinate y, Coordinate& x_low, - Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, - int& physical_length, int& truncated, bool is_vertical) { - int seg_length = std::stoi(info.seg_type.substr(1)); - int tap = info.tap; - - // Calculate initial coordinates based on side - if (is_vertical) { - switch (info.side) { - case Side::LEFT: - x_high = x + (seg_length - tap); - x_low = x - (tap - 1); - y_high = y; - y_low = y; - break; - case Side::RIGHT: - x_high = x + tap; - x_low = x + tap + 1 - seg_length; - y_high = y; - y_low = y; - break; - case Side::TOP: - x_high = x; - x_low = x; - y_high = y + tap; - y_low = y + 1 - seg_length + tap; - break; - case Side::BOTTOM: - x_high = x; - x_low = x; - y_high = y + seg_length - tap; - y_low = y - tap + 1; - break; - default: - x_high = x_low = x; - y_high = y_low = y; - break; - } - } else { - switch (info.side) { - case Side::LEFT: - x_high = x + tap - 1; - x_low = x - seg_length + tap; - y_high = y; - y_low = y; - break; - case Side::RIGHT: - x_high = x + seg_length; - x_low = x + 1; - y_high = y; - y_low = y; - break; - case Side::TOP: - x_high = x; - x_low = x; - y_high = y + seg_length; - y_low = y + 1; - break; - case Side::BOTTOM: - x_high = x; - x_low = x; - y_high = y; - y_low = y - seg_length + tap; - break; - default: - x_high = x_low = x; - y_high = y_low = y; - break; + const SegmentInfo& info, + Coordinate x, + Coordinate y, + Coordinate& x_low, + Coordinate& x_high, + Coordinate& y_low, + Coordinate& y_high, + int& physical_length, + int& truncated, + bool is_vertical) { + int seg_length = std::stoi(info.seg_type.substr(1)); + int tap = info.tap; + + // Calculate initial coordinates based on side + if (is_vertical) { + switch (info.side) { + case Side::LEFT: + x_high = x + (seg_length - tap); + x_low = x - (tap - 1); + y_high = y; + y_low = y; + break; + case Side::RIGHT: + x_high = x + tap; + x_low = x + tap + 1 - seg_length; + y_high = y; + y_low = y; + break; + case Side::TOP: + x_high = x; + x_low = x; + y_high = y + tap; + y_low = y + 1 - seg_length + tap; + break; + case Side::BOTTOM: + x_high = x; + x_low = x; + y_high = y + seg_length - tap; + y_low = y - tap + 1; + break; + default: + x_high = x_low = x; + y_high = y_low = y; + break; + } + } else { + switch (info.side) { + case Side::LEFT: + x_high = x + tap - 1; + x_low = x - seg_length + tap; + y_high = y; + y_low = y; + break; + case Side::RIGHT: + x_high = x + seg_length; + x_low = x + 1; + y_high = y; + y_low = y; + break; + case Side::TOP: + x_high = x; + x_low = x; + y_high = y + seg_length; + y_low = y + 1; + break; + case Side::BOTTOM: + x_high = x; + x_low = x; + y_high = y; + y_low = y - seg_length + tap; + break; + default: + x_high = x_low = x; + y_high = y_low = y; + break; + } } - } - - // Calculate truncation - truncated = (std::max(x_low, static_cast(1)) - x_low) - - (x_high - std::min(x_high, fpga_grid_x_)); - truncated += (std::max(y_low, static_cast(1)) - y_low) - - (y_high - std::min(y_high, fpga_grid_y_)); - - // Apply grid boundaries - x_low = std::max(x_low, static_cast(1)); - y_low = std::max(y_low, static_cast(1)); - x_high = std::min(x_high, fpga_grid_x_); - y_high = std::min(y_high, fpga_grid_y_); - - // Calculate physical length - physical_length = (x_high - x_low) + (y_high - y_low) + 1; + + // Calculate truncation + truncated = (std::max(x_low, static_cast(1)) - x_low) - (x_high - std::min(x_high, fpga_grid_x_)); + truncated += (std::max(y_low, static_cast(1)) - y_low) - (y_high - std::min(y_high, fpga_grid_y_)); + + // Apply grid boundaries + x_low = std::max(x_low, static_cast(1)); + y_low = std::max(y_low, static_cast(1)); + x_high = std::min(x_high, fpga_grid_x_); + y_high = std::min(y_high, fpga_grid_y_); + + // Calculate physical length + physical_length = (x_high - x_low) + (y_high - y_low) + 1; } Direction CRRConnectionBuilder::get_direction_for_side(Side side, - bool is_vertical) { - if (is_vertical) { - return (side == Side::RIGHT || side == Side::TOP) ? Direction::DEC_DIR - : Direction::INC_DIR; - } else { - return (side == Side::RIGHT || side == Side::TOP) ? Direction::INC_DIR - : Direction::DEC_DIR; - } + bool is_vertical) { + if (is_vertical) { + return (side == Side::RIGHT || side == Side::TOP) ? Direction::DEC_DIR + : Direction::INC_DIR; + } else { + return (side == Side::RIGHT || side == Side::TOP) ? Direction::INC_DIR + : Direction::DEC_DIR; + } } std::string CRRConnectionBuilder::get_segment_type_label(Side side) { - return (side == Side::LEFT || side == Side::RIGHT) ? "CHANX" : "CHANY"; + return (side == Side::LEFT || side == Side::RIGHT) ? "CHANX" : "CHANY"; } std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, - int /*seg_length*/, - int physical_length, - Direction direction, - int truncated) { - std::vector sequence; - - if (direction == Direction::DEC_DIR) { - seg_index -= (2 * truncated > 0) ? 2 * truncated : 0; - for (int i = 0; i < physical_length; ++i) { - sequence.push_back(std::to_string(seg_index - (i * 2))); + int /*seg_length*/, + int physical_length, + Direction direction, + int truncated) { + std::vector sequence; + + if (direction == Direction::DEC_DIR) { + seg_index -= (2 * truncated > 0) ? 2 * truncated : 0; + for (int i = 0; i < physical_length; ++i) { + sequence.push_back(std::to_string(seg_index - (i * 2))); + } + } else { + seg_index += (2 * truncated > 0) ? 2 * truncated : 0; + for (int i = 0; i < physical_length; ++i) { + sequence.push_back(std::to_string(seg_index + (i * 2))); + } } - } else { - seg_index += (2 * truncated > 0) ? 2 * truncated : 0; - for (int i = 0; i < physical_length; ++i) { - sequence.push_back(std::to_string(seg_index + (i * 2))); + + std::string result; + for (size_t i = 0; i < sequence.size(); ++i) { + if (i > 0) result += ","; + result += sequence[i]; } - } - - std::string result; - for (size_t i = 0; i < sequence.size(); ++i) { - if (i > 0) result += ","; - result += sequence[i]; - } - return result; + return result; } SwitchId CRRConnectionBuilder::get_edge_switch_id( - const std::string& cell_value, const std::string& sink_node_type, - NodeId /*source_node*/, NodeId /*sink_node*/, + const std::string& cell_value, + const std::string& sink_node_type, + NodeId /*source_node*/, + NodeId /*sink_node*/, int segment_length) { - std::string lower_case_sink_node_type = sink_node_type; - std::transform(lower_case_sink_node_type.begin(), - lower_case_sink_node_type.end(), - lower_case_sink_node_type.begin(), ::tolower); - - if (is_integer(cell_value) && is_annotated_excel_) { - // TODO: This is a temporary solution. We need to have an API call to get - // the switch id from delay. - if (cell_value == "0") { - return sw_zero_id_; - } - int switch_delay_ps = std::stoi(cell_value); - int switch_id = switch_delay_ps; - return static_cast(switch_id); - } else { - std::string switch_id_key = ""; - if (segment_length > 0) { - switch_id_key = "l" + std::to_string(segment_length); + std::string lower_case_sink_node_type = sink_node_type; + std::transform(lower_case_sink_node_type.begin(), + lower_case_sink_node_type.end(), + lower_case_sink_node_type.begin(), ::tolower); + + if (is_integer(cell_value) && is_annotated_excel_) { + // TODO: This is a temporary solution. We need to have an API call to get + // the switch id from delay. + if (cell_value == "0") { + return sw_zero_id_; + } + int switch_delay_ps = std::stoi(cell_value); + int switch_id = switch_delay_ps; + return static_cast(switch_id); } else { - switch_id_key = lower_case_sink_node_type; - } + std::string switch_id_key = ""; + if (segment_length > 0) { + switch_id_key = "l" + std::to_string(segment_length); + } else { + switch_id_key = lower_case_sink_node_type; + } - std::string capitalized_switch_id_key = switch_id_key; - std::transform(capitalized_switch_id_key.begin(), - capitalized_switch_id_key.end(), - capitalized_switch_id_key.begin(), ::toupper); - - if (default_switch_id_.find(switch_id_key) != - default_switch_id_.end()) { - return default_switch_id_[switch_id_key]; - } else if (default_switch_id_.find(capitalized_switch_id_key) != - default_switch_id_.end()) { - return default_switch_id_[capitalized_switch_id_key]; - } else { - throw std::runtime_error("Default switch id not found for Node Type: " + - lower_case_sink_node_type + " and Switch ID Key: " + - capitalized_switch_id_key); + std::string capitalized_switch_id_key = switch_id_key; + std::transform(capitalized_switch_id_key.begin(), + capitalized_switch_id_key.end(), + capitalized_switch_id_key.begin(), ::toupper); + + if (default_switch_id_.find(switch_id_key) != default_switch_id_.end()) { + return default_switch_id_[switch_id_key]; + } else if (default_switch_id_.find(capitalized_switch_id_key) != default_switch_id_.end()) { + return default_switch_id_[capitalized_switch_id_key]; + } else { + throw std::runtime_error("Default switch id not found for Node Type: " + lower_case_sink_node_type + " and Switch ID Key: " + capitalized_switch_id_key); + } } - } } bool CRRConnectionBuilder::is_valid_grid_location(Coordinate x, - Coordinate y) const { - return x >= 1 && x <= fpga_grid_x_ && y >= 1 && y <= fpga_grid_y_; + Coordinate y) const { + return x >= 1 && x <= fpga_grid_x_ && y >= 1 && y <= fpga_grid_y_; } void CRRConnectionBuilder::update_progress() { - size_t current = processed_locations_.fetch_add(1) + 1; - if (current % std::max(size_t(1), total_locations_ / 20) == 0 || - current == total_locations_) { - double percentage = - (static_cast(current) / total_locations_) * 100.0; - VTR_LOG("Connection building progress: %zu/%zu (%.1f%%)\n", current, - total_locations_, percentage); - } + size_t current = processed_locations_.fetch_add(1) + 1; + if (current % std::max(size_t(1), total_locations_ / 20) == 0 || current == total_locations_) { + double percentage = + (static_cast(current) / total_locations_) * 100.0; + VTR_LOG("Connection building progress: %zu/%zu (%.1f%%)\n", current, + total_locations_, percentage); + } } -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index e2afafeb36..d9100ff931 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -17,164 +17,163 @@ namespace crrgenerator { * processing. */ class CRRConnectionBuilder { - public: - CRRConnectionBuilder(const RRGraph& rr_graph, - const NodeLookupManager& node_lookup, - const SwitchBlockManager& sb_manager); - - /** - * @brief Initialize the connection builder - * @param node_lookup Node lookup manager - * @param sb_manager Switch block manager - * @param original_switches Original switches from the input graph - */ - void initialize(Coordinate fpga_grid_x, - Coordinate fpga_grid_y, - bool is_annotated_excel); - - /** - * @brief Get connections for a tile - * @param tile_x Tile x coordinate - * @param tile_y Tile y coordinate - * @return Vector of connections - */ - std::vector get_tile_connections(Coordinate tile_x, Coordinate tile_y); - - /** - * @brief Get all generated connections - * @return Vector of all connections - */ - const std::vector>>& get_all_connections() const { - return all_connections_; - } - - /** - * @brief Get connection count - * @return Number of connections generated - */ - size_t get_connection_count() const { - size_t count = 0; - for (const auto& x : all_connections_) { - for (const auto& y : x) { - count += y.size(); - } + public: + CRRConnectionBuilder(const RRGraph& rr_graph, + const NodeLookupManager& node_lookup, + const SwitchBlockManager& sb_manager); + + /** + * @brief Initialize the connection builder + * @param node_lookup Node lookup manager + * @param sb_manager Switch block manager + * @param original_switches Original switches from the input graph + */ + void initialize(Coordinate fpga_grid_x, + Coordinate fpga_grid_y, + bool is_annotated_excel); + + /** + * @brief Get connections for a tile + * @param tile_x Tile x coordinate + * @param tile_y Tile y coordinate + * @return Vector of connections + */ + std::vector get_tile_connections(Coordinate tile_x, Coordinate tile_y) const; + + /** + * @brief Get all generated connections + * @return Vector of all connections + */ + const std::vector>>& get_all_connections() const { + return all_connections_; } - return count; - } - - /** - * @brief Get the default switch id map - * @return Map of default switch id - */ - std::map get_default_swithes_map() const { - return default_switch_id_; - } - - /** - * @brief Clear all connections - */ - void clear() { all_connections_.clear(); } - void remove_tile_connections(Coordinate x, Coordinate y) { - all_connections_[static_cast(x)][static_cast(y)].clear(); - all_connections_[static_cast(x)][static_cast(y)].shrink_to_fit(); - } - - private: - - // Info from config - Coordinate fpga_grid_x_; - Coordinate fpga_grid_y_; - bool is_annotated_excel_; - - // Dependencies - const RRGraph& rr_graph_; - const NodeLookupManager& node_lookup_; - const SwitchBlockManager& sb_manager_; - SwitchId sw_zero_id_; - - std::vector storage_sw_names_; - std::vector> storage_source_nodes_; - std::vector> storage_sink_nodes_; - - // Generated connections - std::vector>> all_connections_; - std::mutex connections_mutex_; - - // Processing state - std::atomic processed_locations_{0}; - size_t total_locations_{0}; - - // Default switch id based on the node type - std::map default_switch_id_; - - // Connection building methods - void build_connections_for_location(Coordinate x, - Coordinate y, - std::vector& tile_connections); - - // Node processing methods - std::map get_vertical_nodes( - Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& - node_lookup); - - std::map get_horizontal_nodes( - Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& - node_lookup); - - // PTC sequence calculation - std::string get_ptc_sequence(int seg_index, int seg_length, - int physical_length, Direction direction, - int truncated); - - // Segment processing helpers - struct SegmentInfo { - Side side; - std::string seg_type; - int seg_index; - int tap; - - SegmentInfo() : side(Side::INVALID), seg_index(-1), tap(-1) {} - SegmentInfo(Side s, const std::string& type, int index, int t = 1) - : side(s), seg_type(type), seg_index(index), tap(t) {} - }; - - SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, - bool is_vertical); - NodeId process_opin_ipin_node( - const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& - node_lookup); - NodeId process_channel_node(const SegmentInfo& info, Coordinate x, - Coordinate y, - const std::unordered_map& node_lookup, - int& prev_seg_index, Side& prev_side, - std::string& prev_seg_type, int& prev_ptc_number, - bool is_vertical); - - // Coordinate and direction calculations - void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, - Coordinate y, Coordinate& x_low, - Coordinate& x_high, Coordinate& y_low, - Coordinate& y_high, int& physical_length, - int& truncated, bool is_vertical); - - Direction get_direction_for_side(Side side, bool is_vertical); - std::string get_segment_type_label(Side side); - - // Return the switch id of an edge between two nodes - SwitchId get_edge_switch_id(const std::string& cell_value, - const std::string& sink_node_type, - NodeId source_node, NodeId sink_node, - int segment_length=-1); - - // Validation and bounds checking - bool is_valid_grid_location(Coordinate x, Coordinate y) const; - - // Progress tracking - void update_progress(); + + /** + * @brief Get connection count + * @return Number of connections generated + */ + size_t get_connection_count() const { + size_t count = 0; + for (const auto& x : all_connections_) { + for (const auto& y : x) { + count += y.size(); + } + } + return count; + } + + /** + * @brief Get the default switch id map + * @return Map of default switch id + */ + std::map get_default_swithes_map() const { + return default_switch_id_; + } + + /** + * @brief Clear all connections + */ + void clear() { all_connections_.clear(); } + void remove_tile_connections(Coordinate x, Coordinate y) { + all_connections_[static_cast(x)][static_cast(y)].clear(); + all_connections_[static_cast(x)][static_cast(y)].shrink_to_fit(); + } + + private: + // Info from config + Coordinate fpga_grid_x_; + Coordinate fpga_grid_y_; + bool is_annotated_excel_; + + // Dependencies + const RRGraph& rr_graph_; + const NodeLookupManager& node_lookup_; + const SwitchBlockManager& sb_manager_; + SwitchId sw_zero_id_; + + std::vector storage_sw_names_; + std::vector> storage_source_nodes_; + std::vector> storage_sink_nodes_; + + // Generated connections + std::vector>> all_connections_; + std::mutex connections_mutex_; + + // Processing state + std::atomic processed_locations_{0}; + size_t total_locations_{0}; + + // Default switch id based on the node type + std::map default_switch_id_; + + // Connection building methods + void build_connections_for_location(Coordinate x, + Coordinate y, + std::vector& tile_connections) const; + + // Node processing methods + std::map get_vertical_nodes( + Coordinate x, + Coordinate y, + const DataFrame& df, + const std::unordered_map& + node_lookup); + + std::map get_horizontal_nodes( + Coordinate x, + Coordinate y, + const DataFrame& df, + const std::unordered_map& + node_lookup); + + // PTC sequence calculation + std::string get_ptc_sequence(int seg_index, int seg_length, int physical_length, Direction direction, int truncated); + + // Segment processing helpers + struct SegmentInfo { + Side side; + std::string seg_type; + int seg_index; + int tap; + + SegmentInfo() + : side(Side::INVALID) + , seg_index(-1) + , tap(-1) {} + SegmentInfo(Side s, const std::string& type, int index, int t = 1) + : side(s) + , seg_type(type) + , seg_index(index) + , tap(t) {} + }; + + SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical); + NodeId process_opin_ipin_node( + const SegmentInfo& info, + Coordinate x, + Coordinate y, + const std::unordered_map& + node_lookup); + NodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical); + + // Coordinate and direction calculations + void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, Coordinate y, Coordinate& x_low, Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, int& physical_length, int& truncated, bool is_vertical); + + Direction get_direction_for_side(Side side, bool is_vertical); + std::string get_segment_type_label(Side side); + + // Return the switch id of an edge between two nodes + SwitchId get_edge_switch_id(const std::string& cell_value, + const std::string& sink_node_type, + NodeId source_node, + NodeId sink_node, + int segment_length = -1); + + // Validation and bounds checking + bool is_valid_grid_location(Coordinate x, Coordinate y) const; + + // Progress tracking + void update_progress(); }; -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp new file mode 100644 index 0000000000..138ecac3c9 --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp @@ -0,0 +1,15 @@ +#include "crr_edge_builder.h" + +#include "crr_connection_builder.h" + +void build_gsb_track_to_track_map(RRGraphBuilder& rr_graph_builder, + const RRGSB& rr_gsb, + const crrgenerator::CRRConnectionBuilder& connection_builder) { + size_t gsb_x = rr_gsb.get_sb_x(); + size_t gsb_y = rr_gsb.get_sb_y(); + + std::vector gsb_connections = connection_builder.get_tile_connections(gsb_x, gsb_y); + for (const auto& connection : gsb_connections) { + rr_graph_builder.create_edclge_in_cache(connection.src_node(), connection.sink_node(), connection.switch_id(), false); + } +} diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h new file mode 100644 index 0000000000..890f55a39c --- /dev/null +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +#include "vtr_vector.h" +#include "vtr_geometry.h" + +#include "physical_types.h" +#include "device_grid.h" + +#include "rr_gsb.h" +#include "rr_graph_obj.h" +#include "rr_graph.h" +#include "rr_graph_view.h" +#include "rr_graph_builder.h" + +#include "crr_connection_builder.h" + +void build_gsb_track_to_track_edges(RRGraphBuilder& rr_graph_builder, + const RRGSB& rr_gsb, + const crrgenerator::CRRConnectionBuilder& connection_builder); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index d32364361c..3834572272 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -13,11 +13,11 @@ CRRGraphGenerator::CRRGraphGenerator(const t_crr_opts& crr_opts, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager, const std::string& output_graph_xml) - : crr_opts_(crr_opts), - input_graph_(input_graph), - node_lookup_(node_lookup), - sb_manager_(sb_manager), - output_graph_xml_(output_graph_xml) {} + : crr_opts_(crr_opts) + , input_graph_(input_graph) + , node_lookup_(node_lookup) + , sb_manager_(sb_manager) + , output_graph_xml_(output_graph_xml) {} void CRRGraphGenerator::run() { auto start_time = std::chrono::steady_clock::now(); @@ -32,13 +32,13 @@ void CRRGraphGenerator::run() { build_connections(); // Create output graph - create_output_graph(); + // create_output_graph(); // Write output files - write_output_files(); + // write_output_files(); // Print summary - print_processing_summary(); + // print_processing_summary(); auto end_time = std::chrono::steady_clock::now(); auto duration = @@ -63,185 +63,182 @@ void CRRGraphGenerator::initialize_components() { VTR_ASSERT(crr_opts_.crr_num_threads > 0); thread_pool_ = std::make_unique(crr_opts_.crr_num_threads); VTR_LOG("CRR Graph Generator: Parallel processing enabled with %lu threads\n", - thread_pool_->get_thread_count()); + thread_pool_->get_thread_count()); VTR_LOG("CRR Graph Generator: All components initialized successfully\n"); } void CRRGraphGenerator::build_connections() { - VTR_LOG("CRR Graph Generator: Building connections\n"); + VTR_LOG("CRR Graph Generator: Building connections\n"); - // Initialize connection builder - const DeviceGrid& grid = g_vpr_ctx.device().grid; - connection_builder_->initialize(grid.width()-2, - grid.height()-2, - crr_opts_.annotated_rr_graph); + // Initialize connection builder + const DeviceGrid& grid = g_vpr_ctx.device().grid; + connection_builder_->initialize(grid.width() - 2, + grid.height() - 2, + crr_opts_.annotated_rr_graph); - VTR_LOG("CRR Graph Generator: Connection building completed\n"); + VTR_LOG("CRR Graph Generator: Connection building completed\n"); } void CRRGraphGenerator::create_output_graph() { - VTR_LOG("CRR Graph Generator: Creating output graph\n"); - - // Create new graph based on input graph - output_graph_ = std::make_unique(input_graph_); - - // Add new switches to output graph - if (crr_opts_.annotated_rr_graph) { - size_t nxt_switch_id = - connection_builder_->get_default_swithes_map().size(); - int max_sw_delay_ps = sb_manager_.get_max_switch_delay_ps(); - std::string default_sw_type = ""; - Timing default_timing; - Sizing default_sizing; - - // Get default timing and sizing from input graph - for (const auto& graph_sw : input_graph_.get_switches()) { - std::string sw_name = graph_sw.get_name(); - std::transform(sw_name.begin(), sw_name.end(), sw_name.begin(), - ::tolower); - if (sw_name.find("l1") != std::string::npos || - sw_name.find("l4") != std::string::npos) { - default_sw_type = graph_sw.get_type(); - default_timing = graph_sw.get_timing(); - default_sizing = graph_sw.get_sizing(); - } - } + VTR_LOG("CRR Graph Generator: Creating output graph\n"); - // Add sw_zero switch - we don't use delayless switch because OpenFPGA doesn't work with it. - Switch sw_zero(static_cast(nxt_switch_id), "sw_zero", default_sw_type, Timing(0, 0), default_sizing); - output_graph_->add_switch(sw_zero); + // Create new graph based on input graph + output_graph_ = std::make_unique(input_graph_); // Add new switches to output graph - for (int curr_sw_delay_ps = static_cast(nxt_switch_id) + 1; - curr_sw_delay_ps <= max_sw_delay_ps; curr_sw_delay_ps++) { - float curr_sw_delay_s = static_cast(curr_sw_delay_ps) * 1e-12f; - Switch curr_switch( - static_cast(curr_sw_delay_ps), - "sw_" + std::to_string(curr_sw_delay_ps), default_sw_type, - Timing(default_timing.Cin, curr_sw_delay_s), default_sizing); - VTR_LOG_DEBUG("Adding switch: %s with delay: %e s\n", curr_switch.get_name().c_str(), curr_sw_delay_s); - output_graph_->add_switch(curr_switch); + if (crr_opts_.annotated_rr_graph) { + size_t nxt_switch_id = + connection_builder_->get_default_swithes_map().size(); + int max_sw_delay_ps = sb_manager_.get_max_switch_delay_ps(); + std::string default_sw_type = ""; + Timing default_timing; + Sizing default_sizing; + + // Get default timing and sizing from input graph + for (const auto& graph_sw : input_graph_.get_switches()) { + std::string sw_name = graph_sw.get_name(); + std::transform(sw_name.begin(), sw_name.end(), sw_name.begin(), + ::tolower); + if (sw_name.find("l1") != std::string::npos || sw_name.find("l4") != std::string::npos) { + default_sw_type = graph_sw.get_type(); + default_timing = graph_sw.get_timing(); + default_sizing = graph_sw.get_sizing(); + } + } + + // Add sw_zero switch - we don't use delayless switch because OpenFPGA doesn't work with it. + Switch sw_zero(static_cast(nxt_switch_id), "sw_zero", default_sw_type, Timing(0, 0), default_sizing); + output_graph_->add_switch(sw_zero); + + // Add new switches to output graph + for (int curr_sw_delay_ps = static_cast(nxt_switch_id) + 1; + curr_sw_delay_ps <= max_sw_delay_ps; curr_sw_delay_ps++) { + float curr_sw_delay_s = static_cast(curr_sw_delay_ps) * 1e-12f; + Switch curr_switch( + static_cast(curr_sw_delay_ps), + "sw_" + std::to_string(curr_sw_delay_ps), default_sw_type, + Timing(default_timing.Cin, curr_sw_delay_s), default_sizing); + VTR_LOG_DEBUG("Adding switch: %s with delay: %e s\n", curr_switch.get_name().c_str(), curr_sw_delay_s); + output_graph_->add_switch(curr_switch); + } } - } - // Get all connections from connection builder - auto all_connections = connection_builder_->get_all_connections(); + // Get all connections from connection builder + auto all_connections = connection_builder_->get_all_connections(); - auto preserved_edges = input_graph_.get_preserved_edges( - crr_opts_.preserve_pin_connections); - VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu\n", preserved_edges.size()); + auto preserved_edges = input_graph_.get_preserved_edges( + crr_opts_.preserve_pin_connections); + VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu\n", preserved_edges.size()); - // Clear existing edges and add new ones - output_graph_->get_edges().clear(); + // Clear existing edges and add new ones + output_graph_->get_edges().clear(); - // Add preserved edges - for (const auto& edge : preserved_edges) { - output_graph_->add_edge(edge); - } + // Add preserved edges + for (const auto& edge : preserved_edges) { + output_graph_->add_edge(edge); + } - add_custom_edges(); + add_custom_edges(); - output_graph_->sort_nodes(); - output_graph_->sort_edges(); - output_graph_->shrink_to_fit(); + output_graph_->sort_nodes(); + output_graph_->sort_edges(); + output_graph_->shrink_to_fit(); - VTR_LOG("CRR Graph Generator: Output graph created with %zu edges\n", - output_graph_->get_edge_count()); + VTR_LOG("CRR Graph Generator: Output graph created with %zu edges\n", + output_graph_->get_edge_count()); } void CRRGraphGenerator::add_custom_edges() { - VTR_LOG("CRR Graph Generator: Adding custom edges\n"); - - // Add new connections - const DeviceGrid& grid = g_vpr_ctx.device().grid; - size_t total_tiles = - static_cast((grid.width() + 1 - 2) * (grid.height() + 1 - 2)); - ProgressTracker tracker(total_tiles, "Adding new connections"); - std::vector> futures; - std::mutex graph_mutex; - - for (Coordinate tile_x = 0; tile_x <= grid.width() - 2; tile_x++) { - for (Coordinate tile_y = 0; tile_y <= grid.height() - 2; tile_y++) { - auto fut = thread_pool_->submit([this, tile_x, tile_y, &graph_mutex, &tracker]() { - std::vector tile_connections = - connection_builder_->get_tile_connections(tile_x, tile_y); - - { - std::lock_guard lock(graph_mutex); - for (const auto& connection : tile_connections) { - output_graph_->add_edge(connection.src_node(), - connection.sink_node(), - connection.switch_id()); - } + VTR_LOG("CRR Graph Generator: Adding custom edges\n"); + + // Add new connections + const DeviceGrid& grid = g_vpr_ctx.device().grid; + size_t total_tiles = + static_cast((grid.width() + 1 - 2) * (grid.height() + 1 - 2)); + ProgressTracker tracker(total_tiles, "Adding new connections"); + std::vector> futures; + std::mutex graph_mutex; + + for (Coordinate tile_x = 0; tile_x <= grid.width() - 2; tile_x++) { + for (Coordinate tile_y = 0; tile_y <= grid.height() - 2; tile_y++) { + auto fut = thread_pool_->submit([this, tile_x, tile_y, &graph_mutex, &tracker]() { + std::vector tile_connections = + connection_builder_->get_tile_connections(tile_x, tile_y); + + { + std::lock_guard lock(graph_mutex); + for (const auto& connection : tile_connections) { + output_graph_->add_edge(connection.src_node(), + connection.sink_node(), + connection.switch_id()); + } + } + + tracker.increment(); + }); + futures.push_back(std::move(fut)); } - - tracker.increment(); - }); - futures.push_back(std::move(fut)); } - } - // Wait for all tasks to complete - for (auto& fut : futures) { - fut.get(); - } + // Wait for all tasks to complete + for (auto& fut : futures) { + fut.get(); + } } void CRRGraphGenerator::write_output_files() { - if (!output_graph_xml_.empty()) { - VTR_LOG("CRR Graph Generator: Writing output files\n"); - xml_handler_->write_rr_graph(output_graph_xml_, *output_graph_); - VTR_LOG("CRR Graph Generator: Output files written successfully\n"); - } else { - VTR_LOG("CRR Graph Generator: No output file specified\n"); - } + if (!output_graph_xml_.empty()) { + VTR_LOG("CRR Graph Generator: Writing output files\n"); + xml_handler_->write_rr_graph(output_graph_xml_, *output_graph_); + VTR_LOG("CRR Graph Generator: Output files written successfully\n"); + } else { + VTR_LOG("CRR Graph Generator: No output file specified\n"); + } } void CRRGraphGenerator::print_processing_summary() { - VTR_LOG("CRR Graph Generator: === Processing Summary ===\n"); - - VTR_LOG("CRR Graph Generator: Input graph:\n"); - VTR_LOG(" Nodes: %zu\n", input_graph_.get_node_count()); - VTR_LOG(" Edges: %zu\n", input_graph_.get_edge_count()); - VTR_LOG(" Switches: %zu\n", input_graph_.get_switch_count()); + VTR_LOG("CRR Graph Generator: === Processing Summary ===\n"); - VTR_LOG("CRR Graph Generator: Output graph:\n"); - VTR_LOG(" Nodes: %zu\n", output_graph_->get_node_count()); - VTR_LOG(" Edges: %zu\n", output_graph_->get_edge_count()); - VTR_LOG(" Switches: %zu\n", output_graph_->get_switch_count()); + VTR_LOG("CRR Graph Generator: Input graph:\n"); + VTR_LOG(" Nodes: %zu\n", input_graph_.get_node_count()); + VTR_LOG(" Edges: %zu\n", input_graph_.get_edge_count()); + VTR_LOG(" Switches: %zu\n", input_graph_.get_switch_count()); - int new_edges = - static_cast(output_graph_->get_edge_count()) - - static_cast(input_graph_.get_edge_count()); - VTR_LOG(" New edges added: %d\n", new_edges); + VTR_LOG("CRR Graph Generator: Output graph:\n"); + VTR_LOG(" Nodes: %zu\n", output_graph_->get_node_count()); + VTR_LOG(" Edges: %zu\n", output_graph_->get_edge_count()); + VTR_LOG(" Switches: %zu\n", output_graph_->get_switch_count()); - VTR_LOG("Switch blocks processed: %zu\n", sb_manager_.get_all_patterns().size()); - VTR_LOG("Total connections: %zu\n", sb_manager_.get_total_connections()); + int new_edges = + static_cast(output_graph_->get_edge_count()) - static_cast(input_graph_.get_edge_count()); + VTR_LOG(" New edges added: %d\n", new_edges); - VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width() - 2, g_vpr_ctx.device().grid.height() - 2); + VTR_LOG("Switch blocks processed: %zu\n", sb_manager_.get_all_patterns().size()); + VTR_LOG("Total connections: %zu\n", sb_manager_.get_total_connections()); + VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width() - 2, g_vpr_ctx.device().grid.height() - 2); } void CRRGraphGenerator::validate_processing_results() { - // Basic validation - if (!output_graph_) { - VTR_LOG_ERROR("Output graph was not created\n"); - } + // Basic validation + if (!output_graph_) { + VTR_LOG_ERROR("Output graph was not created\n"); + } - if (output_graph_->get_node_count() == 0) { - VTR_LOG_ERROR("Output graph has no nodes\n"); - } + if (output_graph_->get_node_count() == 0) { + VTR_LOG_ERROR("Output graph has no nodes\n"); + } - if (output_graph_->get_edge_count() == 0) { - VTR_LOG_ERROR("Output graph has no edges\n"); - } + if (output_graph_->get_edge_count() == 0) { + VTR_LOG_ERROR("Output graph has no edges\n"); + } - if (output_graph_->get_switch_count() == 0) { - VTR_LOG_ERROR("Output graph has no switches\n"); - } + if (output_graph_->get_switch_count() == 0) { + VTR_LOG_ERROR("Output graph has no switches\n"); + } - VTR_LOG("Processing results validation passed\n"); + VTR_LOG("Processing results validation passed\n"); } -} // namespace crrgenerator \ No newline at end of file +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h index 0266273396..6e6d9aa73d 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h @@ -21,7 +21,7 @@ namespace crrgenerator { * process switch block configurations, and generate output graphs. */ class CRRGraphGenerator { -public: + public: CRRGraphGenerator(const t_crr_opts& crr_opts, const RRGraph& input_graph, const NodeLookupManager& node_lookup, @@ -38,7 +38,7 @@ class CRRGraphGenerator { return connection_builder_.get(); } -private: + private: const t_crr_opts& crr_opts_; const RRGraph& input_graph_; const NodeLookupManager& node_lookup_; @@ -63,4 +63,4 @@ class CRRGraphGenerator { void validate_processing_results(); }; -} // namespace crrgenerator \ No newline at end of file +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h index 722264f899..4b6ed209ff 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_pattern_matcher.h @@ -7,7 +7,7 @@ namespace crrgenerator { class PatternMatcher { -private: + private: // Helper function to parse range [start:end:step] or comma-separated values [7,20] static bool matches_range(int value, const std::string& range_str) { // Extract numbers from [start:end:step] or [7,20] format @@ -16,22 +16,22 @@ class PatternMatcher { if (start_pos == std::string::npos || end_pos == std::string::npos) { return false; } - + std::string range_content = range_str.substr(start_pos + 1, end_pos - start_pos - 1); - + // Check if it's comma-separated values (e.g., [7,20]) if (range_content.find(',') != std::string::npos) { // Parse comma-separated values std::vector values; size_t pos = 0; size_t comma_pos; - + while ((comma_pos = range_content.find(',', pos)) != std::string::npos) { values.push_back(std::stoi(range_content.substr(pos, comma_pos - pos))); pos = comma_pos + 1; } values.push_back(std::stoi(range_content.substr(pos))); - + // Check if value is in the list return std::find(values.begin(), values.end(), value) != values.end(); } @@ -41,22 +41,22 @@ class PatternMatcher { std::vector parts; size_t pos = 0; size_t colon_pos; - + while ((colon_pos = range_content.find(':', pos)) != std::string::npos) { parts.push_back(std::stoi(range_content.substr(pos, colon_pos - pos))); pos = colon_pos + 1; } parts.push_back(std::stoi(range_content.substr(pos))); - + if (parts.size() != 3) return false; - + int start = parts[0]; - int end = parts[1]; // end is NOT exclusive as per your specification + int end = parts[1]; // end is NOT exclusive as per your specification int step = parts[2]; - + if (value < start || value > end) return false; if ((value - start) % step != 0) return false; - + return true; } // Single value (e.g., [5]) @@ -69,101 +69,92 @@ class PatternMatcher { // Convert pattern to regex, handling * and [start:end:step] ranges static std::string pattern_to_regex(const std::string& pattern) { std::string regex_pattern = "^"; - + for (size_t i = 0; i < pattern.length(); ++i) { char c = pattern[i]; - + if (c == '*') { - regex_pattern += "([0-9]+)"; // Capture group for numbers - } - else if (c == '[') { + regex_pattern += "([0-9]+)"; // Capture group for numbers + } else if (c == '[') { // Find the matching closing bracket size_t close_bracket = pattern.find(']', i); if (close_bracket != std::string::npos) { std::string range = pattern.substr(i, close_bracket - i + 1); - regex_pattern += "([0-9]+)"; // Capture the number, validate range later - i = close_bracket; // Skip to after the closing bracket - } - else { - regex_pattern += "\\["; // Literal bracket if no closing bracket found + regex_pattern += "([0-9]+)"; // Capture the number, validate range later + i = close_bracket; // Skip to after the closing bracket + } else { + regex_pattern += "\\["; // Literal bracket if no closing bracket found } - } - else if (c == '\\' && i + 1 < pattern.length() && pattern[i + 1] == '*') { + } else if (c == '\\' && i + 1 < pattern.length() && pattern[i + 1] == '*') { // Handle escaped asterisk - treat as literal * regex_pattern += "\\*"; - ++i; // Skip the next character - } - else { + ++i; // Skip the next character + } else { // Escape regex special characters - if (c == '.' || c == '^' || c == '$' || c == '+' || c == '?' || - c == '(' || c == ')' || c == '|' || c == '{' || c == '}') { + if (c == '.' || c == '^' || c == '$' || c == '+' || c == '?' || c == '(' || c == ')' || c == '|' || c == '{' || c == '}') { regex_pattern += "\\"; } regex_pattern += c; } } - + regex_pattern += "$"; return regex_pattern; } -public: + public: static bool matches_pattern(const std::string& name, const std::string& pattern) { // Fast path for exact matches (no wildcards or ranges) - if (pattern.find('*') == std::string::npos && - pattern.find('[') == std::string::npos && - pattern.find('\\') == std::string::npos) { + if (pattern.find('*') == std::string::npos && pattern.find('[') == std::string::npos && pattern.find('\\') == std::string::npos) { return name == pattern; } - + // Compile regex for this pattern std::string regex_str = pattern_to_regex(pattern); std::regex compiled_regex(regex_str); - + std::smatch matches; if (!std::regex_match(name, matches, compiled_regex)) { return false; } - + // Now validate any range constraints std::vector captured_numbers; for (size_t i = 1; i < matches.size(); ++i) { captured_numbers.push_back(matches[i].str()); } - + // Parse pattern again to find ranges and validate them size_t capture_index = 0; for (size_t i = 0; i < pattern.length(); ++i) { char c = pattern[i]; - + if (c == '*') { // Simple wildcard, no validation needed ++capture_index; - } - else if (c == '[') { + } else if (c == '[') { // Find the matching closing bracket size_t close_bracket = pattern.find(']', i); if (close_bracket != std::string::npos) { std::string range = pattern.substr(i, close_bracket - i + 1); - + if (capture_index < captured_numbers.size()) { int captured_value = std::stoi(captured_numbers[capture_index]); if (!matches_range(captured_value, range)) { return false; } } - + ++capture_index; - i = close_bracket; // Skip to after the closing bracket + i = close_bracket; // Skip to after the closing bracket } - } - else if (c == '\\' && i + 1 < pattern.length() && pattern[i + 1] == '*') { - ++i; // Skip escaped asterisk + } else if (c == '\\' && i + 1 < pattern.length() && pattern[i + 1] == '*') { + ++i; // Skip escaped asterisk } } - + return true; } }; -} // namespace crrgenerator \ No newline at end of file +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp index b7b089db13..b32faabab2 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.cpp @@ -15,8 +15,8 @@ namespace crrgenerator { SwitchBlockManager::SwitchBlockManager() = default; void SwitchBlockManager::initialize(const std::string& sb_maps_file, - const std::string& sb_annotated_dir, - const bool is_annotated_excel) { + const std::string& sb_annotated_dir, + const bool is_annotated_excel) { VTR_LOG("Initializing SwitchBlockManager with maps file: %s\n", sb_maps_file.c_str()); annotated_dir_ = sb_annotated_dir; @@ -40,12 +40,12 @@ void SwitchBlockManager::initialize(const std::string& sb_maps_file, std::string excel_file = item.second.as(); if (item.second.IsNull()) { - excel_file = ""; + excel_file = ""; } std::string full_path = std::filesystem::path(annotated_dir_) / excel_file; if (excel_file.empty()) { - full_path = ""; + full_path = ""; } // Handle escaped asterisks (replace \* with *) @@ -55,33 +55,33 @@ void SwitchBlockManager::initialize(const std::string& sb_maps_file, ordered_switch_block_patterns_.push_back(pattern); switch_block_to_file_[pattern] = full_path; if (!full_path.empty()) { - unique_files.insert(full_path); + unique_files.insert(full_path); } } for (const auto& full_path : unique_files) { if (std::filesystem::exists(full_path)) { - try { - VTR_LOG_DEBUG("Attempting to read Excel file: %s\n", full_path.c_str()); - DataFrame df = processor_.read_excel(full_path); - df = processor_.process_dataframe(std::move(df), NUM_EMPTY_ROWS, - NUM_EMPTY_COLS); - file_cache_[full_path] = std::move(df); - VTR_LOG_DEBUG("Processed %zu connections in %s file\n", - file_cache_[full_path].connections, - std::filesystem::path(full_path).filename().string().c_str()); - } catch (const std::exception& e) { - VTR_LOG_ERROR("Failed to read required Excel file '%s': %s\n", full_path.c_str(), e.what()); - } + try { + VTR_LOG_DEBUG("Attempting to read Excel file: %s\n", full_path.c_str()); + DataFrame df = processor_.read_excel(full_path); + df = processor_.process_dataframe(std::move(df), NUM_EMPTY_ROWS, + NUM_EMPTY_COLS); + file_cache_[full_path] = std::move(df); + VTR_LOG_DEBUG("Processed %zu connections in %s file\n", + file_cache_[full_path].connections, + std::filesystem::path(full_path).filename().string().c_str()); + } catch (const std::exception& e) { + VTR_LOG_ERROR("Failed to read required Excel file '%s': %s\n", full_path.c_str(), e.what()); + } } else { - VTR_LOG_ERROR("Required Excel file not found: %s\n", full_path.c_str()); + VTR_LOG_ERROR("Required Excel file not found: %s\n", full_path.c_str()); } } // Map patterns to loaded DataFrames for (const auto& [pattern, full_path] : switch_block_to_file_) { if (file_cache_.find(full_path) != file_cache_.end()) { - dataframes_[pattern] = &file_cache_[full_path]; + dataframes_[pattern] = &file_cache_[full_path]; } } @@ -180,4 +180,4 @@ void SwitchBlockManager::validate_yaml_structure(const YAML::Node& root) { } } -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h index d39730657b..c7de801392 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_switch_block_manager.h @@ -16,7 +16,7 @@ namespace crrgenerator { * containing switch block data, and managing switch block patterns. */ class SwitchBlockManager { -public: + public: SwitchBlockManager(); /** @@ -69,18 +69,18 @@ class SwitchBlockManager { size_t get_total_connections() const; /** - * @brief Get the maximum switch delay in picoseconds - * @return Maximum switch delay in picoseconds - */ + * @brief Get the maximum switch delay in picoseconds + * @return Maximum switch delay in picoseconds + */ int get_max_switch_delay_ps() const { return switch_delay_max_ps_; } /** - * @brief Get the minimum switch delay in picoseconds - * @return Minimum switch delay in picoseconds - */ + * @brief Get the minimum switch delay in picoseconds + * @return Minimum switch delay in picoseconds + */ int get_min_switch_delay_ps() const { return switch_delay_min_ps_; } -private: + private: /** * @brief Ordered list of switch block patterns * @@ -102,12 +102,12 @@ class SwitchBlockManager { // File processing void load_excel_file(const std::string& pattern, - const std::string& excel_file); + const std::string& excel_file); /** - * @brief Update global switch delay ranges based on all loaded DataFrames - * @param is_annotated_excel Whether the switches are annotated in Excel - */ + * @brief Update global switch delay ranges based on all loaded DataFrames + * @param is_annotated_excel Whether the switches are annotated in Excel + */ void update_and_set_global_switch_delays(const bool is_annotated_excel); // Validation @@ -115,4 +115,4 @@ class SwitchBlockManager { void validate_excel_files(); }; -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp index f0c8c268e9..b0f594e1b4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.cpp @@ -8,139 +8,138 @@ namespace crrgenerator { // CRRThreadPool implementation CRRThreadPool::CRRThreadPool(size_t num_threads) { - if (num_threads == 0) { - num_threads = std::thread::hardware_concurrency(); - } else { - num_threads = std::min( - num_threads, static_cast(std::thread::hardware_concurrency())); - } - - if (num_threads == 0) { - num_threads = 1; - } - - VTR_LOG("Creating CRRThreadPool with %zu threads\n", num_threads); - - for (size_t i = 0; i < num_threads; ++i) { - workers_.emplace_back(&CRRThreadPool::worker_thread, this); - } + if (num_threads == 0) { + num_threads = std::thread::hardware_concurrency(); + } else { + num_threads = std::min( + num_threads, static_cast(std::thread::hardware_concurrency())); + } + + if (num_threads == 0) { + num_threads = 1; + } + + VTR_LOG("Creating CRRThreadPool with %zu threads\n", num_threads); + + for (size_t i = 0; i < num_threads; ++i) { + workers_.emplace_back(&CRRThreadPool::worker_thread, this); + } } CRRThreadPool::~CRRThreadPool() { - stop(); + stop(); - // Wake up all threads - condition_.notify_all(); + // Wake up all threads + condition_.notify_all(); - // Wait for all threads to finish - for (auto& worker : workers_) { - if (worker.joinable()) { - worker.join(); + // Wait for all threads to finish + for (auto& worker : workers_) { + if (worker.joinable()) { + worker.join(); + } } - } } void CRRThreadPool::wait_for_all() { - std::unique_lock lock(queue_mutex_); - condition_.wait( - lock, [this] { return tasks_.empty() && active_tasks_.load() == 0; }); + std::unique_lock lock(queue_mutex_); + condition_.wait( + lock, [this] { return tasks_.empty() && active_tasks_.load() == 0; }); } size_t CRRThreadPool::get_pending_tasks() const { - std::lock_guard lock(queue_mutex_); - return tasks_.size(); + std::lock_guard lock(queue_mutex_); + return tasks_.size(); } void CRRThreadPool::stop() { stop_.store(true); } void CRRThreadPool::worker_thread() { - while (true) { - std::function task; - - { - std::unique_lock lock(queue_mutex_); - - condition_.wait(lock, [this] { return stop_.load() || !tasks_.empty(); }); - - if (stop_.load() && tasks_.empty()) { - break; - } - - if (!tasks_.empty()) { - task = std::move(tasks_.front()); - tasks_.pop(); - active_tasks_.fetch_add(1); - } + while (true) { + std::function task; + + { + std::unique_lock lock(queue_mutex_); + + condition_.wait(lock, [this] { return stop_.load() || !tasks_.empty(); }); + + if (stop_.load() && tasks_.empty()) { + break; + } + + if (!tasks_.empty()) { + task = std::move(tasks_.front()); + tasks_.pop(); + active_tasks_.fetch_add(1); + } + } + + if (task) { + try { + task(); + } catch (const std::exception& e) { + VTR_LOG_ERROR("Exception in worker thread: %s\n", e.what()); + } catch (...) { + VTR_LOG_ERROR("Unknown exception in worker thread\n"); + } + + active_tasks_.fetch_sub(1); + completed_tasks_.fetch_add(1); + condition_.notify_all(); + } } - - if (task) { - try { - task(); - } catch (const std::exception& e) { - VTR_LOG_ERROR("Exception in worker thread: %s\n", e.what()); - } catch (...) { - VTR_LOG_ERROR("Unknown exception in worker thread\n"); - } - - active_tasks_.fetch_sub(1); - completed_tasks_.fetch_add(1); - condition_.notify_all(); - } - } } // ProgressTracker implementation ProgressTracker::ProgressTracker(size_t total_tasks, const std::string& operation_name) - : total_(total_tasks), - operation_name_(operation_name), - start_time_(std::chrono::steady_clock::now()) { - VTR_LOG("Starting %s: %zu tasks\n", operation_name_.c_str(), total_); + : total_(total_tasks) + , operation_name_(operation_name) + , start_time_(std::chrono::steady_clock::now()) { + VTR_LOG("Starting %s: %zu tasks\n", operation_name_.c_str(), total_); } void ProgressTracker::increment(size_t count) { - size_t new_completed = completed_.fetch_add(count) + count; + size_t new_completed = completed_.fetch_add(count) + count; - // Log progress at intervals - if (new_completed % std::max(size_t(1), total_ / 20) == 0 || - new_completed == total_) { - log_progress(); - } + // Log progress at intervals + if (new_completed % std::max(size_t(1), total_ / 20) == 0 || new_completed == total_) { + log_progress(); + } } double ProgressTracker::get_progress_percentage() const { - if (total_ == 0) return 100.0; - return (static_cast(completed_.load()) / total_) * 100.0; + if (total_ == 0) return 100.0; + return (static_cast(completed_.load()) / total_) * 100.0; } void ProgressTracker::log_progress() const { - std::lock_guard lock(log_mutex_); - - size_t current_completed = completed_.load(); - double percentage = get_progress_percentage(); - - auto now = std::chrono::steady_clock::now(); - auto elapsed = - std::chrono::duration_cast(now - start_time_); - - if (current_completed < total_) { - // Calculate ETA - if (current_completed > 0) { - auto total_estimated = elapsed * total_ / current_completed; - auto eta = total_estimated - elapsed; - - VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds, ETA: %ds\n", - operation_name_.c_str(), current_completed, total_, percentage, - elapsed.count(), eta.count()); + std::lock_guard lock(log_mutex_); + + size_t current_completed = completed_.load(); + double percentage = get_progress_percentage(); + + auto now = std::chrono::steady_clock::now(); + auto elapsed = + std::chrono::duration_cast(now - start_time_); + + if (current_completed < total_) { + // Calculate ETA + if (current_completed > 0) { + auto total_estimated = elapsed * total_ / current_completed; + auto eta = total_estimated - elapsed; + + VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds, ETA: %ds\n", + operation_name_.c_str(), current_completed, total_, percentage, + elapsed.count(), eta.count()); + } else { + VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds\n", operation_name_.c_str(), + current_completed, total_, percentage, elapsed.count()); + } } else { - VTR_LOG("%s: %zu/%zu (%.1f%%) - Elapsed: %ds\n", operation_name_.c_str(), - current_completed, total_, percentage, elapsed.count()); + VTR_LOG("%s: Complete! %zu/%zu tasks in %ds\n", operation_name_.c_str(), + current_completed, total_, elapsed.count()); } - } else { - VTR_LOG("%s: Complete! %zu/%zu tasks in %ds\n", operation_name_.c_str(), - current_completed, total_, elapsed.count()); - } } -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h index 0471e0966c..3b63ccbf4e 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_thread_pool.h @@ -13,74 +13,74 @@ namespace crrgenerator { * with progress tracking and synchronization support. */ class CRRThreadPool { - public: - /** - * @brief Constructor - * @param num_threads Number of worker threads (0 = hardware concurrency) - */ - explicit CRRThreadPool(size_t num_threads = 0); - - /** - * @brief Destructor - waits for all tasks to complete - */ - ~CRRThreadPool(); - - /** - * @brief Submit a task to the thread pool - * @param func Function to execute - * @param args Arguments to pass to the function - * @return Future for the result - */ - template - auto submit(Func&& func, Args&&... args) - -> std::future>; - - /** - * @brief Wait for all submitted tasks to complete - */ - void wait_for_all(); - - /** - * @brief Get the number of worker threads - * @return Number of threads - */ - size_t get_thread_count() const { return workers_.size(); } - - /** - * @brief Get the number of pending tasks - * @return Number of tasks in queue - */ - size_t get_pending_tasks() const; - - /** - * @brief Stop the thread pool (no new tasks accepted) - */ - void stop(); - - /** - * @brief Check if the thread pool is stopped - * @return true if stopped - */ - bool is_stopped() const { return stop_; } - - private: - // Worker threads - std::vector workers_; - - // Task queue - std::queue> tasks_; - - // Synchronization - mutable std::mutex queue_mutex_; - std::condition_variable condition_; - std::atomic stop_{false}; - - // Progress tracking - std::atomic active_tasks_{0}; - std::atomic completed_tasks_{0}; - - // Worker function - void worker_thread(); + public: + /** + * @brief Constructor + * @param num_threads Number of worker threads (0 = hardware concurrency) + */ + explicit CRRThreadPool(size_t num_threads = 0); + + /** + * @brief Destructor - waits for all tasks to complete + */ + ~CRRThreadPool(); + + /** + * @brief Submit a task to the thread pool + * @param func Function to execute + * @param args Arguments to pass to the function + * @return Future for the result + */ + template + auto submit(Func&& func, Args&&... args) + -> std::future>; + + /** + * @brief Wait for all submitted tasks to complete + */ + void wait_for_all(); + + /** + * @brief Get the number of worker threads + * @return Number of threads + */ + size_t get_thread_count() const { return workers_.size(); } + + /** + * @brief Get the number of pending tasks + * @return Number of tasks in queue + */ + size_t get_pending_tasks() const; + + /** + * @brief Stop the thread pool (no new tasks accepted) + */ + void stop(); + + /** + * @brief Check if the thread pool is stopped + * @return true if stopped + */ + bool is_stopped() const { return stop_; } + + private: + // Worker threads + std::vector workers_; + + // Task queue + std::queue> tasks_; + + // Synchronization + mutable std::mutex queue_mutex_; + std::condition_variable condition_; + std::atomic stop_{false}; + + // Progress tracking + std::atomic active_tasks_{0}; + std::atomic completed_tasks_{0}; + + // Worker function + void worker_thread(); }; /** @@ -89,76 +89,76 @@ class CRRThreadPool { * Thread-safe progress tracking with logging support. */ class ProgressTracker { - public: - ProgressTracker(size_t total_tasks, - const std::string& operation_name = "Processing"); - - /** - * @brief Increment completed task count - * @param count Number of tasks completed (default: 1) - */ - void increment(size_t count = 1); - - /** - * @brief Get current progress as percentage - * @return Progress percentage (0.0 - 100.0) - */ - double get_progress_percentage() const; - - /** - * @brief Get number of completed tasks - * @return Completed task count - */ - size_t get_completed() const { return completed_.load(); } - - /** - * @brief Get total number of tasks - * @return Total task count - */ - size_t get_total() const { return total_; } - - /** - * @brief Check if all tasks are completed - * @return true if complete - */ - bool is_complete() const { return completed_.load() >= total_; } - - /** - * @brief Log current progress - */ - void log_progress() const; - - private: - std::atomic completed_{0}; - size_t total_; - std::string operation_name_; - mutable std::mutex log_mutex_; - std::chrono::steady_clock::time_point start_time_; + public: + ProgressTracker(size_t total_tasks, + const std::string& operation_name = "Processing"); + + /** + * @brief Increment completed task count + * @param count Number of tasks completed (default: 1) + */ + void increment(size_t count = 1); + + /** + * @brief Get current progress as percentage + * @return Progress percentage (0.0 - 100.0) + */ + double get_progress_percentage() const; + + /** + * @brief Get number of completed tasks + * @return Completed task count + */ + size_t get_completed() const { return completed_.load(); } + + /** + * @brief Get total number of tasks + * @return Total task count + */ + size_t get_total() const { return total_; } + + /** + * @brief Check if all tasks are completed + * @return true if complete + */ + bool is_complete() const { return completed_.load() >= total_; } + + /** + * @brief Log current progress + */ + void log_progress() const; + + private: + std::atomic completed_{0}; + size_t total_; + std::string operation_name_; + mutable std::mutex log_mutex_; + std::chrono::steady_clock::time_point start_time_; }; // Template implementation for CRRThreadPool::submit -template +template auto CRRThreadPool::submit(Func&& func, Args&&... args) -> std::future> { - using return_type = std::invoke_result_t; + using return_type = std::invoke_result_t; - auto task = std::make_shared>( - std::bind(std::forward(func), std::forward(args)...)); + auto task = std::make_shared>( + std::bind(std::forward(func), std::forward(args)...)); - std::future result = task->get_future(); + std::future result = task->get_future(); - { - std::unique_lock lock(queue_mutex_); + { + std::unique_lock lock(queue_mutex_); - if (stop_) { - throw std::runtime_error("Cannot submit task to stopped CRRThreadPool"); - } + if (stop_) { + throw std::runtime_error("Cannot submit task to stopped CRRThreadPool"); + } - tasks_.emplace([task]() { (*task)(); }); - } + tasks_.emplace([task]() { (*task)(); }); + } - condition_.notify_one(); - return result; + condition_.notify_one(); + return result; } -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp index 4036cbeca1..664d934671 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp @@ -7,236 +7,223 @@ namespace crrgenerator { // RRGraph implementation void RRGraph::add_node(const RRNode& node) { - nodes_.push_back(node); - update_node_index(node.get_id(), nodes_.size() - 1); + nodes_.push_back(node); + update_node_index(node.get_id(), nodes_.size() - 1); } -void RRGraph::add_node(NodeId id, NodeType type, int capacity, - const std::string& direction, const Location& location, - const NodeTiming& timing, const NodeSegmentId& segment_id) { - add_node(RRNode(id, type, capacity, direction, location, timing, segment_id)); +void RRGraph::add_node(NodeId id, NodeType type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id) { + add_node(RRNode(id, type, capacity, direction, location, timing, segment_id)); } const RRNode* RRGraph::get_node(NodeId id) const { - auto it = node_id_to_index_.find(id); - return (it != node_id_to_index_.end()) ? &nodes_[it->second] : nullptr; + auto it = node_id_to_index_.find(id); + return (it != node_id_to_index_.end()) ? &nodes_[it->second] : nullptr; } RRNode* RRGraph::get_node(NodeId id) { - auto it = node_id_to_index_.find(id); - return (it != node_id_to_index_.end()) ? &nodes_[it->second] : nullptr; + auto it = node_id_to_index_.find(id); + return (it != node_id_to_index_.end()) ? &nodes_[it->second] : nullptr; } void RRGraph::add_edge(const RREdge& edge) { edges_.push_back(edge); } void RRGraph::add_edge(NodeId src_node, NodeId sink_node, SwitchId switch_id) { - add_edge(RREdge(src_node, sink_node, switch_id)); + add_edge(RREdge(src_node, sink_node, switch_id)); } void RRGraph::add_channel(const Channel& channel) { - channels_.push_back(channel); + channels_.push_back(channel); } -void RRGraph::add_channel(int max_width, int x_max, int x_min, int y_max, - int y_min) { - add_channel(Channel(max_width, x_max, x_min, y_max, y_min)); +void RRGraph::add_channel(int max_width, int x_max, int x_min, int y_max, int y_min) { + add_channel(Channel(max_width, x_max, x_min, y_max, y_min)); } void RRGraph::add_xy_list(const XYList& xy_list) { - xy_lists_.push_back(xy_list); + xy_lists_.push_back(xy_list); } void RRGraph::add_xy_list(XYList::Type type, int index, int info) { - add_xy_list(XYList(type, index, info)); + add_xy_list(XYList(type, index, info)); } void RRGraph::add_switch(const Switch& switch_obj) { - switches_.push_back(switch_obj); - update_switch_index(switch_obj.get_id(), switches_.size() - 1); + switches_.push_back(switch_obj); + update_switch_index(switch_obj.get_id(), switches_.size() - 1); } -void RRGraph::add_switch(SwitchId id, const std::string& name, - const std::string& type, const Timing& timing, - const Sizing& sizing) { - add_switch(Switch(id, name, type, timing, sizing)); +void RRGraph::add_switch(SwitchId id, const std::string& name, const std::string& type, const Timing& timing, const Sizing& sizing) { + add_switch(Switch(id, name, type, timing, sizing)); } const Switch* RRGraph::get_switch(SwitchId id) const { - auto it = switch_id_to_index_.find(id); - return (it != switch_id_to_index_.end()) ? &switches_[it->second] : nullptr; + auto it = switch_id_to_index_.find(id); + return (it != switch_id_to_index_.end()) ? &switches_[it->second] : nullptr; } Switch* RRGraph::get_switch(SwitchId id) { - auto it = switch_id_to_index_.find(id); - return (it != switch_id_to_index_.end()) ? &switches_[it->second] : nullptr; + auto it = switch_id_to_index_.find(id); + return (it != switch_id_to_index_.end()) ? &switches_[it->second] : nullptr; } void RRGraph::add_segment(const Segment& segment) { - segments_.push_back(segment); - update_segment_index(segment.get_id(), segments_.size() - 1); + segments_.push_back(segment); + update_segment_index(segment.get_id(), segments_.size() - 1); } -void RRGraph::add_segment(SegmentId id, const std::string& name, int length, - const std::string& res_type) { - add_segment(Segment(id, name, length, res_type)); +void RRGraph::add_segment(SegmentId id, const std::string& name, int length, const std::string& res_type) { + add_segment(Segment(id, name, length, res_type)); } const Segment* RRGraph::get_segment(SegmentId id) const { - auto it = segment_id_to_index_.find(id); - return (it != segment_id_to_index_.end()) ? &segments_[it->second] : nullptr; + auto it = segment_id_to_index_.find(id); + return (it != segment_id_to_index_.end()) ? &segments_[it->second] : nullptr; } void RRGraph::add_block_type(const BlockType& block_type) { - block_types_.push_back(block_type); + block_types_.push_back(block_type); } -void RRGraph::add_block_type(int id, const std::string& name, int height, - int width, - const std::vector& pin_classes) { - add_block_type(BlockType(id, name, height, width, pin_classes)); +void RRGraph::add_block_type(int id, const std::string& name, int height, int width, const std::vector& pin_classes) { + add_block_type(BlockType(id, name, height, width, pin_classes)); } void RRGraph::add_grid_loc(const GridLoc& grid_loc) { - grid_locs_.push_back(grid_loc); + grid_locs_.push_back(grid_loc); } -void RRGraph::add_grid_loc(int type_id, int height_offset, int width_offset, - int x, int y, int layer) { - add_grid_loc(GridLoc(type_id, height_offset, width_offset, x, y, layer)); +void RRGraph::add_grid_loc(int type_id, int height_offset, int width_offset, int x, int y, int layer) { + add_grid_loc(GridLoc(type_id, height_offset, width_offset, x, y, layer)); } void RRGraph::clear() { - nodes_.clear(); - edges_.clear(); - switches_.clear(); - segments_.clear(); - node_id_to_index_.clear(); - switch_id_to_index_.clear(); - segment_id_to_index_.clear(); - tool_name_.clear(); - tool_version_.clear(); - tool_comment_.clear(); + nodes_.clear(); + edges_.clear(); + switches_.clear(); + segments_.clear(); + node_id_to_index_.clear(); + switch_id_to_index_.clear(); + segment_id_to_index_.clear(); + tool_name_.clear(); + tool_version_.clear(); + tool_comment_.clear(); } void RRGraph::print_statistics() const { - VTR_LOG("=== CRR Generator RR Graph Statistics ===\n"); - VTR_LOG("Nodes: %zu\n", nodes_.size()); - VTR_LOG("Edges: %zu\n", edges_.size()); - VTR_LOG("Switches: %zu\n", switches_.size()); - VTR_LOG("Segments: %zu\n", segments_.size()); - - // Count nodes by type - std::map type_counts; - for (const auto& node : nodes_) { - type_counts[node.get_type()]++; - } + VTR_LOG("=== CRR Generator RR Graph Statistics ===\n"); + VTR_LOG("Nodes: %zu\n", nodes_.size()); + VTR_LOG("Edges: %zu\n", edges_.size()); + VTR_LOG("Switches: %zu\n", switches_.size()); + VTR_LOG("Segments: %zu\n", segments_.size()); + + // Count nodes by type + std::map type_counts; + for (const auto& node : nodes_) { + type_counts[node.get_type()]++; + } - for (const auto& [type, count] : type_counts) { - VTR_LOG(" %s nodes: %zu\n", to_string(type), count); - } + for (const auto& [type, count] : type_counts) { + VTR_LOG(" %s nodes: %zu\n", to_string(type), count); + } - VTR_LOG("Tool: %s v%s\n", tool_name_.c_str(), tool_version_.c_str()); - if (!tool_comment_.empty()) { - VTR_LOG("Comment: %s\n", tool_comment_.c_str()); - } + VTR_LOG("Tool: %s v%s\n", tool_name_.c_str(), tool_version_.c_str()); + if (!tool_comment_.empty()) { + VTR_LOG("Comment: %s\n", tool_comment_.c_str()); + } } std::vector RRGraph::get_nodes_by_type(NodeType type) const { - std::vector result; - for (const auto& node : nodes_) { - if (node.get_type() == type) { - result.push_back(node.get_id()); + std::vector result; + for (const auto& node : nodes_) { + if (node.get_type() == type) { + result.push_back(node.get_id()); + } } - } - return result; + return result; } std::unordered_set RRGraph::get_source_nodes() const { - std::unordered_set result; - for (const auto& node : nodes_) { - if (node.get_type() == NodeType::SOURCE) { - result.insert(node.get_id()); + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::SOURCE) { + result.insert(node.get_id()); + } } - } - return result; + return result; } std::unordered_set RRGraph::get_sink_nodes() const { - std::unordered_set result; - for (const auto& node : nodes_) { - if (node.get_type() == NodeType::SINK) { - result.insert(node.get_id()); + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::SINK) { + result.insert(node.get_id()); + } } - } - return result; + return result; } std::unordered_set RRGraph::get_ipin_nodes() const { - std::unordered_set result; - for (const auto& node : nodes_) { - if (node.get_type() == NodeType::IPIN) { - result.insert(node.get_id()); + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::IPIN) { + result.insert(node.get_id()); + } } - } - return result; + return result; } std::unordered_set RRGraph::get_opin_nodes() const { - std::unordered_set result; - for (const auto& node : nodes_) { - if (node.get_type() == NodeType::OPIN) { - result.insert(node.get_id()); + std::unordered_set result; + for (const auto& node : nodes_) { + if (node.get_type() == NodeType::OPIN) { + result.insert(node.get_id()); + } } - } - return result; + return result; } std::vector RRGraph::get_preserved_edges(const bool preserve_pin_connections) const { - std::vector result; - auto source_nodes = get_source_nodes(); - auto sink_nodes = get_sink_nodes(); - auto ipin_nodes = get_ipin_nodes(); - auto opin_nodes = get_opin_nodes(); - for (const auto& edge : edges_) { - auto edge_src_node = edge.get_src_node(); - auto edge_sink_node = edge.get_sink_node(); - if (source_nodes.find(edge_src_node) != source_nodes.end() || - sink_nodes.find(edge_sink_node) != sink_nodes.end() || - (opin_nodes.find(edge_src_node) != opin_nodes.end() && - ipin_nodes.find(edge_sink_node) != ipin_nodes.end())) { - result.push_back(edge); - } else { - if (preserve_pin_connections) { - if (ipin_nodes.find(edge_sink_node) != ipin_nodes.end() || - opin_nodes.find(edge_src_node) != opin_nodes.end()) { - result.push_back(edge); + std::vector result; + auto source_nodes = get_source_nodes(); + auto sink_nodes = get_sink_nodes(); + auto ipin_nodes = get_ipin_nodes(); + auto opin_nodes = get_opin_nodes(); + for (const auto& edge : edges_) { + auto edge_src_node = edge.get_src_node(); + auto edge_sink_node = edge.get_sink_node(); + if (source_nodes.find(edge_src_node) != source_nodes.end() || sink_nodes.find(edge_sink_node) != sink_nodes.end() || (opin_nodes.find(edge_src_node) != opin_nodes.end() && ipin_nodes.find(edge_sink_node) != ipin_nodes.end())) { + result.push_back(edge); + } else { + if (preserve_pin_connections) { + if (ipin_nodes.find(edge_sink_node) != ipin_nodes.end() || opin_nodes.find(edge_src_node) != opin_nodes.end()) { + result.push_back(edge); + } + } } } - } - // Remove duplicate edges - std::sort(result.begin(), result.end()); - result.erase(std::unique(result.begin(), result.end()), result.end()); - return result; + // Remove duplicate edges + std::sort(result.begin(), result.end()); + result.erase(std::unique(result.begin(), result.end()), result.end()); + return result; } -void RRGraph::set_tool_info(const std::string& name, const std::string& version, - const std::string& comment) { - tool_name_ = name; - tool_version_ = version; - tool_comment_ = comment; +void RRGraph::set_tool_info(const std::string& name, const std::string& version, const std::string& comment) { + tool_name_ = name; + tool_version_ = version; + tool_comment_ = comment; } void RRGraph::update_node_index(NodeId id, size_t index) { - node_id_to_index_[id] = index; + node_id_to_index_[id] = index; } void RRGraph::update_switch_index(SwitchId id, size_t index) { - switch_id_to_index_[id] = index; + switch_id_to_index_[id] = index; } void RRGraph::update_segment_index(SegmentId id, size_t index) { - segment_id_to_index_[id] = index; + segment_id_to_index_[id] = index; } -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h index b9395927ef..822b837a17 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h @@ -8,342 +8,349 @@ namespace crrgenerator { * @brief Represents a routing resource node in the FPGA */ class RRNode { - public: - RRNode() = default; - RRNode(NodeId id, NodeType type, int capacity, const std::string& direction, - const Location& location, const NodeTiming& timing, - const NodeSegmentId& segment_id) - : id_(id), - type_(type), - capacity_(capacity), - direction_(direction), - location_(location), - timing_(timing), - segment_id_(segment_id) {} - - // Getters - NodeId get_id() const { return id_; } - NodeType get_type() const { return type_; } - int get_capacity() const { return capacity_; } - const std::string& get_direction() const { return direction_; } - const Location& get_location() const { return location_; } - const std::string& get_ptc() const { return location_.ptc; } - const NodeTiming& get_timing() const { return timing_; } - const NodeSegmentId& get_segment() const { return segment_id_; } - - // Setters - void set_id(NodeId id) { id_ = id; } - void set_type(NodeType type) { type_ = type; } - void set_capacity(int capacity) { capacity_ = capacity; } - void set_direction(const std::string& direction) { direction_ = direction; } - void set_location(const Location& location) { location_ = location; } - void set_timing(const NodeTiming& timing) { timing_ = timing; } - void set_segment(const NodeSegmentId& segment_id) { segment_id_ = segment_id; } - - // Utility methods - NodeHash get_hash() const { - return std::make_tuple(type_, location_.ptc, location_.x_low, - location_.x_high, location_.y_low, location_.y_high); - } - - bool is_single_coordinate() const { - return (location_.x_low == location_.x_high) && - (location_.y_low == location_.y_high); - } - - bool operator<(const RRNode& other) const { - return id_ < other.id_; - } - - bool operator==(const RRNode& other) const { - return id_ == other.id_; - } - - private: - NodeId id_{0}; - NodeType type_{NodeType::INVALID}; - int capacity_{-1}; - std::string direction_; - Location location_; - NodeTiming timing_; - NodeSegmentId segment_id_; + public: + RRNode() = default; + RRNode(NodeId id, NodeType type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id) + : id_(id) + , type_(type) + , capacity_(capacity) + , direction_(direction) + , location_(location) + , timing_(timing) + , segment_id_(segment_id) {} + + // Getters + NodeId get_id() const { return id_; } + NodeType get_type() const { return type_; } + int get_capacity() const { return capacity_; } + const std::string& get_direction() const { return direction_; } + const Location& get_location() const { return location_; } + const std::string& get_ptc() const { return location_.ptc; } + const NodeTiming& get_timing() const { return timing_; } + const NodeSegmentId& get_segment() const { return segment_id_; } + + // Setters + void set_id(NodeId id) { id_ = id; } + void set_type(NodeType type) { type_ = type; } + void set_capacity(int capacity) { capacity_ = capacity; } + void set_direction(const std::string& direction) { direction_ = direction; } + void set_location(const Location& location) { location_ = location; } + void set_timing(const NodeTiming& timing) { timing_ = timing; } + void set_segment(const NodeSegmentId& segment_id) { segment_id_ = segment_id; } + + // Utility methods + NodeHash get_hash() const { + return std::make_tuple(type_, location_.ptc, location_.x_low, + location_.x_high, location_.y_low, location_.y_high); + } + + bool is_single_coordinate() const { + return (location_.x_low == location_.x_high) && (location_.y_low == location_.y_high); + } + + bool operator<(const RRNode& other) const { + return id_ < other.id_; + } + + bool operator==(const RRNode& other) const { + return id_ == other.id_; + } + + private: + NodeId id_{0}; + NodeType type_{NodeType::INVALID}; + int capacity_{-1}; + std::string direction_; + Location location_; + NodeTiming timing_; + NodeSegmentId segment_id_; }; /** * @brief Represents a routing edge connecting two nodes */ class RREdge { - public: - RREdge() = default; - RREdge(NodeId src_node, NodeId sink_node, SwitchId switch_id) - : src_node_(src_node), sink_node_(sink_node), switch_id_(switch_id) {} - - // Getters - NodeId get_src_node() const { return src_node_; } - NodeId get_sink_node() const { return sink_node_; } - SwitchId get_switch_id() const { return switch_id_; } - - // Setters - void set_src_node(NodeId node) { src_node_ = node; } - void set_sink_node(NodeId node) { sink_node_ = node; } - void set_switch_id(SwitchId id) { switch_id_ = id; } - - bool operator<(const RREdge& other) const { - return std::tie(src_node_, sink_node_, switch_id_) < - std::tie(other.src_node_, other.sink_node_, other.switch_id_); - } - - bool operator==(const RREdge& other) const { - return src_node_ == other.src_node_ && sink_node_ == other.sink_node_ && - switch_id_ == other.switch_id_; - } - - private: - NodeId src_node_{0}; - NodeId sink_node_{0}; - SwitchId switch_id_{0}; + public: + RREdge() = default; + RREdge(NodeId src_node, NodeId sink_node, SwitchId switch_id) + : src_node_(src_node) + , sink_node_(sink_node) + , switch_id_(switch_id) {} + + // Getters + NodeId get_src_node() const { return src_node_; } + NodeId get_sink_node() const { return sink_node_; } + SwitchId get_switch_id() const { return switch_id_; } + + // Setters + void set_src_node(NodeId node) { src_node_ = node; } + void set_sink_node(NodeId node) { sink_node_ = node; } + void set_switch_id(SwitchId id) { switch_id_ = id; } + + bool operator<(const RREdge& other) const { + return std::tie(src_node_, sink_node_, switch_id_) < std::tie(other.src_node_, other.sink_node_, other.switch_id_); + } + + bool operator==(const RREdge& other) const { + return src_node_ == other.src_node_ && sink_node_ == other.sink_node_ && switch_id_ == other.switch_id_; + } + + private: + NodeId src_node_{0}; + NodeId sink_node_{0}; + SwitchId switch_id_{0}; }; /** * @brief Represents a list of X or Y coordinates */ class XYList { - public: - enum class Type { X_LIST, Y_LIST, INVALID_LIST }; - - XYList() = default; - XYList(Type type, int index, int info) - : type_(type), index_(index), info_(info) {} - - // Getters - Type get_type() const { return type_; } - int get_index() const { return index_; } - int get_info() const { return info_; } - - // Setters - void set_type(Type type) { type_ = type; } - void set_index(int index) { index_ = index; } - void set_info(int info) { info_ = info; } - - private: - Type type_{Type::INVALID_LIST}; - int index_{-1}; - int info_{-1}; + public: + enum class Type { X_LIST, + Y_LIST, + INVALID_LIST }; + + XYList() = default; + XYList(Type type, int index, int info) + : type_(type) + , index_(index) + , info_(info) {} + + // Getters + Type get_type() const { return type_; } + int get_index() const { return index_; } + int get_info() const { return info_; } + + // Setters + void set_type(Type type) { type_ = type; } + void set_index(int index) { index_ = index; } + void set_info(int info) { info_ = info; } + + private: + Type type_{Type::INVALID_LIST}; + int index_{-1}; + int info_{-1}; }; /** * @brief Represents a channel in the FPGA */ class Channel { - public: - Channel() = default; - Channel(int max_width, int x_max, int x_min, int y_max, int y_min) - : max_width_(max_width), - x_max_(x_max), - x_min_(x_min), - y_max_(y_max), - y_min_(y_min) {} - - // Getters - int get_max_width() const { return max_width_; } - int get_x_max() const { return x_max_; } - int get_x_min() const { return x_min_; } - int get_y_max() const { return y_max_; } - int get_y_min() const { return y_min_; } - - // Setters - void set_max_width(int max_width) { max_width_ = max_width; } - void set_x_max(int x_max) { x_max_ = x_max; } - void set_x_min(int x_min) { x_min_ = x_min; } - void set_y_max(int y_max) { y_max_ = y_max; } - void set_y_min(int y_min) { y_min_ = y_min; } - - private: - int max_width_{-1}; - int x_max_{-1}; - int x_min_{-1}; - int y_max_{-1}; - int y_min_{-1}; + public: + Channel() = default; + Channel(int max_width, int x_max, int x_min, int y_max, int y_min) + : max_width_(max_width) + , x_max_(x_max) + , x_min_(x_min) + , y_max_(y_max) + , y_min_(y_min) {} + + // Getters + int get_max_width() const { return max_width_; } + int get_x_max() const { return x_max_; } + int get_x_min() const { return x_min_; } + int get_y_max() const { return y_max_; } + int get_y_min() const { return y_min_; } + + // Setters + void set_max_width(int max_width) { max_width_ = max_width; } + void set_x_max(int x_max) { x_max_ = x_max; } + void set_x_min(int x_min) { x_min_ = x_min; } + void set_y_max(int y_max) { y_max_ = y_max; } + void set_y_min(int y_min) { y_min_ = y_min; } + + private: + int max_width_{-1}; + int x_max_{-1}; + int x_min_{-1}; + int y_max_{-1}; + int y_min_{-1}; }; /** * @brief Represents a pin in the FPGA */ class Pin { - public: - Pin() = default; - Pin(const int ptc, const std::string& value) : ptc_(ptc), value_(value) {} - - // Getters - int get_ptc() const { return ptc_; } - std::string get_value() const { return value_; } - - // Setters - void set_ptc(const int ptc) { ptc_ = ptc; } - void set_value(const std::string& value) { value_ = value; } - - private: - int ptc_; - std::string value_; + public: + Pin() = default; + Pin(const int ptc, const std::string& value) + : ptc_(ptc) + , value_(value) {} + + // Getters + int get_ptc() const { return ptc_; } + std::string get_value() const { return value_; } + + // Setters + void set_ptc(const int ptc) { ptc_ = ptc; } + void set_value(const std::string& value) { value_ = value; } + + private: + int ptc_; + std::string value_; }; /** * @brief Represents a pin class in the FPGA */ class PinClass { - public: - PinClass() = default; - PinClass(const std::string& type, const std::vector& pins) - : type_(type), pins_(pins) {} - - // Getters - const std::string& get_type() const { return type_; } - const std::vector& get_pins() const { return pins_; } - - // Setters - void set_type(const std::string& type) { type_ = type; } - void set_pins(const std::vector& pins) { pins_ = pins; } - - private: - std::string type_; - std::vector pins_; + public: + PinClass() = default; + PinClass(const std::string& type, const std::vector& pins) + : type_(type) + , pins_(pins) {} + + // Getters + const std::string& get_type() const { return type_; } + const std::vector& get_pins() const { return pins_; } + + // Setters + void set_type(const std::string& type) { type_ = type; } + void set_pins(const std::vector& pins) { pins_ = pins; } + + private: + std::string type_; + std::vector pins_; }; /** * @brief Represents a block type in the FPGA */ class BlockType { - public: - BlockType() = default; - BlockType(int id, const std::string& name, int height, int width, - const std::vector& pin_classes) - : id_(id), - name_(name), - height_(height), - width_(width), - pin_classes_(pin_classes) {} - - // Getters - int get_id() const { return id_; } - const std::string& get_name() const { return name_; } - int get_height() const { return height_; } - int get_width() const { return width_; } - const std::vector& get_pin_classes() const { return pin_classes_; } - // Setters - void set_id(int id) { id_ = id; } - void set_name(const std::string& name) { name_ = name; } - void set_height(int height) { height_ = height; } - void set_width(int width) { width_ = width; } - void set_pin_classes(const std::vector& pin_classes) { - pin_classes_ = pin_classes; - } - - private: - int id_{-1}; - std::string name_; - int height_{-1}; - int width_{-1}; - std::vector pin_classes_; + public: + BlockType() = default; + BlockType(int id, const std::string& name, int height, int width, const std::vector& pin_classes) + : id_(id) + , name_(name) + , height_(height) + , width_(width) + , pin_classes_(pin_classes) {} + + // Getters + int get_id() const { return id_; } + const std::string& get_name() const { return name_; } + int get_height() const { return height_; } + int get_width() const { return width_; } + const std::vector& get_pin_classes() const { return pin_classes_; } + // Setters + void set_id(int id) { id_ = id; } + void set_name(const std::string& name) { name_ = name; } + void set_height(int height) { height_ = height; } + void set_width(int width) { width_ = width; } + void set_pin_classes(const std::vector& pin_classes) { + pin_classes_ = pin_classes; + } + + private: + int id_{-1}; + std::string name_; + int height_{-1}; + int width_{-1}; + std::vector pin_classes_; }; /** * @brief Represents a grid in the FPGA */ class GridLoc { - public: - GridLoc() = default; - GridLoc(int type_id, int height_offset, int width_offset, int x, int y, - int layer) - : type_id_(type_id), - height_offset_(height_offset), - width_offset_(width_offset), - x_(x), - y_(y), - layer_(layer) {} - - // Getters - int get_type_id() const { return type_id_; } - int get_height_offset() const { return height_offset_; } - int get_width_offset() const { return width_offset_; } - int get_x() const { return x_; } - int get_y() const { return y_; } - int get_layer() const { return layer_; } - - // Setters - void set_type_id(int type_id) { type_id_ = type_id; } - void set_height_offset(int height_offset) { height_offset_ = height_offset; } - void set_width_offset(int width_offset) { width_offset_ = width_offset; } - void set_x(int x) { x_ = x; } - void set_y(int y) { y_ = y; } - void set_layer(int layer) { layer_ = layer; } - - private: - int type_id_{-1}; - int height_offset_{-1}; - int width_offset_{-1}; - int x_{-1}; - int y_{-1}; - int layer_{-1}; + public: + GridLoc() = default; + GridLoc(int type_id, int height_offset, int width_offset, int x, int y, int layer) + : type_id_(type_id) + , height_offset_(height_offset) + , width_offset_(width_offset) + , x_(x) + , y_(y) + , layer_(layer) {} + + // Getters + int get_type_id() const { return type_id_; } + int get_height_offset() const { return height_offset_; } + int get_width_offset() const { return width_offset_; } + int get_x() const { return x_; } + int get_y() const { return y_; } + int get_layer() const { return layer_; } + + // Setters + void set_type_id(int type_id) { type_id_ = type_id; } + void set_height_offset(int height_offset) { height_offset_ = height_offset; } + void set_width_offset(int width_offset) { width_offset_ = width_offset; } + void set_x(int x) { x_ = x; } + void set_y(int y) { y_ = y; } + void set_layer(int layer) { layer_ = layer; } + + private: + int type_id_{-1}; + int height_offset_{-1}; + int width_offset_{-1}; + int x_{-1}; + int y_{-1}; + int layer_{-1}; }; /** * @brief Represents a switch with timing and sizing information */ class Switch { - public: - Switch() = default; - Switch(SwitchId id, const std::string& name, const std::string& type, - const Timing& timing, const Sizing& sizing) - : id_(id), name_(name), type_(type), timing_(timing), sizing_(sizing) {} - - // Getters - SwitchId get_id() const { return id_; } - const std::string& get_name() const { return name_; } - const std::string& get_type() const { return type_; } - const Timing& get_timing() const { return timing_; } - const Sizing& get_sizing() const { return sizing_; } - - // Setters - void set_id(SwitchId id) { id_ = id; } - void set_name(const std::string& name) { name_ = name; } - void set_type(const std::string& type) { type_ = type; } - void set_timing(const Timing& timing) { timing_ = timing; } - void set_sizing(const Sizing& sizing) { sizing_ = sizing; } - - private: - SwitchId id_{0}; - std::string name_; - std::string type_; - Timing timing_; - Sizing sizing_; + public: + Switch() = default; + Switch(SwitchId id, const std::string& name, const std::string& type, const Timing& timing, const Sizing& sizing) + : id_(id) + , name_(name) + , type_(type) + , timing_(timing) + , sizing_(sizing) {} + + // Getters + SwitchId get_id() const { return id_; } + const std::string& get_name() const { return name_; } + const std::string& get_type() const { return type_; } + const Timing& get_timing() const { return timing_; } + const Sizing& get_sizing() const { return sizing_; } + + // Setters + void set_id(SwitchId id) { id_ = id; } + void set_name(const std::string& name) { name_ = name; } + void set_type(const std::string& type) { type_ = type; } + void set_timing(const Timing& timing) { timing_ = timing; } + void set_sizing(const Sizing& sizing) { sizing_ = sizing; } + + private: + SwitchId id_{0}; + std::string name_; + std::string type_; + Timing timing_; + Sizing sizing_; }; /** * @brief Represents a wire segment */ class Segment { - public: - Segment() = default; - Segment(SegmentId id, const std::string& name, int length, - const std::string& res_type) - : id_(id), name_(name), length_(length), res_type_(res_type) {} - - // Getters - SegmentId get_id() const { return id_; } - const std::string& get_name() const { return name_; } - int get_length() const { return length_; } - const std::string& get_res_type() const { return res_type_; } - // Setters - void set_id(SegmentId id) { id_ = id; } - void set_name(const std::string& name) { name_ = name; } - void set_length(int length) { length_ = length; } - void set_res_type(const std::string& res_type) { res_type_ = res_type; } - - private: - SegmentId id_{0}; - std::string name_; - int length_{-1}; - std::string res_type_; + public: + Segment() = default; + Segment(SegmentId id, const std::string& name, int length, const std::string& res_type) + : id_(id) + , name_(name) + , length_(length) + , res_type_(res_type) {} + + // Getters + SegmentId get_id() const { return id_; } + const std::string& get_name() const { return name_; } + int get_length() const { return length_; } + const std::string& get_res_type() const { return res_type_; } + // Setters + void set_id(SegmentId id) { id_ = id; } + void set_name(const std::string& name) { name_ = name; } + void set_length(int length) { length_ = length; } + void set_res_type(const std::string& res_type) { res_type_ = res_type; } + + private: + SegmentId id_{0}; + std::string name_; + int length_{-1}; + std::string res_type_; }; /** @@ -353,144 +360,140 @@ class Segment { * the FPGA routing resource graph. */ class RRGraph { - public: - RRGraph() = default; - - // Node management - void add_node(const RRNode& node); - void add_node(NodeId id, NodeType type, int capacity, - const std::string& direction, const Location& location, - const NodeTiming& timing, const NodeSegmentId& segment_id); - const RRNode* get_node(NodeId id) const; - RRNode* get_node(NodeId id); - const std::vector& get_nodes() const { return nodes_; } - std::vector& get_nodes() { return nodes_; } - size_t get_node_count() const { return nodes_.size(); } - - // Edge management - void add_edge(const RREdge& edge); - void add_edge(NodeId src_node, NodeId sink_node, SwitchId switch_id); - const std::vector& get_edges() const { return edges_; } - std::vector& get_edges() { return edges_; } - size_t get_edge_count() const { return edges_.size(); } - - // Channel management - void add_channel(const Channel& channel); - void add_channel(int max_width, int x_max, int x_min, int y_max, int y_min); - const Channel* get_channel(size_t channel_id) const { - return &channels_[channel_id]; - } - Channel* get_channel(size_t channel_id) { return &channels_[channel_id]; } - const std::vector& get_channels() const { return channels_; } - std::vector& get_channels() { return channels_; } - size_t get_channel_count() const { return channels_.size(); } - - // XYList management - void add_xy_list(const XYList& xy_list); - void add_xy_list(XYList::Type type, int index, int info); - const XYList* get_xy_list(size_t xy_list_id) const { - return &xy_lists_[xy_list_id]; - } - XYList* get_xy_list(size_t xy_list_id) { return &xy_lists_[xy_list_id]; } - const std::vector& get_xy_lists() const { return xy_lists_; } - std::vector& get_xy_lists() { return xy_lists_; } - size_t get_xy_list_count() const { return xy_lists_.size(); } - - // Switch management - void add_switch(const Switch& switch_obj); - void add_switch(SwitchId id, const std::string& name, const std::string& type, - const Timing& timing, const Sizing& sizing); - const Switch* get_switch(SwitchId id) const; - Switch* get_switch(SwitchId id); - const std::vector& get_switches() const { return switches_; } - std::vector& get_switches() { return switches_; } - size_t get_switch_count() const { return switches_.size(); } - - // Segment management - void add_segment(const Segment& segment); - void add_segment(SegmentId id, const std::string& name, int length, - const std::string& res_type); - const Segment* get_segment(SegmentId id) const; - const std::vector& get_segments() const { return segments_; } - std::vector& get_segments() { return segments_; } - size_t get_segment_count() const { return segments_.size(); } - - // Block type management - void add_block_type(const BlockType& block_type); - void add_block_type(int id, const std::string& name, int height, int width, - const std::vector& pin_classes); - const BlockType* get_block_type(size_t id) const { return &block_types_[id]; } - BlockType* get_block_type(size_t id) { return &block_types_[id]; } - const std::vector& get_block_types() const { return block_types_; } - std::vector& get_block_types() { return block_types_; } - size_t get_block_type_count() const { return block_types_.size(); } - - // Grid management - void add_grid_loc(const GridLoc& grid_loc); - void add_grid_loc(int type_id, int height_offset, int width_offset, int x, - int y, int layer); - const GridLoc* get_grid_loc(size_t grid_loc_id) const { - return &grid_locs_[grid_loc_id]; - } - GridLoc* get_grid_loc(size_t grid_loc_id) { return &grid_locs_[grid_loc_id]; } - const std::vector& get_grid_locs() const { return grid_locs_; } - std::vector& get_grid_locs() { return grid_locs_; } - size_t get_grid_loc_count() const { return grid_locs_.size(); } - - // Utility methods - void clear(); - void reserve_nodes(size_t count) { nodes_.reserve(count); } - void reserve_edges(size_t count) { edges_.reserve(count); } - void reserve_switches(size_t count) { switches_.reserve(count); } - void reserve_segments(size_t count) { segments_.reserve(count); } - void sort_nodes() { std::sort(nodes_.begin(), nodes_.end()); } - void sort_edges() { std::sort(edges_.begin(), edges_.end()); } - void shrink_to_fit() { nodes_.shrink_to_fit(); edges_.shrink_to_fit(); } - - // Statistics - void print_statistics() const; - - // Node categorization - std::vector get_nodes_by_type(NodeType type) const; - std::unordered_set get_source_nodes() const; - std::unordered_set get_sink_nodes() const; - std::unordered_set get_ipin_nodes() const; - std::unordered_set get_opin_nodes() const; - - // Edge filtering - std::vector get_preserved_edges(const bool preserve_pin_connections) const; - - // Metadata - void set_tool_info(const std::string& name, const std::string& version, - const std::string& comment); - const std::string& get_tool_name() const { return tool_name_; } - const std::string& get_tool_version() const { return tool_version_; } - const std::string& get_tool_comment() const { return tool_comment_; } - - private: - std::vector nodes_; - std::vector edges_; - std::vector channels_; - std::vector xy_lists_; - std::vector switches_; - std::vector segments_; - std::vector block_types_; - std::vector grid_locs_; - - // Lookup maps for efficiency - std::unordered_map node_id_to_index_; - std::unordered_map switch_id_to_index_; - std::unordered_map segment_id_to_index_; - - // Metadata - std::string tool_name_; - std::string tool_version_; - std::string tool_comment_; - - // Helper methods - void update_node_index(NodeId id, size_t index); - void update_switch_index(SwitchId id, size_t index); - void update_segment_index(SegmentId id, size_t index); + public: + RRGraph() = default; + + // Node management + void add_node(const RRNode& node); + void add_node(NodeId id, NodeType type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id); + const RRNode* get_node(NodeId id) const; + RRNode* get_node(NodeId id); + const std::vector& get_nodes() const { return nodes_; } + std::vector& get_nodes() { return nodes_; } + size_t get_node_count() const { return nodes_.size(); } + + // Edge management + void add_edge(const RREdge& edge); + void add_edge(NodeId src_node, NodeId sink_node, SwitchId switch_id); + const std::vector& get_edges() const { return edges_; } + std::vector& get_edges() { return edges_; } + size_t get_edge_count() const { return edges_.size(); } + + // Channel management + void add_channel(const Channel& channel); + void add_channel(int max_width, int x_max, int x_min, int y_max, int y_min); + const Channel* get_channel(size_t channel_id) const { + return &channels_[channel_id]; + } + Channel* get_channel(size_t channel_id) { return &channels_[channel_id]; } + const std::vector& get_channels() const { return channels_; } + std::vector& get_channels() { return channels_; } + size_t get_channel_count() const { return channels_.size(); } + + // XYList management + void add_xy_list(const XYList& xy_list); + void add_xy_list(XYList::Type type, int index, int info); + const XYList* get_xy_list(size_t xy_list_id) const { + return &xy_lists_[xy_list_id]; + } + XYList* get_xy_list(size_t xy_list_id) { return &xy_lists_[xy_list_id]; } + const std::vector& get_xy_lists() const { return xy_lists_; } + std::vector& get_xy_lists() { return xy_lists_; } + size_t get_xy_list_count() const { return xy_lists_.size(); } + + // Switch management + void add_switch(const Switch& switch_obj); + void add_switch(SwitchId id, const std::string& name, const std::string& type, const Timing& timing, const Sizing& sizing); + const Switch* get_switch(SwitchId id) const; + Switch* get_switch(SwitchId id); + const std::vector& get_switches() const { return switches_; } + std::vector& get_switches() { return switches_; } + size_t get_switch_count() const { return switches_.size(); } + + // Segment management + void add_segment(const Segment& segment); + void add_segment(SegmentId id, const std::string& name, int length, const std::string& res_type); + const Segment* get_segment(SegmentId id) const; + const std::vector& get_segments() const { return segments_; } + std::vector& get_segments() { return segments_; } + size_t get_segment_count() const { return segments_.size(); } + + // Block type management + void add_block_type(const BlockType& block_type); + void add_block_type(int id, const std::string& name, int height, int width, const std::vector& pin_classes); + const BlockType* get_block_type(size_t id) const { return &block_types_[id]; } + BlockType* get_block_type(size_t id) { return &block_types_[id]; } + const std::vector& get_block_types() const { return block_types_; } + std::vector& get_block_types() { return block_types_; } + size_t get_block_type_count() const { return block_types_.size(); } + + // Grid management + void add_grid_loc(const GridLoc& grid_loc); + void add_grid_loc(int type_id, int height_offset, int width_offset, int x, int y, int layer); + const GridLoc* get_grid_loc(size_t grid_loc_id) const { + return &grid_locs_[grid_loc_id]; + } + GridLoc* get_grid_loc(size_t grid_loc_id) { return &grid_locs_[grid_loc_id]; } + const std::vector& get_grid_locs() const { return grid_locs_; } + std::vector& get_grid_locs() { return grid_locs_; } + size_t get_grid_loc_count() const { return grid_locs_.size(); } + + // Utility methods + void clear(); + void reserve_nodes(size_t count) { nodes_.reserve(count); } + void reserve_edges(size_t count) { edges_.reserve(count); } + void reserve_switches(size_t count) { switches_.reserve(count); } + void reserve_segments(size_t count) { segments_.reserve(count); } + void sort_nodes() { std::sort(nodes_.begin(), nodes_.end()); } + void sort_edges() { std::sort(edges_.begin(), edges_.end()); } + void shrink_to_fit() { + nodes_.shrink_to_fit(); + edges_.shrink_to_fit(); + } + + // Statistics + void print_statistics() const; + + // Node categorization + std::vector get_nodes_by_type(NodeType type) const; + std::unordered_set get_source_nodes() const; + std::unordered_set get_sink_nodes() const; + std::unordered_set get_ipin_nodes() const; + std::unordered_set get_opin_nodes() const; + + // Edge filtering + std::vector get_preserved_edges(const bool preserve_pin_connections) const; + + // Metadata + void set_tool_info(const std::string& name, const std::string& version, const std::string& comment); + const std::string& get_tool_name() const { return tool_name_; } + const std::string& get_tool_version() const { return tool_version_; } + const std::string& get_tool_comment() const { return tool_comment_; } + + private: + std::vector nodes_; + std::vector edges_; + std::vector channels_; + std::vector xy_lists_; + std::vector switches_; + std::vector segments_; + std::vector block_types_; + std::vector grid_locs_; + + // Lookup maps for efficiency + std::unordered_map node_id_to_index_; + std::unordered_map switch_id_to_index_; + std::unordered_map segment_id_to_index_; + + // Metadata + std::string tool_name_; + std::string tool_version_; + std::string tool_comment_; + + // Helper methods + void update_node_index(NodeId id, size_t index); + void update_switch_index(SwitchId id, size_t index); + void update_segment_index(SegmentId id, size_t index); }; -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp index d338ae8c99..4bdb7b1356 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.cpp @@ -9,7 +9,9 @@ namespace crrgenerator { // DataFrame implementation -DataFrame::DataFrame(size_t rows, size_t cols) : rows_(rows), cols_(cols) { +DataFrame::DataFrame(size_t rows, size_t cols) + : rows_(rows) + , cols_(cols) { data_.resize(rows); for (auto& row : data_) { row.resize(cols); @@ -95,9 +97,7 @@ size_t DataFrame::count_non_empty() const { return count; } -size_t DataFrame::count_non_empty_in_range(size_t start_row, size_t start_col, - size_t end_row, - size_t end_col) const { +size_t DataFrame::count_non_empty_in_range(size_t start_row, size_t start_col, size_t end_row, size_t end_col) const { size_t count = 0; for (size_t row = start_row; row < std::min(end_row, rows_); ++row) { for (size_t col = start_col; col < std::min(end_col, cols_); ++col) { @@ -132,7 +132,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { // Get the first worksheet auto worksheet = wb.active_sheet(); std::string sheet_name = worksheet.title(); - + VTR_LOG_DEBUG("Got worksheet: '%s'\n", sheet_name.c_str()); // Get the used range dimensions @@ -145,7 +145,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { // Safety check if (last_row > 10000 || last_col > 1000) { VTR_LOG_ERROR("Excel file too large: %zux%zu (limit: 10000x1000)\n", - last_row, last_col); + last_row, last_col); } if (last_row == 0 || last_col == 0) { @@ -168,7 +168,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { cells_read++; } catch (const std::exception& e) { VTR_LOG_DEBUG("Error reading cell (%zu, %zu): %s\n", row, col, e.what()); - df.at(row - 1, col - 1) = Cell(); // Empty cell + df.at(row - 1, col - 1) = Cell(); // Empty cell } } @@ -180,7 +180,7 @@ DataFrame DataFrameProcessor::read_excel(const std::string& filename) { df.source_file = std::filesystem::path(filename).stem().string(); VTR_LOG_DEBUG("Successfully read Excel file with dimensions: %zux%zu, %zu cells\n", - df.rows(), df.cols(), cells_read); + df.rows(), df.cols(), cells_read); return df; @@ -194,7 +194,7 @@ DataFrame DataFrameProcessor::process_dataframe(DataFrame df, int merge_rows_count, int merge_cols_count) { VTR_LOG_DEBUG("Processing dataframe with merge_rows=%d, merge_cols=%d\n", - merge_rows_count, merge_cols_count); + merge_rows_count, merge_cols_count); // Perform row merging std::vector merged_row_indices = {0, 1}; @@ -206,9 +206,9 @@ DataFrame DataFrameProcessor::process_dataframe(DataFrame df, // Count connections in the data area df.connections = df.count_non_empty_in_range(static_cast(merge_rows_count), - static_cast(merge_cols_count), - df.rows(), - df.cols()); + static_cast(merge_cols_count), + df.rows(), + df.cols()); VTR_LOG_DEBUG("Processed dataframe with %zu connections\n", df.connections); @@ -322,4 +322,4 @@ void DataFrameProcessor::validate_excel_file(const std::string& filename) { } } -} // namespace crrgenerator \ No newline at end of file +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h index 2ad77c9cea..34232879e3 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/data_frame_processor.h @@ -12,7 +12,10 @@ namespace crrgenerator { * @brief Represents a cell in the dataframe */ struct Cell { - enum class Type { EMPTY, STRING, INTEGER, DOUBLE }; + enum class Type { EMPTY, + STRING, + INTEGER, + DOUBLE }; Type type = Type::EMPTY; std::string string_value; @@ -21,9 +24,14 @@ struct Cell { Cell() = default; explicit Cell(const std::string& value) - : type(Type::STRING), string_value(value) {} - explicit Cell(int64_t value) : type(Type::INTEGER), int_value(value) {} - explicit Cell(double value) : type(Type::DOUBLE), double_value(value) {} + : type(Type::STRING) + , string_value(value) {} + explicit Cell(int64_t value) + : type(Type::INTEGER) + , int_value(value) {} + explicit Cell(double value) + : type(Type::DOUBLE) + , double_value(value) {} bool is_empty() const { return type == Type::EMPTY; } bool is_string() const { return type == Type::STRING; } @@ -60,99 +68,102 @@ struct Cell { * containing switch block configuration data. */ class DataFrame { - public: - DataFrame() = default; - DataFrame(size_t rows, size_t cols); - - // Access methods - Cell& at(size_t row, size_t col); - const Cell& at(size_t row, size_t col) const; - Cell& operator()(size_t row, size_t col) { return at(row, col); } - const Cell& operator()(size_t row, size_t col) const { return at(row, col); } - - // Dimensions - size_t rows() const { return rows_; } - size_t cols() const { return cols_; } - std::pair shape() const { return {rows_, cols_}; } - - // Resize operations - void resize(size_t rows, size_t cols); - void clear(); - - // Row/column operations - std::vector get_row(size_t row) const; - std::vector get_column(size_t col) const; - void set_row(size_t row, const std::vector& values); - void set_column(size_t col, const std::vector& values); - - // Statistics and counting - size_t count_non_empty() const; - size_t count_non_empty_in_range(size_t start_row, size_t start_col, - size_t end_row, size_t end_col) const; - - // Iteration support - class RowIterator { - public: - RowIterator(DataFrame* df, size_t row) : df_(df), row_(row) {} - - Cell& operator[](size_t col) { return df_->at(row_, col); } - const Cell& operator[](size_t col) const { return df_->at(row_, col); } - - size_t size() const { return df_->cols(); } - size_t get_row_index() const { return row_; } - - RowIterator& operator++() { - ++row_; - return *this; - } - bool operator!=(const RowIterator& other) const { - return df_ != other.df_ || row_ != other.row_; - } - RowIterator& operator*() { return *this; } - - private: - DataFrame* df_; - size_t row_; - }; - - class ConstRowIterator { - public: - ConstRowIterator(const DataFrame* df, size_t row) : df_(df), row_(row) {} - - const Cell& operator[](size_t col) const { return df_->at(row_, col); } - - size_t size() const { return df_->cols(); } - size_t get_row_index() const { return row_; } - - ConstRowIterator& operator++() { - ++row_; - return *this; - } - bool operator!=(const ConstRowIterator& other) const { - return row_ != other.row_; - } - const ConstRowIterator& operator*() const { return *this; } - - private: - const DataFrame* df_; - size_t row_; - }; - - RowIterator begin() { return RowIterator(this, 0); } - RowIterator end() { return RowIterator(this, rows_); } - ConstRowIterator begin() const { return ConstRowIterator(this, 0); } - ConstRowIterator end() const { return ConstRowIterator(this, rows_); } - - // Metadata - std::string source_file; - size_t connections = 0; - - private: - std::vector> data_; - size_t rows_ = 0; - size_t cols_ = 0; - - void validate_bounds(size_t row, size_t col) const; + public: + DataFrame() = default; + DataFrame(size_t rows, size_t cols); + + // Access methods + Cell& at(size_t row, size_t col); + const Cell& at(size_t row, size_t col) const; + Cell& operator()(size_t row, size_t col) { return at(row, col); } + const Cell& operator()(size_t row, size_t col) const { return at(row, col); } + + // Dimensions + size_t rows() const { return rows_; } + size_t cols() const { return cols_; } + std::pair shape() const { return {rows_, cols_}; } + + // Resize operations + void resize(size_t rows, size_t cols); + void clear(); + + // Row/column operations + std::vector get_row(size_t row) const; + std::vector get_column(size_t col) const; + void set_row(size_t row, const std::vector& values); + void set_column(size_t col, const std::vector& values); + + // Statistics and counting + size_t count_non_empty() const; + size_t count_non_empty_in_range(size_t start_row, size_t start_col, size_t end_row, size_t end_col) const; + + // Iteration support + class RowIterator { + public: + RowIterator(DataFrame* df, size_t row) + : df_(df) + , row_(row) {} + + Cell& operator[](size_t col) { return df_->at(row_, col); } + const Cell& operator[](size_t col) const { return df_->at(row_, col); } + + size_t size() const { return df_->cols(); } + size_t get_row_index() const { return row_; } + + RowIterator& operator++() { + ++row_; + return *this; + } + bool operator!=(const RowIterator& other) const { + return df_ != other.df_ || row_ != other.row_; + } + RowIterator& operator*() { return *this; } + + private: + DataFrame* df_; + size_t row_; + }; + + class ConstRowIterator { + public: + ConstRowIterator(const DataFrame* df, size_t row) + : df_(df) + , row_(row) {} + + const Cell& operator[](size_t col) const { return df_->at(row_, col); } + + size_t size() const { return df_->cols(); } + size_t get_row_index() const { return row_; } + + ConstRowIterator& operator++() { + ++row_; + return *this; + } + bool operator!=(const ConstRowIterator& other) const { + return row_ != other.row_; + } + const ConstRowIterator& operator*() const { return *this; } + + private: + const DataFrame* df_; + size_t row_; + }; + + RowIterator begin() { return RowIterator(this, 0); } + RowIterator end() { return RowIterator(this, rows_); } + ConstRowIterator begin() const { return ConstRowIterator(this, 0); } + ConstRowIterator end() const { return ConstRowIterator(this, rows_); } + + // Metadata + std::string source_file; + size_t connections = 0; + + private: + std::vector> data_; + size_t rows_ = 0; + size_t cols_ = 0; + + void validate_bounds(size_t row, size_t col) const; }; /** @@ -162,45 +173,44 @@ class DataFrame { * operations similar to the Python pandas functionality. */ class DataFrameProcessor { - public: - DataFrameProcessor() = default; - - /** - * @brief Read Excel file and create DataFrame - * @param filename Path to Excel file - * @return DataFrame containing the Excel data - * @throws FileException if file cannot be read - */ - DataFrame read_excel(const std::string& filename); - - /** - * @brief Process DataFrame with merging operations - * @param df DataFrame to process - * @param merge_rows_count Number of rows to merge - * @param merge_cols_count Number of columns to merge - * @return Processed DataFrame - */ - DataFrame process_dataframe(DataFrame df, - int merge_rows_count = NUM_EMPTY_ROWS, - int merge_cols_count = NUM_EMPTY_COLS); - - /** - * @brief Update switch delay min/max based on DataFrame content - * @param df DataFrame to analyze - * @param switch_delay_max_ps Current maximum switch delay (will be updated) - * @param switch_delay_min_ps Current minimum switch delay (will be updated) - */ - void update_switch_delays(const DataFrame& df, int& switch_delay_max_ps, - int& switch_delay_min_ps); - - private: - // Excel parsing helpers - Cell parse_excel_cell(const xlnt::cell& cell); - void merge_rows(DataFrame& df, const std::vector& merge_row_indices); - void merge_columns(DataFrame& df, const std::vector& merge_col_indices); - - // Validation - void validate_excel_file(const std::string& filename); + public: + DataFrameProcessor() = default; + + /** + * @brief Read Excel file and create DataFrame + * @param filename Path to Excel file + * @return DataFrame containing the Excel data + * @throws FileException if file cannot be read + */ + DataFrame read_excel(const std::string& filename); + + /** + * @brief Process DataFrame with merging operations + * @param df DataFrame to process + * @param merge_rows_count Number of rows to merge + * @param merge_cols_count Number of columns to merge + * @return Processed DataFrame + */ + DataFrame process_dataframe(DataFrame df, + int merge_rows_count = NUM_EMPTY_ROWS, + int merge_cols_count = NUM_EMPTY_COLS); + + /** + * @brief Update switch delay min/max based on DataFrame content + * @param df DataFrame to analyze + * @param switch_delay_max_ps Current maximum switch delay (will be updated) + * @param switch_delay_min_ps Current minimum switch delay (will be updated) + */ + void update_switch_delays(const DataFrame& df, int& switch_delay_max_ps, int& switch_delay_min_ps); + + private: + // Excel parsing helpers + Cell parse_excel_cell(const xlnt::cell& cell); + void merge_rows(DataFrame& df, const std::vector& merge_row_indices); + void merge_columns(DataFrame& df, const std::vector& merge_col_indices); + + // Validation + void validate_excel_file(const std::string& filename); }; -} // namespace crrgenerator \ No newline at end of file +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index 0617c9ed39..37bbe6b96e 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -5,189 +5,189 @@ namespace crrgenerator { -NodeLookupManager::NodeLookupManager() : fpga_grid_x_(0), fpga_grid_y_(0) {} - -void NodeLookupManager::initialize(const RRGraph& graph, Coordinate fpga_grid_x, - Coordinate fpga_grid_y) { - VTR_LOG("Initializing NodeLookupManager for %d x %d grid with %zu nodes\n", - fpga_grid_x, fpga_grid_y, static_cast(graph.get_node_count())); - - fpga_grid_x_ = fpga_grid_x; - fpga_grid_y_ = fpga_grid_y; - - // Clear existing data - clear(); - - // Initialize lookup structures - column_lookup_.resize(static_cast(fpga_grid_x) + 1); - row_lookup_.resize(static_cast(fpga_grid_y) + 1); - for (int i = 0; i <= fpga_grid_x + 1; i++) { - edge_sink_lookup_.push_back(std::vector>( - static_cast(fpga_grid_y + 2), std::vector())); - } - - // Index all nodes - for (const auto& node : graph.get_nodes()) { - index_node(node); - } - - // Index all edges - for (const auto& edge : graph.get_edges()) { - index_edge(graph, edge); - } - - VTR_LOG("Node lookup manager initialized successfully\n"); - print_statistics(); +NodeLookupManager::NodeLookupManager() + : fpga_grid_x_(0) + , fpga_grid_y_(0) {} + +void NodeLookupManager::initialize(const RRGraph& graph, Coordinate fpga_grid_x, Coordinate fpga_grid_y) { + VTR_LOG("Initializing NodeLookupManager for %d x %d grid with %zu nodes\n", + fpga_grid_x, fpga_grid_y, static_cast(graph.get_node_count())); + + fpga_grid_x_ = fpga_grid_x; + fpga_grid_y_ = fpga_grid_y; + + // Clear existing data + clear(); + + // Initialize lookup structures + column_lookup_.resize(static_cast(fpga_grid_x) + 1); + row_lookup_.resize(static_cast(fpga_grid_y) + 1); + for (int i = 0; i <= fpga_grid_x + 1; i++) { + edge_sink_lookup_.push_back(std::vector>( + static_cast(fpga_grid_y + 2), std::vector())); + } + + // Index all nodes + for (const auto& node : graph.get_nodes()) { + index_node(node); + } + + // Index all edges + for (const auto& edge : graph.get_edges()) { + index_edge(graph, edge); + } + + VTR_LOG("Node lookup manager initialized successfully\n"); + print_statistics(); } const RRNode* NodeLookupManager::get_node_by_hash(const NodeHash& hash) const { - auto it = global_lookup_.find(hash); - return (it != global_lookup_.end()) ? it->second : nullptr; + auto it = global_lookup_.find(hash); + return (it != global_lookup_.end()) ? it->second : nullptr; } const std::unordered_map& NodeLookupManager::get_column_nodes(Coordinate x) const { - if (x <= fpga_grid_x_ && x < static_cast(column_lookup_.size())) { - return column_lookup_[static_cast(x)]; - } - return empty_map_; + if (x <= fpga_grid_x_ && x < static_cast(column_lookup_.size())) { + return column_lookup_[static_cast(x)]; + } + return empty_map_; } const std::unordered_map& NodeLookupManager::get_row_nodes(Coordinate y) const { - if (y <= fpga_grid_y_ && y < static_cast(row_lookup_.size())) { - return row_lookup_[static_cast(y)]; - } - return empty_map_; + if (y <= fpga_grid_y_ && y < static_cast(row_lookup_.size())) { + return row_lookup_[static_cast(y)]; + } + return empty_map_; } std::unordered_map NodeLookupManager::get_combined_nodes(Coordinate x, Coordinate y) const { - std::unordered_map combined; + std::unordered_map combined; - // Add column nodes - const auto& col_nodes = get_column_nodes(x); - combined.insert(col_nodes.begin(), col_nodes.end()); + // Add column nodes + const auto& col_nodes = get_column_nodes(x); + combined.insert(col_nodes.begin(), col_nodes.end()); - // Add row nodes - const auto& row_nodes = get_row_nodes(y); - combined.insert(row_nodes.begin(), row_nodes.end()); + // Add row nodes + const auto& row_nodes = get_row_nodes(y); + combined.insert(row_nodes.begin(), row_nodes.end()); - return combined; + return combined; } std::vector NodeLookupManager::get_nodes_by_type( NodeType type) const { - auto it = type_lookup_.find(type); - return (it != type_lookup_.end()) ? it->second : std::vector{}; + auto it = type_lookup_.find(type); + return (it != type_lookup_.end()) ? it->second : std::vector{}; } const std::vector NodeLookupManager::get_sink_edges_at_location(Coordinate x, Coordinate y) const { - return edge_sink_lookup_[static_cast(x)][static_cast(y)]; + return edge_sink_lookup_[static_cast(x)][static_cast(y)]; } bool NodeLookupManager::is_valid_coordinate(Coordinate x, Coordinate y) const { - return x >= 0 && x <= fpga_grid_x_ && y >= 0 && y <= fpga_grid_y_; + return x >= 0 && x <= fpga_grid_x_ && y >= 0 && y <= fpga_grid_y_; } void NodeLookupManager::print_statistics() const { - VTR_LOG("=== Node Lookup Manager Statistics ===\n"); - VTR_LOG("Grid dimensions: %d x %d\n", fpga_grid_x_, fpga_grid_y_); - VTR_LOG("Total nodes indexed: %zu\n", global_lookup_.size()); - - // Count nodes by type - for (const auto& [type, nodes] : type_lookup_) { - VTR_LOG(" %s nodes: %zu\n", to_string(type).c_str(), nodes.size()); - } - - // Count nodes per column - std::vector col_counts; - for (const auto& col_map : column_lookup_) { - col_counts.push_back(col_map.size()); - } - - if (!col_counts.empty()) { - auto [min_col, max_col] = - std::minmax_element(col_counts.begin(), col_counts.end()); - VTR_LOG("Nodes per column: min=%d, max=%d, avg=%f\n", *min_col, *max_col, - std::accumulate(col_counts.begin(), col_counts.end(), 0.0) / col_counts.size()); - } - - // Count nodes per row - std::vector row_counts; - for (const auto& row_map : row_lookup_) { - row_counts.push_back(row_map.size()); - } - - if (!row_counts.empty()) { - auto [min_row, max_row] = - std::minmax_element(row_counts.begin(), row_counts.end()); - VTR_LOG("Nodes per row: min=%d, max=%d, avg=%f\n", *min_row, *max_row, - *max_row, - std::accumulate(row_counts.begin(), row_counts.end(), 0.0) / row_counts.size()); - } + VTR_LOG("=== Node Lookup Manager Statistics ===\n"); + VTR_LOG("Grid dimensions: %d x %d\n", fpga_grid_x_, fpga_grid_y_); + VTR_LOG("Total nodes indexed: %zu\n", global_lookup_.size()); + + // Count nodes by type + for (const auto& [type, nodes] : type_lookup_) { + VTR_LOG(" %s nodes: %zu\n", to_string(type).c_str(), nodes.size()); + } + + // Count nodes per column + std::vector col_counts; + for (const auto& col_map : column_lookup_) { + col_counts.push_back(col_map.size()); + } + + if (!col_counts.empty()) { + auto [min_col, max_col] = + std::minmax_element(col_counts.begin(), col_counts.end()); + VTR_LOG("Nodes per column: min=%d, max=%d, avg=%f\n", *min_col, *max_col, + std::accumulate(col_counts.begin(), col_counts.end(), 0.0) / col_counts.size()); + } + + // Count nodes per row + std::vector row_counts; + for (const auto& row_map : row_lookup_) { + row_counts.push_back(row_map.size()); + } + + if (!row_counts.empty()) { + auto [min_row, max_row] = + std::minmax_element(row_counts.begin(), row_counts.end()); + VTR_LOG("Nodes per row: min=%d, max=%d, avg=%f\n", *min_row, *max_row, + *max_row, + std::accumulate(row_counts.begin(), row_counts.end(), 0.0) / row_counts.size()); + } } void NodeLookupManager::clear() { - column_lookup_.clear(); - row_lookup_.clear(); - global_lookup_.clear(); - type_lookup_.clear(); + column_lookup_.clear(); + row_lookup_.clear(); + global_lookup_.clear(); + type_lookup_.clear(); } NodeHash NodeLookupManager::build_node_hash(const RRNode& node) const { - return std::make_tuple(node.get_type(), node.get_ptc(), - node.get_location().x_low, node.get_location().x_high, - node.get_location().y_low, node.get_location().y_high); + return std::make_tuple(node.get_type(), node.get_ptc(), + node.get_location().x_low, node.get_location().x_high, + node.get_location().y_low, node.get_location().y_high); } void NodeLookupManager::index_node(const RRNode& node) { - NodeHash hash = build_node_hash(node); - const RRNode* node_ptr = &node; + NodeHash hash = build_node_hash(node); + const RRNode* node_ptr = &node; - // Add to global lookup - global_lookup_[hash] = node_ptr; + // Add to global lookup + global_lookup_[hash] = node_ptr; - // Add to type lookup - type_lookup_[node.get_type()].push_back(node_ptr); + // Add to type lookup + type_lookup_[node.get_type()].push_back(node_ptr); - const Location& loc = node.get_location(); + const Location& loc = node.get_location(); - VTR_ASSERT(loc.x_low <= fpga_grid_x_); - VTR_ASSERT(loc.x_high <= fpga_grid_x_); - VTR_ASSERT(loc.y_low <= fpga_grid_y_); - VTR_ASSERT(loc.y_high <= fpga_grid_y_); + VTR_ASSERT(loc.x_low <= fpga_grid_x_); + VTR_ASSERT(loc.x_high <= fpga_grid_x_); + VTR_ASSERT(loc.y_low <= fpga_grid_y_); + VTR_ASSERT(loc.y_high <= fpga_grid_y_); - // Skip spatial indexing for source/sink nodes - if (node.get_type() == NodeType::SOURCE || - node.get_type() == NodeType::SINK) { - return; - } + // Skip spatial indexing for source/sink nodes + if (node.get_type() == NodeType::SOURCE || node.get_type() == NodeType::SINK) { + return; + } - // Add to column lookup (for single-column nodes) - if (loc.x_low == loc.x_high) { - column_lookup_[static_cast(loc.x_low)][hash] = node_ptr; - } + // Add to column lookup (for single-column nodes) + if (loc.x_low == loc.x_high) { + column_lookup_[static_cast(loc.x_low)][hash] = node_ptr; + } - // Add to row lookup (for single-row nodes) - if (loc.y_low == loc.y_high) { - row_lookup_[static_cast(loc.y_low)][hash] = node_ptr; - } + // Add to row lookup (for single-row nodes) + if (loc.y_low == loc.y_high) { + row_lookup_[static_cast(loc.y_low)][hash] = node_ptr; + } } void NodeLookupManager::index_edge(const RRGraph& graph, const RREdge& edge) { - const RRNode* sink = graph.get_node(edge.get_sink_node()); + const RRNode* sink = graph.get_node(edge.get_sink_node()); - VTR_ASSERT(sink->get_location().x_high >= 0); - VTR_ASSERT(sink->get_location().y_high >= 0); + VTR_ASSERT(sink->get_location().x_high >= 0); + VTR_ASSERT(sink->get_location().y_high >= 0); - VTR_ASSERT(sink->get_location().x_high <= fpga_grid_x_); - VTR_ASSERT(sink->get_location().y_high <= fpga_grid_y_); + VTR_ASSERT(sink->get_location().x_high <= fpga_grid_x_); + VTR_ASSERT(sink->get_location().y_high <= fpga_grid_y_); - // Add to edge lookup - edge_sink_lookup_[static_cast(sink->get_location().x_low)] - [static_cast(sink->get_location().y_low)].push_back(&edge); + // Add to edge lookup + edge_sink_lookup_[static_cast(sink->get_location().x_low)] + [static_cast(sink->get_location().y_low)] + .push_back(&edge); } - -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h index ec243bf542..f433b00cb4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h @@ -12,112 +12,112 @@ namespace crrgenerator { * by coordinates, type, and other attributes. */ class NodeLookupManager { - public: - NodeLookupManager(); - - /** - * @brief Initialize lookup tables from RR graph - * @param graph RR graph to index - * @param fpga_grid_x Maximum X coordinate - * @param fpga_grid_y Maximum Y coordinate - */ - void initialize(const RRGraph& graph, Coordinate fpga_grid_x, - Coordinate fpga_grid_y); - - /** - * @brief Get node by hash key - * @param hash Node hash tuple - * @return Pointer to node or nullptr if not found - */ - const RRNode* get_node_by_hash(const NodeHash& hash) const; - - /** - * @brief Get nodes in a specific column - * @param x Column coordinate - * @return Map of hash to node for nodes in column - */ - const std::unordered_map& - get_column_nodes(Coordinate x) const; - - /** - * @brief Get nodes in a specific row - * @param y Row coordinate - * @return Map of hash to node for nodes in row - */ - const std::unordered_map& get_row_nodes( - Coordinate y) const; - - /** - * @brief Get combined nodes for column and row (for switch block processing) - * @param x Column coordinate - * @param y Row coordinate - * @return Combined map of nodes - */ - std::unordered_map get_combined_nodes( - Coordinate x, Coordinate y) const; - - /** - * @brief Get all nodes by type - * @param type Node type to filter - * @return Vector of nodes of specified type - */ - std::vector get_nodes_by_type(NodeType type) const; - - /** - * @brief Get sink edge at location - * @param x X coordinate - * @param y Y coordinate - * @return Edges which sinks are in the given location - */ - const std::vector get_sink_edges_at_location(Coordinate x, Coordinate y) const; - - /** - * @brief Check if coordinate is valid - * @param x X coordinate - * @param y Y coordinate - * @return true if coordinates are within grid bounds - */ - bool is_valid_coordinate(Coordinate x, Coordinate y) const; - - /** - * @brief Print lookup statistics - */ - void print_statistics() const; - - /** - * @brief Clear all lookup tables - */ - void clear(); - - private: - // Spatial indexes - SINK and SOURCE nodes are not stored in these two maps - std::vector> - column_lookup_; - std::vector> - row_lookup_; - - // Edge spatial indexes. [x][y] -> std::vector - std::vector>> edge_sink_lookup_; - - // Global lookup - Return a pointer to the node corresponding to the hash - std::unordered_map global_lookup_; - - // Type-based lookup - Return a vector of pointers to nodes of the specified - // type - std::unordered_map> type_lookup_; - - // Grid dimensions - Coordinate fpga_grid_x_; - Coordinate fpga_grid_y_; - - // Empty map for invalid coordinates - std::unordered_map empty_map_; - - // Helper methods - NodeHash build_node_hash(const RRNode& node) const; - void validate_coordinates(Coordinate x, Coordinate y) const; - void index_node(const RRNode& node); - void index_edge(const RRGraph& graph, const RREdge& edge); + public: + NodeLookupManager(); + + /** + * @brief Initialize lookup tables from RR graph + * @param graph RR graph to index + * @param fpga_grid_x Maximum X coordinate + * @param fpga_grid_y Maximum Y coordinate + */ + void initialize(const RRGraph& graph, Coordinate fpga_grid_x, Coordinate fpga_grid_y); + + /** + * @brief Get node by hash key + * @param hash Node hash tuple + * @return Pointer to node or nullptr if not found + */ + const RRNode* get_node_by_hash(const NodeHash& hash) const; + + /** + * @brief Get nodes in a specific column + * @param x Column coordinate + * @return Map of hash to node for nodes in column + */ + const std::unordered_map& + get_column_nodes(Coordinate x) const; + + /** + * @brief Get nodes in a specific row + * @param y Row coordinate + * @return Map of hash to node for nodes in row + */ + const std::unordered_map& get_row_nodes( + Coordinate y) const; + + /** + * @brief Get combined nodes for column and row (for switch block processing) + * @param x Column coordinate + * @param y Row coordinate + * @return Combined map of nodes + */ + std::unordered_map get_combined_nodes( + Coordinate x, + Coordinate y) const; + + /** + * @brief Get all nodes by type + * @param type Node type to filter + * @return Vector of nodes of specified type + */ + std::vector get_nodes_by_type(NodeType type) const; + + /** + * @brief Get sink edge at location + * @param x X coordinate + * @param y Y coordinate + * @return Edges which sinks are in the given location + */ + const std::vector get_sink_edges_at_location(Coordinate x, Coordinate y) const; + + /** + * @brief Check if coordinate is valid + * @param x X coordinate + * @param y Y coordinate + * @return true if coordinates are within grid bounds + */ + bool is_valid_coordinate(Coordinate x, Coordinate y) const; + + /** + * @brief Print lookup statistics + */ + void print_statistics() const; + + /** + * @brief Clear all lookup tables + */ + void clear(); + + private: + // Spatial indexes - SINK and SOURCE nodes are not stored in these two maps + std::vector> + column_lookup_; + std::vector> + row_lookup_; + + // Edge spatial indexes. [x][y] -> std::vector + std::vector>> edge_sink_lookup_; + + // Global lookup - Return a pointer to the node corresponding to the hash + std::unordered_map global_lookup_; + + // Type-based lookup - Return a vector of pointers to nodes of the specified + // type + std::unordered_map> type_lookup_; + + // Grid dimensions + Coordinate fpga_grid_x_; + Coordinate fpga_grid_y_; + + // Empty map for invalid coordinates + std::unordered_map empty_map_; + + // Helper methods + NodeHash build_node_hash(const RRNode& node) const; + void validate_coordinates(Coordinate x, Coordinate y) const; + void index_node(const RRNode& node); + void index_edge(const RRGraph& graph, const RREdge& edge); }; -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp index be8013e441..486840d71c 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -1,5 +1,5 @@ -#include // for std::ostringstream -#include // for std::setprecision and std::scientific +#include // for std::ostringstream +#include // for std::setprecision and std::scientific #include "xml_handler.h" @@ -9,584 +9,607 @@ namespace crrgenerator { inline void xml_escape_and_write(std::ostream& os, const std::string& s) { - for (char c : s) { - switch (c) { - case '&': os << "&"; break; - case '<': os << "<"; break; - case '>': os << ">"; break; - case '"': os << """; break; - case '\'': os << "'"; break; - default: os << c; break; + for (char c : s) { + switch (c) { + case '&': + os << "&"; + break; + case '<': + os << "<"; + break; + case '>': + os << ">"; + break; + case '"': + os << """; + break; + case '\'': + os << "'"; + break; + default: + os << c; + break; + } } - } } inline void write_attr(std::ostream& os, const char* name, const std::string& v) { - os << ' ' << name << "=\""; xml_escape_and_write(os, v); os << '"'; + os << ' ' << name << "=\""; + xml_escape_and_write(os, v); + os << '"'; } -template +template inline void write_attr(std::ostream& os, const char* name, T v) { - os << ' ' << name << "=\"" << v << '"'; + os << ' ' << name << "=\"" << v << '"'; } XMLHandler::XMLHandler() { setup_attribute_mapping(); } void XMLHandler::setup_attribute_mapping() { - attribute_map_ = {{"x_max", "xMax"}, - {"x_min", "xMin"}, - {"y_max", "yMax"}, - {"y_min", "yMin"}, - {"res_type", "resType"}, - {"chan_width_max", "chanWidthMax"}, - {"buf_size", "bufSize"}, - {"mux_trans_size", "muxTransSize"}, - {"C_per_meter", "cPerMeter"}, - {"R_per_meter", "rPerMeter"}, - {"block_type_id", "blockTypeId"}, - {"height_offset", "heightOffset"}, - {"width_offset", "widthOffset"}, - {"C", "c"}, - {"R", "r"}, - {"Cinternal", "cinternal"}, - {"Cin", "cin"}, - {"Cout", "cout"}, - {"Tdel", "tdel"}, - {"src_node", "srcNode"}, - {"sink_node", "sinkNode"}, - {"switch_id", "switchId"}, - {"segment_id", "segmentId"}}; + attribute_map_ = {{"x_max", "xMax"}, + {"x_min", "xMin"}, + {"y_max", "yMax"}, + {"y_min", "yMin"}, + {"res_type", "resType"}, + {"chan_width_max", "chanWidthMax"}, + {"buf_size", "bufSize"}, + {"mux_trans_size", "muxTransSize"}, + {"C_per_meter", "cPerMeter"}, + {"R_per_meter", "rPerMeter"}, + {"block_type_id", "blockTypeId"}, + {"height_offset", "heightOffset"}, + {"width_offset", "widthOffset"}, + {"C", "c"}, + {"R", "r"}, + {"Cinternal", "cinternal"}, + {"Cin", "cin"}, + {"Cout", "cout"}, + {"Tdel", "tdel"}, + {"src_node", "srcNode"}, + {"sink_node", "sinkNode"}, + {"switch_id", "switchId"}, + {"segment_id", "segmentId"}}; } std::unique_ptr XMLHandler::read_rr_graph( const std::string& filename) { - VTR_LOG("Reading RR graph from: %s\n", filename.c_str()); - - pugi::xml_document doc; - pugi::xml_parse_result result = doc.load_file(filename.c_str(), - pugi::parse_default); - - if (!result) { - std::ifstream in(filename); - std::string line; - size_t pos = 0; - int lineno = 1; - while (std::getline(in, line)) { - if (pos + line.size() + 1 > static_cast(result.offset)) { - VTR_LOG("Parse error at line %d near: %s\n", lineno, line.c_str()); - break; + VTR_LOG("Reading RR graph from: %s\n", filename.c_str()); + + pugi::xml_document doc; + pugi::xml_parse_result result = doc.load_file(filename.c_str(), + pugi::parse_default); + + if (!result) { + std::ifstream in(filename); + std::string line; + size_t pos = 0; + int lineno = 1; + while (std::getline(in, line)) { + if (pos + line.size() + 1 > static_cast(result.offset)) { + VTR_LOG("Parse error at line %d near: %s\n", lineno, line.c_str()); + break; + } + pos += line.size() + 1; + lineno++; } - pos += line.size() + 1; - lineno++; - } - VTR_LOG_ERROR("Failed to parse XML file %s: %s (at byte offset %zu)\n", filename.c_str(), - result.description(), result.offset); - } + VTR_LOG_ERROR("Failed to parse XML file %s: %s (at byte offset %zu)\n", filename.c_str(), + result.description(), result.offset); + } - validate_xml_structure(doc); + validate_xml_structure(doc); - auto graph = std::make_unique(); - pugi::xml_node root = doc.child("rr_graph"); + auto graph = std::make_unique(); + pugi::xml_node root = doc.child("rr_graph"); - // Parse tool information - parse_tool_info(root, *graph); + // Parse tool information + parse_tool_info(root, *graph); - // Parse main sections - if (auto channels = root.child("channels")) { - parse_channels(channels, *graph); - } + // Parse main sections + if (auto channels = root.child("channels")) { + parse_channels(channels, *graph); + } - if (auto switches = root.child("switches")) { - parse_switches(switches, *graph); - } + if (auto switches = root.child("switches")) { + parse_switches(switches, *graph); + } - if (auto segments = root.child("segments")) { - parse_segments(segments, *graph); - } + if (auto segments = root.child("segments")) { + parse_segments(segments, *graph); + } - if (auto block_types = root.child("block_types")) { - parse_block_types(block_types, *graph); - } + if (auto block_types = root.child("block_types")) { + parse_block_types(block_types, *graph); + } - if (auto grids = root.child("grid")) { - parse_grid(grids, *graph); - } + if (auto grids = root.child("grid")) { + parse_grid(grids, *graph); + } - if (auto rr_nodes = root.child("rr_nodes")) { - parse_nodes(rr_nodes, *graph); - } + if (auto rr_nodes = root.child("rr_nodes")) { + parse_nodes(rr_nodes, *graph); + } - if (auto rr_edges = root.child("rr_edges")) { - parse_edges(rr_edges, *graph); - } + if (auto rr_edges = root.child("rr_edges")) { + parse_edges(rr_edges, *graph); + } - graph->print_statistics(); - VTR_LOG("Successfully loaded RR graph from %s\n", filename.c_str()); + graph->print_statistics(); + VTR_LOG("Successfully loaded RR graph from %s\n", filename.c_str()); - return graph; + return graph; } void XMLHandler::write_rr_graph(const std::string& filename, - const RRGraph& graph) { - VTR_LOG("Writing RR graph to: %s\n", filename.c_str()); - - std::string temp_filename = filename + ".tmp"; - std::vector out_buf(100 * 1024 * 1024); - std::ofstream out; - out.rdbuf()->pubsetbuf(out_buf.data(), static_cast(out_buf.size())); - out.open(temp_filename, std::ios::out | std::ios::binary); - if (!out) { - VTR_LOG_ERROR("Failed to open output file: %s\n", temp_filename.c_str()); - } - - out << "\n"; - out << "\n"; - - write_channels(out, graph); - write_switches(out, graph); - write_segments(out, graph); - write_block_types(out, graph); - write_grid(out, graph); - write_nodes(out, graph); - write_edges(out, graph); - - out << "\n"; - out.close(); - - if (std::rename(temp_filename.c_str(), filename.c_str()) != 0) { - std::remove(temp_filename.c_str()); - VTR_LOG_ERROR("Failed to atomically replace XML file: %s\n", filename.c_str()); - } - - VTR_LOG("Successfully wrote RR graph to %s\n", filename.c_str()); + const RRGraph& graph) { + VTR_LOG("Writing RR graph to: %s\n", filename.c_str()); + + std::string temp_filename = filename + ".tmp"; + std::vector out_buf(100 * 1024 * 1024); + std::ofstream out; + out.rdbuf()->pubsetbuf(out_buf.data(), static_cast(out_buf.size())); + out.open(temp_filename, std::ios::out | std::ios::binary); + if (!out) { + VTR_LOG_ERROR("Failed to open output file: %s\n", temp_filename.c_str()); + } + + out << "\n"; + out << "\n"; + + write_channels(out, graph); + write_switches(out, graph); + write_segments(out, graph); + write_block_types(out, graph); + write_grid(out, graph); + write_nodes(out, graph); + write_edges(out, graph); + + out << "\n"; + out.close(); + + if (std::rename(temp_filename.c_str(), filename.c_str()) != 0) { + std::remove(temp_filename.c_str()); + VTR_LOG_ERROR("Failed to atomically replace XML file: %s\n", filename.c_str()); + } + + VTR_LOG("Successfully wrote RR graph to %s\n", filename.c_str()); } void XMLHandler::parse_tool_info(const pugi::xml_node& root, RRGraph& graph) { - std::string tool_name = root.attribute("tool_name").as_string(); - std::string tool_version = root.attribute("tool_version").as_string(); - std::string tool_comment = root.attribute("tool_comment").as_string(); + std::string tool_name = root.attribute("tool_name").as_string(); + std::string tool_version = root.attribute("tool_version").as_string(); + std::string tool_comment = root.attribute("tool_comment").as_string(); - graph.set_tool_info(tool_name, tool_version, tool_comment); + graph.set_tool_info(tool_name, tool_version, tool_comment); } void XMLHandler::parse_channels(const pugi::xml_node& channels_node, RRGraph& graph) { - for (pugi::xml_node channel_node : channels_node.children("channel")) { - Channel channel = parse_channel(channel_node); - graph.add_channel(channel); - } - for (pugi::xml_node channel_node : channels_node.children("x_list")) { - XYList xy_list = parse_xy_list(channel_node); - graph.add_xy_list(xy_list); - } - for (pugi::xml_node channel_node : channels_node.children("y_list")) { - XYList xy_list = parse_xy_list(channel_node); - graph.add_xy_list(xy_list); - } - VTR_LOG_DEBUG("Parsed %zu channels\n", graph.get_channel_count()); + for (pugi::xml_node channel_node : channels_node.children("channel")) { + Channel channel = parse_channel(channel_node); + graph.add_channel(channel); + } + for (pugi::xml_node channel_node : channels_node.children("x_list")) { + XYList xy_list = parse_xy_list(channel_node); + graph.add_xy_list(xy_list); + } + for (pugi::xml_node channel_node : channels_node.children("y_list")) { + XYList xy_list = parse_xy_list(channel_node); + graph.add_xy_list(xy_list); + } + VTR_LOG_DEBUG("Parsed %zu channels\n", graph.get_channel_count()); } Channel XMLHandler::parse_channel(const pugi::xml_node& channel_node) { - int max_width = channel_node.attribute("chan_width_max").as_int(); - int x_max = channel_node.attribute("x_max").as_int(); - int x_min = channel_node.attribute("x_min").as_int(); - int y_max = channel_node.attribute("y_max").as_int(); - int y_min = channel_node.attribute("y_min").as_int(); + int max_width = channel_node.attribute("chan_width_max").as_int(); + int x_max = channel_node.attribute("x_max").as_int(); + int x_min = channel_node.attribute("x_min").as_int(); + int y_max = channel_node.attribute("y_max").as_int(); + int y_min = channel_node.attribute("y_min").as_int(); - return Channel(max_width, x_max, x_min, y_max, y_min); + return Channel(max_width, x_max, x_min, y_max, y_min); } XYList XMLHandler::parse_xy_list(const pugi::xml_node& xy_list_node) { - XYList::Type type = XYList::Type::INVALID_LIST; - if (std::string(xy_list_node.name()) == "x_list") { - type = XYList::Type::X_LIST; - } else { - VTR_ASSERT(std::string(xy_list_node.name()) == "y_list"); - type = XYList::Type::Y_LIST; - } - int index = xy_list_node.attribute("index").as_int(); - int info = xy_list_node.attribute("info").as_int(); - return XYList(type, index, info); + XYList::Type type = XYList::Type::INVALID_LIST; + if (std::string(xy_list_node.name()) == "x_list") { + type = XYList::Type::X_LIST; + } else { + VTR_ASSERT(std::string(xy_list_node.name()) == "y_list"); + type = XYList::Type::Y_LIST; + } + int index = xy_list_node.attribute("index").as_int(); + int info = xy_list_node.attribute("info").as_int(); + return XYList(type, index, info); } void XMLHandler::parse_switches(const pugi::xml_node& switches_node, RRGraph& graph) { - for (pugi::xml_node switch_node : switches_node.children("switch")) { - Switch switch_obj = parse_switch(switch_node); - graph.add_switch(switch_obj); - } - VTR_LOG_DEBUG("Parsed %zu switches\n", graph.get_switch_count()); + for (pugi::xml_node switch_node : switches_node.children("switch")) { + Switch switch_obj = parse_switch(switch_node); + graph.add_switch(switch_obj); + } + VTR_LOG_DEBUG("Parsed %zu switches\n", graph.get_switch_count()); } Switch XMLHandler::parse_switch(const pugi::xml_node& switch_xml) { - SwitchId id = switch_xml.attribute("id").as_int(); - std::string name = switch_xml.attribute("name").as_string(); - std::string type = switch_xml.attribute("type").as_string(); + SwitchId id = switch_xml.attribute("id").as_int(); + std::string name = switch_xml.attribute("name").as_string(); + std::string type = switch_xml.attribute("type").as_string(); - Timing timing; - if (auto timing_node = switch_xml.child("timing")) { - timing = parse_timing(timing_node); - } + Timing timing; + if (auto timing_node = switch_xml.child("timing")) { + timing = parse_timing(timing_node); + } - Sizing sizing; - if (auto sizing_node = switch_xml.child("sizing")) { - sizing = parse_sizing(sizing_node); - } + Sizing sizing; + if (auto sizing_node = switch_xml.child("sizing")) { + sizing = parse_sizing(sizing_node); + } - return Switch(id, name, type, timing, sizing); + return Switch(id, name, type, timing, sizing); } Timing XMLHandler::parse_timing(const pugi::xml_node& timing_xml) { - return Timing(timing_xml.attribute("Cin").as_float(), - timing_xml.attribute("Tdel").as_float()); + return Timing(timing_xml.attribute("Cin").as_float(), + timing_xml.attribute("Tdel").as_float()); } Sizing XMLHandler::parse_sizing(const pugi::xml_node& sizing_xml) { - return Sizing(sizing_xml.attribute("mux_trans_size").as_float(), - sizing_xml.attribute("buf_size").as_float()); + return Sizing(sizing_xml.attribute("mux_trans_size").as_float(), + sizing_xml.attribute("buf_size").as_float()); } void XMLHandler::parse_segments(const pugi::xml_node& segments_node, RRGraph& graph) { - for (pugi::xml_node segment_node : segments_node.children("segment")) { - Segment segment = parse_segment(segment_node); - graph.add_segment(segment); - } - VTR_LOG_DEBUG("Parsed %zu segments\n", graph.get_segment_count()); + for (pugi::xml_node segment_node : segments_node.children("segment")) { + Segment segment = parse_segment(segment_node); + graph.add_segment(segment); + } + VTR_LOG_DEBUG("Parsed %zu segments\n", graph.get_segment_count()); } Segment XMLHandler::parse_segment(const pugi::xml_node& segment_xml) { - SegmentId id = segment_xml.attribute("id").as_int(); - std::string name = segment_xml.attribute("name").as_string(); - int length = -1; - if (segment_xml.attribute("length")) { - length = segment_xml.attribute("length").as_int(); - } - std::string res_type = ""; - if (segment_xml.attribute("res_type")) { - res_type = segment_xml.attribute("res_type").as_string(); - } - return Segment(id, name, length, res_type); + SegmentId id = segment_xml.attribute("id").as_int(); + std::string name = segment_xml.attribute("name").as_string(); + int length = -1; + if (segment_xml.attribute("length")) { + length = segment_xml.attribute("length").as_int(); + } + std::string res_type = ""; + if (segment_xml.attribute("res_type")) { + res_type = segment_xml.attribute("res_type").as_string(); + } + return Segment(id, name, length, res_type); } void XMLHandler::parse_block_types(const pugi::xml_node& block_types_node, RRGraph& graph) { - for (pugi::xml_node block_type_node : - block_types_node.children("block_type")) { - BlockType block_type = parse_block_type(block_type_node); - graph.add_block_type(block_type); - } - VTR_LOG_DEBUG("Parsed %zu block types\n", graph.get_block_type_count()); + for (pugi::xml_node block_type_node : + block_types_node.children("block_type")) { + BlockType block_type = parse_block_type(block_type_node); + graph.add_block_type(block_type); + } + VTR_LOG_DEBUG("Parsed %zu block types\n", graph.get_block_type_count()); } BlockType XMLHandler::parse_block_type(const pugi::xml_node& block_type_node) { - int id = block_type_node.attribute("id").as_int(); - std::string name = block_type_node.attribute("name").as_string(); - int height = block_type_node.attribute("height").as_int(); - int width = block_type_node.attribute("width").as_int(); - std::vector pin_classes; - for (pugi::xml_node pin_class_node : block_type_node.children("pin_class")) { - PinClass pin_class = parse_pin_class(pin_class_node); - pin_classes.push_back(pin_class); - } - return BlockType(id, name, height, width, pin_classes); + int id = block_type_node.attribute("id").as_int(); + std::string name = block_type_node.attribute("name").as_string(); + int height = block_type_node.attribute("height").as_int(); + int width = block_type_node.attribute("width").as_int(); + std::vector pin_classes; + for (pugi::xml_node pin_class_node : block_type_node.children("pin_class")) { + PinClass pin_class = parse_pin_class(pin_class_node); + pin_classes.push_back(pin_class); + } + return BlockType(id, name, height, width, pin_classes); } PinClass XMLHandler::parse_pin_class(const pugi::xml_node& pin_class_node) { - std::string type = pin_class_node.attribute("type").as_string(); - std::vector pins; - for (pugi::xml_node pin_node : pin_class_node.children("pin")) { - Pin pin = parse_pin(pin_node); - pins.push_back(pin); - } - return PinClass(type, pins); + std::string type = pin_class_node.attribute("type").as_string(); + std::vector pins; + for (pugi::xml_node pin_node : pin_class_node.children("pin")) { + Pin pin = parse_pin(pin_node); + pins.push_back(pin); + } + return PinClass(type, pins); } Pin XMLHandler::parse_pin(const pugi::xml_node& pin_node) { - int ptc = pin_node.attribute("ptc").as_int(); - std::string value = pin_node.text().get(); - return Pin(ptc, value); + int ptc = pin_node.attribute("ptc").as_int(); + std::string value = pin_node.text().get(); + return Pin(ptc, value); } void XMLHandler::parse_grid(const pugi::xml_node& grids_node, RRGraph& graph) { - for (pugi::xml_node grid_node : grids_node.children("grid_loc")) { - GridLoc grid_loc = parse_grid_loc(grid_node); - graph.add_grid_loc(grid_loc); - } - VTR_LOG_DEBUG("Parsed %zu grid locations\n", graph.get_grid_loc_count()); + for (pugi::xml_node grid_node : grids_node.children("grid_loc")) { + GridLoc grid_loc = parse_grid_loc(grid_node); + graph.add_grid_loc(grid_loc); + } + VTR_LOG_DEBUG("Parsed %zu grid locations\n", graph.get_grid_loc_count()); } GridLoc XMLHandler::parse_grid_loc(const pugi::xml_node& grid_node) { - int type_id = grid_node.attribute("block_type_id").as_int(); - int height_offset = grid_node.attribute("height_offset").as_int(); - int width_offset = grid_node.attribute("width_offset").as_int(); - int x = grid_node.attribute("x").as_int(); - int y = grid_node.attribute("y").as_int(); - int layer = grid_node.attribute("layer").as_int(); - return GridLoc(type_id, height_offset, width_offset, x, y, layer); + int type_id = grid_node.attribute("block_type_id").as_int(); + int height_offset = grid_node.attribute("height_offset").as_int(); + int width_offset = grid_node.attribute("width_offset").as_int(); + int x = grid_node.attribute("x").as_int(); + int y = grid_node.attribute("y").as_int(); + int layer = grid_node.attribute("layer").as_int(); + return GridLoc(type_id, height_offset, width_offset, x, y, layer); } void XMLHandler::parse_nodes(const pugi::xml_node& nodes_node, RRGraph& graph) { - for (pugi::xml_node node_xml : nodes_node.children("node")) { - RRNode node = parse_node(node_xml); - graph.add_node(node); - } - VTR_LOG_DEBUG("Parsed %zu nodes\n", graph.get_node_count()); + for (pugi::xml_node node_xml : nodes_node.children("node")) { + RRNode node = parse_node(node_xml); + graph.add_node(node); + } + VTR_LOG_DEBUG("Parsed %zu nodes\n", graph.get_node_count()); } RRNode XMLHandler::parse_node(const pugi::xml_node& node_xml) { - NodeId id = node_xml.attribute("id").as_int(); - NodeType type = string_to_node_type(node_xml.attribute("type").as_string()); - int capacity = node_xml.attribute("capacity").as_int(); - std::string direction = ""; - if (node_xml.attribute("direction")) { - direction = node_xml.attribute("direction").as_string(); - } + NodeId id = node_xml.attribute("id").as_int(); + NodeType type = string_to_node_type(node_xml.attribute("type").as_string()); + int capacity = node_xml.attribute("capacity").as_int(); + std::string direction = ""; + if (node_xml.attribute("direction")) { + direction = node_xml.attribute("direction").as_string(); + } - Location location; - if (auto loc_node = node_xml.child("loc")) { - location = parse_location(loc_node); - } + Location location; + if (auto loc_node = node_xml.child("loc")) { + location = parse_location(loc_node); + } - NodeTiming timing; - if (auto timing_node = node_xml.child("timing")) { - timing = parse_node_timing(timing_node); - } + NodeTiming timing; + if (auto timing_node = node_xml.child("timing")) { + timing = parse_node_timing(timing_node); + } - NodeSegmentId segment_id; - if (auto segment_node = node_xml.child("segment")) { - segment_id = parse_node_segment(segment_node); - } + NodeSegmentId segment_id; + if (auto segment_node = node_xml.child("segment")) { + segment_id = parse_node_segment(segment_node); + } - return RRNode(id, type, capacity, direction, location, timing, segment_id); + return RRNode(id, type, capacity, direction, location, timing, segment_id); } Location XMLHandler::parse_location(const pugi::xml_node& loc_xml) { - int layer = 0; - if (loc_xml.attribute("layer")) { - layer = loc_xml.attribute("layer").as_int(); - } - std::string side = ""; - if (loc_xml.attribute("side")) { - side = loc_xml.attribute("side").as_string(); - } - return Location( - loc_xml.attribute("xlow").as_int(), loc_xml.attribute("xhigh").as_int(), - loc_xml.attribute("ylow").as_int(), loc_xml.attribute("yhigh").as_int(), - layer, loc_xml.attribute("ptc").as_string(), side); + int layer = 0; + if (loc_xml.attribute("layer")) { + layer = loc_xml.attribute("layer").as_int(); + } + std::string side = ""; + if (loc_xml.attribute("side")) { + side = loc_xml.attribute("side").as_string(); + } + return Location( + loc_xml.attribute("xlow").as_int(), loc_xml.attribute("xhigh").as_int(), + loc_xml.attribute("ylow").as_int(), loc_xml.attribute("yhigh").as_int(), + layer, loc_xml.attribute("ptc").as_string(), side); } NodeTiming XMLHandler::parse_node_timing(const pugi::xml_node& timing_xml) { - return NodeTiming(timing_xml.attribute("R").as_float(), - timing_xml.attribute("C").as_float()); + return NodeTiming(timing_xml.attribute("R").as_float(), + timing_xml.attribute("C").as_float()); } NodeSegmentId XMLHandler::parse_node_segment(const pugi::xml_node& segment_xml) { - return NodeSegmentId(segment_xml.attribute("segment_id").as_int()); + return NodeSegmentId(segment_xml.attribute("segment_id").as_int()); } void XMLHandler::parse_edges(const pugi::xml_node& edges_node, RRGraph& graph) { - for (pugi::xml_node edge_xml : edges_node.children("edge")) { - RREdge edge = parse_edge(edge_xml); - graph.add_edge(edge); - } - VTR_LOG_DEBUG("Parsed %zu edges\n", graph.get_edge_count()); + for (pugi::xml_node edge_xml : edges_node.children("edge")) { + RREdge edge = parse_edge(edge_xml); + graph.add_edge(edge); + } + VTR_LOG_DEBUG("Parsed %zu edges\n", graph.get_edge_count()); } RREdge XMLHandler::parse_edge(const pugi::xml_node& edge_xml) { - NodeId src_node = edge_xml.attribute("src_node").as_int(); - NodeId sink_node = edge_xml.attribute("sink_node").as_int(); - SwitchId switch_id = edge_xml.attribute("switch_id").as_int(); + NodeId src_node = edge_xml.attribute("src_node").as_int(); + NodeId sink_node = edge_xml.attribute("sink_node").as_int(); + SwitchId switch_id = edge_xml.attribute("switch_id").as_int(); - return RREdge(src_node, sink_node, switch_id); + return RREdge(src_node, sink_node, switch_id); } void XMLHandler::write_tool_info(std::ostream& out, const RRGraph& graph) { - if (!graph.get_tool_name().empty()) write_attr(out, "tool_name", graph.get_tool_name()); - if (!graph.get_tool_version().empty()) write_attr(out, "tool_version", graph.get_tool_version()); - if (!graph.get_tool_comment().empty()) write_attr(out, "tool_comment", graph.get_tool_comment()); + if (!graph.get_tool_name().empty()) write_attr(out, "tool_name", graph.get_tool_name()); + if (!graph.get_tool_version().empty()) write_attr(out, "tool_version", graph.get_tool_version()); + if (!graph.get_tool_comment().empty()) write_attr(out, "tool_comment", graph.get_tool_comment()); } void XMLHandler::write_channels(std::ostream& out, const RRGraph& graph) { - out << " \n"; - for (const auto& channel : graph.get_channels()) write_channel(out, channel); - for (const auto& xy_list : graph.get_xy_lists()) write_xy_list(out, xy_list); - out << " \n"; + out << " \n"; + for (const auto& channel : graph.get_channels()) + write_channel(out, channel); + for (const auto& xy_list : graph.get_xy_lists()) + write_xy_list(out, xy_list); + out << " \n"; } void XMLHandler::write_channel(std::ostream& out, const Channel& channel) { - out << " \n"; + out << " \n"; } void XMLHandler::write_xy_list(std::ostream& out, const XYList& xy_list) { - out << " <" << (xy_list.get_type() == XYList::Type::X_LIST ? "x_list" : "y_list"); - write_attr(out, "index", xy_list.get_index()); - write_attr(out, "info", xy_list.get_info()); - out << "/>\n"; + out << " <" << (xy_list.get_type() == XYList::Type::X_LIST ? "x_list" : "y_list"); + write_attr(out, "index", xy_list.get_index()); + write_attr(out, "info", xy_list.get_info()); + out << "/>\n"; } void XMLHandler::write_switches(std::ostream& out, const RRGraph& graph) { - out << " \n"; - for (const auto& s : graph.get_switches()) write_switch(out, s); - out << " \n"; + out << " \n"; + for (const auto& s : graph.get_switches()) + write_switch(out, s); + out << " \n"; } void XMLHandler::write_switch(std::ostream& out, const Switch& s) { - out << " \n"; - out << " \n"; - out << " \n"; - out << " \n"; + out << " \n"; + out << " \n"; + out << " \n"; + out << " \n"; } void XMLHandler::write_segments(std::ostream& out, const RRGraph& graph) { - if (graph.get_segment_count() == 0) return; - out << " \n"; - for (const auto& seg : graph.get_segments()) { - out << " \n"; - } - out << " \n"; + if (graph.get_segment_count() == 0) return; + out << " \n"; + for (const auto& seg : graph.get_segments()) { + out << " \n"; + } + out << " \n"; } void XMLHandler::write_block_types(std::ostream& out, const RRGraph& graph) { - out << " \n"; - for (const auto& bt : graph.get_block_types()) write_block_type(out, bt); - out << " \n"; + out << " \n"; + for (const auto& bt : graph.get_block_types()) + write_block_type(out, bt); + out << " \n"; } void XMLHandler::write_block_type(std::ostream& out, const BlockType& bt) { - out << " \n"; - for (const auto& pc : bt.get_pin_classes()) write_pin_class(out, pc); - out << " \n"; + out << " \n"; + for (const auto& pc : bt.get_pin_classes()) + write_pin_class(out, pc); + out << " \n"; } void XMLHandler::write_pin_class(std::ostream& out, const PinClass& pc) { - out << " \n"; - for (const auto& p : pc.get_pins()) write_pin(out, p); - out << " \n"; + out << " \n"; + for (const auto& p : pc.get_pins()) + write_pin(out, p); + out << " \n"; } void XMLHandler::write_pin(std::ostream& out, const Pin& pin) { - out << " '; - xml_escape_and_write(out, pin.get_value()); - out << "\n"; + out << " '; + xml_escape_and_write(out, pin.get_value()); + out << "\n"; } void XMLHandler::write_grid(std::ostream& out, const RRGraph& graph) { - out << " \n"; - for (const auto& gl : graph.get_grid_locs()) write_grid_loc(out, gl); - out << " \n"; + out << " \n"; + for (const auto& gl : graph.get_grid_locs()) + write_grid_loc(out, gl); + out << " \n"; } void XMLHandler::write_grid_loc(std::ostream& out, const GridLoc& gl) { - out << " \n"; + out << " \n"; } void XMLHandler::write_nodes(std::ostream& out, const RRGraph& graph) { - out << " \n"; - for (const auto& n : graph.get_nodes()) write_node(out, n); - out << " \n"; + out << " \n"; + for (const auto& n : graph.get_nodes()) + write_node(out, n); + out << " \n"; } void XMLHandler::write_node(std::ostream& out, const RRNode& n) { - out << " \n"; - write_location(out, n.get_location()); - write_node_timing(out, n.get_timing()); - if (!n.get_segment().empty()) write_node_segment(out, n.get_segment()); - out << " \n"; + out << " \n"; + write_location(out, n.get_location()); + write_node_timing(out, n.get_timing()); + if (!n.get_segment().empty()) write_node_segment(out, n.get_segment()); + out << " \n"; } void XMLHandler::write_location(std::ostream& out, const Location& loc) { - out << " \n"; + out << " \n"; } void XMLHandler::write_node_timing(std::ostream& out, const NodeTiming& t) { - out << " \n"; + out << " \n"; } void XMLHandler::write_node_segment(std::ostream& out, const NodeSegmentId& seg) { - out << " \n"; + out << " \n"; } void XMLHandler::write_edges(std::ostream& out, const RRGraph& graph) { - out << " \n"; - for (const auto& e : graph.get_edges()) write_edge(out, e); - out << " \n"; + out << " \n"; + for (const auto& e : graph.get_edges()) + write_edge(out, e); + out << " \n"; } void XMLHandler::write_edge(std::ostream& out, const RREdge& e) { - out << " \n"; + out << " \n"; } std::string XMLHandler::format_float_value(double value) { std::ostringstream oss; oss << value; std::string result = oss.str(); - + // Remove trailing .0 for integer values if (result.length() >= 2 && result.ends_with(".0")) { result = result.substr(0, result.length() - 2); } - + // Format scientific notation if (result.find("e-") != std::string::npos) { oss.str(""); @@ -594,20 +617,20 @@ std::string XMLHandler::format_float_value(double value) { oss << std::scientific << std::setprecision(8) << value; result = oss.str(); } - + return result; } void XMLHandler::validate_xml_structure(const pugi::xml_document& doc) { - pugi::xml_node root = doc.child("rr_graph"); - if (!root) { - VTR_LOG_ERROR("Root element 'rr_graph' not found\n"); - } + pugi::xml_node root = doc.child("rr_graph"); + if (!root) { + VTR_LOG_ERROR("Root element 'rr_graph' not found\n"); + } } std::string XMLHandler::map_attribute_name(const std::string& internal_name) { - auto it = attribute_map_.find(internal_name); - return (it != attribute_map_.end()) ? it->second : internal_name; + auto it = attribute_map_.find(internal_name); + return (it != attribute_map_.end()) ? it->second : internal_name; } -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h index 294d3b0d77..20e32150ee 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.h @@ -20,7 +20,7 @@ namespace crrgenerator { * with support for attribute mapping and pretty printing. */ class XMLHandler { -public: + public: XMLHandler(); /** @@ -40,7 +40,7 @@ class XMLHandler { */ void write_rr_graph(const std::string& filename, const RRGraph& graph); - private: + private: // Attribute mapping for XML conversion std::unordered_map attribute_map_; @@ -50,7 +50,7 @@ class XMLHandler { void parse_switches(const pugi::xml_node& switches_node, RRGraph& graph); void parse_segments(const pugi::xml_node& segments_node, RRGraph& graph); void parse_block_types(const pugi::xml_node& block_types_node, - RRGraph& graph); + RRGraph& graph); void parse_grid(const pugi::xml_node& grids_node, RRGraph& graph); void parse_nodes(const pugi::xml_node& nodes_node, RRGraph& graph); void parse_edges(const pugi::xml_node& edges_node, RRGraph& graph); @@ -125,4 +125,4 @@ class XMLHandler { const std::vector& required_children); }; -} // namespace crrgenerator +} // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp index c75fab7489..1e85ddc0cc 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_builder.cpp @@ -248,17 +248,18 @@ void build_tileable_unidir_rr_graph(const std::vector& typ // Add edges that bridge OPINs and IPINs to the rr_graph // Create edges for a tileable rr_graph build_rr_graph_edges(device_ctx.rr_graph, - device_ctx.rr_graph_builder, - rr_node_driver_switches, - grids, vib_grid, 0, - device_chan_width, - segment_inf, segment_inf_x, segment_inf_y, - Fc_in, Fc_out, - sb_type, Fs, sb_subtype, sub_fs, - perimeter_cb, - opin2all_sides, concat_wire, - wire_opposite_side, - delayless_rr_switch); + device_ctx.rr_graph_builder, + rr_node_driver_switches, + crr_opts, + grids, vib_grid, 0, + device_chan_width, + segment_inf, segment_inf_x, segment_inf_y, + Fc_in, Fc_out, + sb_type, Fs, sb_subtype, sub_fs, + perimeter_cb, + opin2all_sides, concat_wire, + wire_opposite_side, + delayless_rr_switch); // Build direction connection lists // TODO: use tile direct builder @@ -272,7 +273,7 @@ void build_tileable_unidir_rr_graph(const std::vector& typ } build_rr_graph_direct_connections(device_ctx.rr_graph, device_ctx.rr_graph_builder, device_ctx.grid, 0, - directs, clb2clb_directs); + directs, clb2clb_directs); // Allocate and load routing resource switches, which are derived from the switches from the architecture file, // based on their fanin in the rr graph. This routine also adjusts the rr nodes to point to these new rr switches diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp index 928203eefe..be9777205e 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp @@ -15,6 +15,8 @@ #include "tileable_rr_graph_gsb.h" #include "tileable_rr_graph_edge_builder.h" +#include "crr_edge_builder.h" + /************************************************************************ * Build the edges for all the SOURCE and SINKs nodes: * 1. create edges between SOURCE and OPINs @@ -314,6 +316,7 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, const bool& opin2all_sides, const bool& concat_wire, const bool& wire_opposite_side) { + bool build_crr_edges = crr_opts.sb_templates.empty(); size_t num_edges_to_create = 0; /* Create edges for SOURCE and SINK nodes for a tileable rr_graph */ build_rr_graph_edges_for_source_nodes(rr_graph, rr_graph_builder, rr_node_driver_switches, grids, layer, num_edges_to_create); @@ -321,6 +324,17 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, vtr::Point gsb_range(grids.width() - 1, grids.height() - 1); + // Building CRR Graph + crrgenerator::SwitchBlockManager sb_manager; + sb_manager.initialize(crr_opts.sb_maps, crr_opts.sb_templates, crr_opts.annotated_rr_graph); + std::unique_ptr crr_input_graph; + crrgenerator::XMLHandler xml_handler; + crr_input_graph = xml_handler.read_rr_graph(det_routing_arch.read_rr_graph_filename); + crrgenerator::NodeLookupManager node_lookup; + node_lookup.initialize(*crr_input_graph, grid.width(), grid.height()); + crrgenerator::CRRGraphGenerator parser(crr_opts, *crr_input_graph, node_lookup, sb_manager, det_routing_arch.write_rr_graph_filename); + parser.run(); + /* Go Switch Block by Switch Block */ for (size_t ix = 0; ix <= gsb_range.x(); ++ix) { for (size_t iy = 0; iy <= gsb_range.y(); ++iy) { @@ -332,24 +346,40 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, device_chan_width, segment_inf_x, segment_inf_y, layer, gsb_coord, perimeter_cb); - /* adapt the track_to_ipin_lookup for the GSB nodes */ t_track2pin_map track2ipin_map; /* [0..track_gsb_side][0..num_tracks][ipin_indices] */ - track2ipin_map = build_gsb_track_to_ipin_map(rr_graph, rr_gsb, grids, segment_inf, Fc_in); - - /* adapt the opin_to_track_map for the GSB nodes */ t_pin2track_map opin2track_map; /* [0..gsb_side][0..num_opin_node][track_indices] */ - opin2track_map = build_gsb_opin_to_track_map(rr_graph, rr_gsb, grids, segment_inf, Fc_out, opin2all_sides); + if (build_crr_edges && !crr_opts.preserve_pin_connections) { + VTR_ASSERT_MSG(false, "Not implemented"); + } else { + /* adapt the track_to_ipin_lookup for the GSB nodes */ + track2ipin_map = build_gsb_track_to_ipin_map(rr_graph, rr_gsb, grids, segment_inf, Fc_in); + + /* adapt the opin_to_track_map for the GSB nodes */ + opin2track_map = build_gsb_opin_to_track_map(rr_graph, rr_gsb, grids, segment_inf, Fc_out, opin2all_sides); + } /* adapt the switch_block_conn for the GSB nodes */ t_track2track_map sb_conn; /* [0..from_gsb_side][0..chan_width-1][track_indices] */ - sb_conn = build_gsb_track_to_track_map(rr_graph, rr_gsb, - sb_type, Fs, sb_subtype, sub_fs, concat_wire, wire_opposite_side, - segment_inf); + if (build_crr_edges) { + sb_conn = build_gsb_crr_track_to_track_map(rr_graph, + rr_gsb, + grids, + segment_inf, + Fc_in, + Fc_out); + } else { + build_gsb_track_to_track_edges(rr_graph_builder, rr_gsb, *parser.get_connection_builder()); + } /* Build edges for a GSB */ - build_edges_for_one_tileable_rr_gsb(rr_graph_builder, rr_gsb, - track2ipin_map, opin2track_map, - sb_conn, rr_node_driver_switches, num_edges_to_create); + build_edges_for_one_tileable_rr_gsb(rr_graph_builder, + rr_gsb, + track2ipin_map, + opin2track_map, + sb_conn, + rr_node_driver_switches, + num_edges_to_create); + /* Finish this GSB, go to the next*/ rr_graph_builder.build_edges(true); } From 327513e7ccdbf6ea806887e42e6e3460ab114638 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Fri, 24 Oct 2025 14:33:27 -0700 Subject: [PATCH 057/120] [vpr][route][crr] fix const function issue in crr_connection_builder --- .../crr_generator/crr_connection_builder.cpp | 87 ++++++------------- .../crr_generator/crr_connection_builder.h | 52 +++++------ 2 files changed, 47 insertions(+), 92 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index cba4468d4a..fab493f1c8 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -187,13 +187,6 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, } } - { - std::lock_guard lock(connections_mutex_); - storage_sw_names_.push_back(sw_name); - storage_source_nodes_.push_back(source_nodes); - storage_sink_nodes_.push_back(sink_nodes); - } - std::sort(tile_connections.begin(), tile_connections.end()); tile_connections.erase(std::unique(tile_connections.begin(), tile_connections.end()), @@ -211,12 +204,8 @@ std::vector CRRConnectionBuilder::get_tile_connections(Coordinate ti return tile_connections; } -std::map CRRConnectionBuilder::get_vertical_nodes( - Coordinate x, - Coordinate y, - const DataFrame& df, - const std::unordered_map& - node_lookup) { +std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& node_lookup) const { std::map source_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; @@ -246,12 +235,8 @@ std::map CRRConnectionBuilder::get_vertical_nodes( return source_nodes; } -std::map CRRConnectionBuilder::get_horizontal_nodes( - Coordinate x, - Coordinate y, - const DataFrame& df, - const std::unordered_map& - node_lookup) { +std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& node_lookup) const { std::map sink_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; @@ -284,10 +269,8 @@ std::map CRRConnectionBuilder::get_horizontal_nodes( return sink_nodes; } -CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info( - const DataFrame& df, - size_t row_or_col, - bool is_vertical) { +CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const DataFrame& df, size_t row_or_col, + bool is_vertical) const { SegmentInfo info; if (is_vertical) { @@ -336,12 +319,8 @@ CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info( return info; } -NodeId CRRConnectionBuilder::process_opin_ipin_node( - const SegmentInfo& info, - Coordinate x, - Coordinate y, - const std::unordered_map& - node_lookup) { +NodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup) const { assert(info.side == Side::OPIN || info.side == Side::IPIN); NodeType node_type = (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; @@ -356,16 +335,10 @@ NodeId CRRConnectionBuilder::process_opin_ipin_node( return 0; } -NodeId CRRConnectionBuilder::process_channel_node( - const SegmentInfo& info, - Coordinate x, - Coordinate y, - const std::unordered_map& node_lookup, - int& prev_seg_index, - Side& prev_side, - std::string& prev_seg_type, - int& prev_ptc_number, - bool is_vertical) { +NodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup, + int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, + bool is_vertical) const { // Check grid boundaries if ((info.side == Side::RIGHT && x == fpga_grid_x_) || (info.side == Side::TOP && y == fpga_grid_y_)) { return 0; @@ -418,17 +391,12 @@ NodeId CRRConnectionBuilder::process_channel_node( } } -void CRRConnectionBuilder::calculate_segment_coordinates( - const SegmentInfo& info, - Coordinate x, - Coordinate y, - Coordinate& x_low, - Coordinate& x_high, - Coordinate& y_low, - Coordinate& y_high, - int& physical_length, - int& truncated, - bool is_vertical) { +void CRRConnectionBuilder::calculate_segment_coordinates(const SegmentInfo& info, + Coordinate x, Coordinate y, + Coordinate& x_low, Coordinate& x_high, + Coordinate& y_low, Coordinate& y_high, + int& physical_length, int& truncated, + bool is_vertical) const { int seg_length = std::stoi(info.seg_type.substr(1)); int tap = info.tap; @@ -512,7 +480,7 @@ void CRRConnectionBuilder::calculate_segment_coordinates( } Direction CRRConnectionBuilder::get_direction_for_side(Side side, - bool is_vertical) { + bool is_vertical) const { if (is_vertical) { return (side == Side::RIGHT || side == Side::TOP) ? Direction::DEC_DIR : Direction::INC_DIR; @@ -522,7 +490,7 @@ Direction CRRConnectionBuilder::get_direction_for_side(Side side, } } -std::string CRRConnectionBuilder::get_segment_type_label(Side side) { +std::string CRRConnectionBuilder::get_segment_type_label(Side side) const { return (side == Side::LEFT || side == Side::RIGHT) ? "CHANX" : "CHANY"; } @@ -530,7 +498,7 @@ std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, int /*seg_length*/, int physical_length, Direction direction, - int truncated) { + int truncated) const { std::vector sequence; if (direction == Direction::DEC_DIR) { @@ -553,12 +521,9 @@ std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, return result; } -SwitchId CRRConnectionBuilder::get_edge_switch_id( - const std::string& cell_value, - const std::string& sink_node_type, - NodeId /*source_node*/, - NodeId /*sink_node*/, - int segment_length) { +SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, + NodeId /*source_node*/, NodeId /*sink_node*/, + int segment_length) const { std::string lower_case_sink_node_type = sink_node_type; std::transform(lower_case_sink_node_type.begin(), lower_case_sink_node_type.end(), @@ -587,9 +552,9 @@ SwitchId CRRConnectionBuilder::get_edge_switch_id( capitalized_switch_id_key.begin(), ::toupper); if (default_switch_id_.find(switch_id_key) != default_switch_id_.end()) { - return default_switch_id_[switch_id_key]; + return default_switch_id_.at(switch_id_key); } else if (default_switch_id_.find(capitalized_switch_id_key) != default_switch_id_.end()) { - return default_switch_id_[capitalized_switch_id_key]; + return default_switch_id_.at(capitalized_switch_id_key); } else { throw std::runtime_error("Default switch id not found for Node Type: " + lower_case_sink_node_type + " and Switch ID Key: " + capitalized_switch_id_key); } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index d9100ff931..263c3b3158 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -91,13 +91,8 @@ class CRRConnectionBuilder { const SwitchBlockManager& sb_manager_; SwitchId sw_zero_id_; - std::vector storage_sw_names_; - std::vector> storage_source_nodes_; - std::vector> storage_sink_nodes_; - // Generated connections std::vector>> all_connections_; - std::mutex connections_mutex_; // Processing state std::atomic processed_locations_{0}; @@ -112,22 +107,14 @@ class CRRConnectionBuilder { std::vector& tile_connections) const; // Node processing methods - std::map get_vertical_nodes( - Coordinate x, - Coordinate y, - const DataFrame& df, - const std::unordered_map& - node_lookup); - - std::map get_horizontal_nodes( - Coordinate x, - Coordinate y, - const DataFrame& df, - const std::unordered_map& - node_lookup); + std::map get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& node_lookup) const; + + std::map get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& node_lookup) const; // PTC sequence calculation - std::string get_ptc_sequence(int seg_index, int seg_length, int physical_length, Direction direction, int truncated); + std::string get_ptc_sequence(int seg_index, int seg_length, int physical_length, Direction direction, int truncated) const; // Segment processing helpers struct SegmentInfo { @@ -147,27 +134,30 @@ class CRRConnectionBuilder { , tap(t) {} }; - SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical); - NodeId process_opin_ipin_node( - const SegmentInfo& info, - Coordinate x, - Coordinate y, - const std::unordered_map& - node_lookup); - NodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical); + SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical) const; + + NodeId process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup) const; + + NodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup, + int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, + bool is_vertical) const; // Coordinate and direction calculations - void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, Coordinate y, Coordinate& x_low, Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, int& physical_length, int& truncated, bool is_vertical); + void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, Coordinate y, + Coordinate& x_low, Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, + int& physical_length, int& truncated, bool is_vertical) const; - Direction get_direction_for_side(Side side, bool is_vertical); - std::string get_segment_type_label(Side side); + Direction get_direction_for_side(Side side, bool is_vertical) const; + std::string get_segment_type_label(Side side) const; // Return the switch id of an edge between two nodes SwitchId get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, NodeId source_node, NodeId sink_node, - int segment_length = -1); + int segment_length = -1) const; // Validation and bounds checking bool is_valid_grid_location(Coordinate x, Coordinate y) const; From ae4ceefc168ac4c6070735f4b36e3eb93996233a Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Fri, 24 Oct 2025 15:11:29 -0700 Subject: [PATCH 058/120] [vpr][route][crr] fix a typo --- .../tileable_rr_graph/crr_generator/crr_edge_builder.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp index 138ecac3c9..3d4d52b9d3 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp @@ -10,6 +10,6 @@ void build_gsb_track_to_track_map(RRGraphBuilder& rr_graph_builder, std::vector gsb_connections = connection_builder.get_tile_connections(gsb_x, gsb_y); for (const auto& connection : gsb_connections) { - rr_graph_builder.create_edclge_in_cache(connection.src_node(), connection.sink_node(), connection.switch_id(), false); + rr_graph_builder.create_edge_in_cache(connection.src_node(), connection.sink_node(), connection.switch_id(), false); } } From 76789e783374363944a76463dbb54f001be0937c Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Fri, 24 Oct 2025 15:35:55 -0700 Subject: [PATCH 059/120] [vpr][route][crr] use rrnodeid in crr connection builder --- .../crr_generator/crr_connection_builder.cpp | 39 +++++++++---------- .../crr_generator/crr_connection_builder.h | 26 +++++++------ 2 files changed, 33 insertions(+), 32 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index fab493f1c8..5ca79baf32 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -154,9 +154,9 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, auto sink_it = sink_nodes.find(col_idx); if (source_it != source_nodes.end() && sink_it != sink_nodes.end()) { - NodeId source_node = source_it->second; + RRNodeId source_node = source_it->second; NodeType source_node_type = rr_graph_.get_node(source_node)->get_type(); - NodeId sink_node = sink_it->second; + RRNodeId sink_node = sink_it->second; NodeType sink_node_type = rr_graph_.get_node(sink_node)->get_type(); // If the source node is an IPIN, then it should be considered as // a sink of the connection. @@ -204,9 +204,9 @@ std::vector CRRConnectionBuilder::get_tile_connections(Coordinate ti return tile_connections; } -std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const { - std::map source_nodes; +std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& node_lookup) const { + std::map source_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; Side prev_side = Side::INVALID; @@ -214,14 +214,13 @@ std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, for (size_t row = NUM_EMPTY_ROWS; row < df.rows(); ++row) { SegmentInfo info = parse_segment_info(df, row, true); - NodeId node_id = 0; + RRNodeId node_id; if (info.side == Side::IPIN || info.side == Side::OPIN) { node_id = process_opin_ipin_node(info, x, y, node_lookup); } else if (info.side == Side::LEFT || info.side == Side::RIGHT || info.side == Side::TOP || info.side == Side::BOTTOM) { - node_id = - process_channel_node(info, x, y, node_lookup, prev_seg_index, - prev_side, prev_seg_type, prev_ptc_number, true); + node_id = process_channel_node(info, x, y, node_lookup, prev_seg_index, + prev_side, prev_seg_type, prev_ptc_number, true); } if (node_id > 0) { @@ -235,9 +234,9 @@ std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, return source_nodes; } -std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, +std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, const std::unordered_map& node_lookup) const { - std::map sink_nodes; + std::map sink_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; Side prev_side = Side::INVALID; @@ -248,7 +247,7 @@ std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x if (info.side == Side::INVALID) { continue; } - NodeId node_id = 0; + RRNodeId node_id; if (info.side == Side::IPIN) { node_id = process_opin_ipin_node(info, x, y, node_lookup); @@ -319,8 +318,8 @@ CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const return info; } -NodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const { +RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup) const { assert(info.side == Side::OPIN || info.side == Side::IPIN); NodeType node_type = (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; @@ -329,14 +328,14 @@ NodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coo auto it = node_lookup.find(hash); if (it != node_lookup.end()) { - return it->second->get_id(); + return it->second; } return 0; } -NodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup, +RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical) const { // Check grid boundaries @@ -383,11 +382,11 @@ NodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coord auto it = node_lookup.find(hash); if (it != node_lookup.end()) { - return it->second->get_id(); + return it->second; } else { VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)\n", seg_type_label.c_str(), seg_sequence.c_str(), x_low, y_low, x_high, y_high); - return 0; + return RRNodeID::INVALID(); } } @@ -522,7 +521,7 @@ std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, } SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, - NodeId /*source_node*/, NodeId /*sink_node*/, + RRNodeId /*source_node*/, RRNodeId /*sink_node*/, int segment_length) const { std::string lower_case_sink_node_type = sink_node_type; std::transform(lower_case_sink_node_type.begin(), diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index 263c3b3158..f54ef96179 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -1,5 +1,7 @@ #pragma once +#include "rr_graph_fwd.h" + #include "crr_common.h" #include "data_frame_processor.h" #include "node_lookup_manager.h" @@ -107,12 +109,12 @@ class CRRConnectionBuilder { std::vector& tile_connections) const; // Node processing methods - std::map get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const; - - std::map get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, + std::map get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, const std::unordered_map& node_lookup) const; + std::map get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, + const std::unordered_map& node_lookup) const; + // PTC sequence calculation std::string get_ptc_sequence(int seg_index, int seg_length, int physical_length, Direction direction, int truncated) const; @@ -136,13 +138,13 @@ class CRRConnectionBuilder { SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical) const; - NodeId process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const; + RRNodeId process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup) const; - NodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup, - int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, - bool is_vertical) const; + RRNodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, + const std::unordered_map& node_lookup, + int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, + bool is_vertical) const; // Coordinate and direction calculations void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, Coordinate y, @@ -155,8 +157,8 @@ class CRRConnectionBuilder { // Return the switch id of an edge between two nodes SwitchId get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, - NodeId source_node, - NodeId sink_node, + RRNodeId source_node, + RRNodeId sink_node, int segment_length = -1) const; // Validation and bounds checking From 91d1fc9e41cd60b017e4430c3a27f174aadffb27 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Sat, 25 Oct 2025 09:09:01 -0700 Subject: [PATCH 060/120] [vpr][route][crr] set NodeId to size_T --- .../tileable_rr_graph/crr_generator/crr_common.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h index 3b75418d76..e737532ab4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h @@ -46,7 +46,7 @@ class ThreadPool; class RRGraphGenerator; // Type aliases for convenience -using NodeId = int32_t; +using NodeId = size_t; using SwitchId = int32_t; using SegmentId = int32_t; using Coordinate = int32_t; From c67bae0ec56b53844062d912d8372e8496e8085a Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Sat, 25 Oct 2025 09:13:28 -0700 Subject: [PATCH 061/120] [vpr][route][crr] fix node_lookup param to contain RRNoneId instead of NodeId --- .../crr_generator/crr_connection_builder.cpp | 10 +++++----- .../crr_generator/crr_connection_builder.h | 8 ++++---- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index 5ca79baf32..e35567c2d0 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -205,7 +205,7 @@ std::vector CRRConnectionBuilder::get_tile_connections(Coordinate ti } std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const { + const std::unordered_map& node_lookup) const { std::map source_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; @@ -235,7 +235,7 @@ std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x } std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const { + const std::unordered_map& node_lookup) const { std::map sink_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; @@ -319,7 +319,7 @@ CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const } RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const { + const std::unordered_map& node_lookup) const { assert(info.side == Side::OPIN || info.side == Side::IPIN); NodeType node_type = (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; @@ -335,7 +335,7 @@ RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, C } RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup, + const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical) const { // Check grid boundaries @@ -386,7 +386,7 @@ RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coo } else { VTR_LOG_DEBUG("Node not found: %s [%s] (%d,%d) -> (%d,%d)\n", seg_type_label.c_str(), seg_sequence.c_str(), x_low, y_low, x_high, y_high); - return RRNodeID::INVALID(); + return RRNodeId::INVALID(); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index f54ef96179..5a03816a88 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -110,10 +110,10 @@ class CRRConnectionBuilder { // Node processing methods std::map get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const; + const std::unordered_map& node_lookup) const; std::map get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const; + const std::unordered_map& node_lookup) const; // PTC sequence calculation std::string get_ptc_sequence(int seg_index, int seg_length, int physical_length, Direction direction, int truncated) const; @@ -139,10 +139,10 @@ class CRRConnectionBuilder { SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical) const; RRNodeId process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const; + const std::unordered_map& node_lookup) const; RRNodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup, + const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical) const; From c895c3178c24dd7130f42fd8f3ce849890956ec3 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Sat, 25 Oct 2025 09:14:08 -0700 Subject: [PATCH 062/120] [vpr][route][crr] use RRNodeId for node_lookup_manager --- .../crr_generator/node_lookup_manager.cpp | 19 +++++++---------- .../crr_generator/node_lookup_manager.h | 21 +++++++------------ 2 files changed, 15 insertions(+), 25 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index 37bbe6b96e..ebc38a27c4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -46,25 +46,22 @@ const RRNode* NodeLookupManager::get_node_by_hash(const NodeHash& hash) const { return (it != global_lookup_.end()) ? it->second : nullptr; } -const std::unordered_map& -NodeLookupManager::get_column_nodes(Coordinate x) const { +const std::unordered_map& NodeLookupManager::get_column_nodes(Coordinate x) const { if (x <= fpga_grid_x_ && x < static_cast(column_lookup_.size())) { return column_lookup_[static_cast(x)]; } - return empty_map_; + return std::unordered_map(); } -const std::unordered_map& -NodeLookupManager::get_row_nodes(Coordinate y) const { +const std::unordered_map& NodeLookupManager::get_row_nodes(Coordinate y) const { if (y <= fpga_grid_y_ && y < static_cast(row_lookup_.size())) { return row_lookup_[static_cast(y)]; } - return empty_map_; + return std::unordered_map(); } -std::unordered_map -NodeLookupManager::get_combined_nodes(Coordinate x, Coordinate y) const { - std::unordered_map combined; +std::unordered_map NodeLookupManager::get_combined_nodes(Coordinate x, Coordinate y) const { + std::unordered_map combined; // Add column nodes const auto& col_nodes = get_column_nodes(x); @@ -166,12 +163,12 @@ void NodeLookupManager::index_node(const RRNode& node) { // Add to column lookup (for single-column nodes) if (loc.x_low == loc.x_high) { - column_lookup_[static_cast(loc.x_low)][hash] = node_ptr; + column_lookup_[static_cast(loc.x_low)][hash] = RRNodeId(node_ptr->get_id()); } // Add to row lookup (for single-row nodes) if (loc.y_low == loc.y_high) { - row_lookup_[static_cast(loc.y_low)][hash] = node_ptr; + row_lookup_[static_cast(loc.y_low)][hash] = RRNodeId(node_ptr->get_id()); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h index f433b00cb4..bdfcee4611 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h @@ -1,5 +1,7 @@ #pragma once +#include "rr_graph_fwd.h" + #include "crr_common.h" #include "custom_rr_graph.h" @@ -35,16 +37,14 @@ class NodeLookupManager { * @param x Column coordinate * @return Map of hash to node for nodes in column */ - const std::unordered_map& - get_column_nodes(Coordinate x) const; + const std::unordered_map& get_column_nodes(Coordinate x) const; /** * @brief Get nodes in a specific row * @param y Row coordinate * @return Map of hash to node for nodes in row */ - const std::unordered_map& get_row_nodes( - Coordinate y) const; + const std::unordered_map& get_row_nodes(Coordinate y) const; /** * @brief Get combined nodes for column and row (for switch block processing) @@ -52,9 +52,7 @@ class NodeLookupManager { * @param y Row coordinate * @return Combined map of nodes */ - std::unordered_map get_combined_nodes( - Coordinate x, - Coordinate y) const; + std::unordered_map get_combined_nodes(Coordinate x, Coordinate y) const; /** * @brief Get all nodes by type @@ -91,10 +89,8 @@ class NodeLookupManager { private: // Spatial indexes - SINK and SOURCE nodes are not stored in these two maps - std::vector> - column_lookup_; - std::vector> - row_lookup_; + std::vector> column_lookup_; + std::vector> row_lookup_; // Edge spatial indexes. [x][y] -> std::vector std::vector>> edge_sink_lookup_; @@ -110,9 +106,6 @@ class NodeLookupManager { Coordinate fpga_grid_x_; Coordinate fpga_grid_y_; - // Empty map for invalid coordinates - std::unordered_map empty_map_; - // Helper methods NodeHash build_node_hash(const RRNode& node) const; void validate_coordinates(Coordinate x, Coordinate y) const; From 9c9edfb6c63896e673e483cff3230bf88aa065ae Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 07:43:46 -0700 Subject: [PATCH 063/120] [vpr][route][crr] change nodeid to rrnodeid for connections class --- .../tileable_rr_graph/crr_generator/crr_common.h | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h index e737532ab4..95a7a38258 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h @@ -27,6 +27,7 @@ #include #include // For getrusage on Unix/Linux +#include "rr_graph_fwd.h" namespace crrgenerator { // Forward declarations @@ -159,12 +160,12 @@ struct Sizing { */ class Connection { public: - Connection(NodeId sink_node, NodeId src_node, SwitchId switch_id) + Connection(RRNodeId sink_node, RRNodeId src_node, SwitchId switch_id) : sink_node_(sink_node) , src_node_(src_node) , switch_id_(switch_id) {} - NodeId sink_node() const { return sink_node_; } - NodeId src_node() const { return src_node_; } + RRNodeId sink_node() const { return sink_node_; } + RRNodeId src_node() const { return src_node_; } SwitchId switch_id() const { return switch_id_; } bool operator<(const Connection& other) const { @@ -176,8 +177,8 @@ class Connection { } private: - NodeId sink_node_; - NodeId src_node_; + RRNodeId sink_node_; + RRNodeId src_node_; SwitchId switch_id_; }; From 097ebdc9c69016e45744def3ceafe38f990c4fac Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 07:50:55 -0700 Subject: [PATCH 064/120] [vpr][route][crr] use rrnodeid in connection builder --- .../crr_generator/crr_connection_builder.cpp | 37 +++++++++++-------- .../crr_generator/crr_connection_builder.h | 8 ++-- 2 files changed, 27 insertions(+), 18 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index e35567c2d0..cde330d498 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -2,9 +2,14 @@ #include #include +#include +#include +#include +#include #include "vtr_log.h" #include "vtr_assert.h" +#include "rr_node_types.h" // #include // using json = nlohmann::json; @@ -47,10 +52,12 @@ static bool is_integer(const std::string& s) { // file << j.dump(4); // Pretty print with indent of 4 // } -CRRConnectionBuilder::CRRConnectionBuilder(const RRGraph& rr_graph, +CRRConnectionBuilder::CRRConnectionBuilder(const RRGraphView& rr_graph, + const RRGraph& crr_graph, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager) : rr_graph_(rr_graph) + , crr_graph_(crr_graph) , node_lookup_(node_lookup) , sb_manager_(sb_manager) {} @@ -63,7 +70,7 @@ void CRRConnectionBuilder::initialize( fpga_grid_y_ = fpga_grid_y; is_annotated_excel_ = is_annotated_excel; - for (const auto& original_switch : rr_graph_.get_switches()) { + for (const auto& original_switch : crr_graph_.get_switches()) { std::string switch_name = original_switch.get_name(); std::transform(switch_name.begin(), switch_name.end(), switch_name.begin(), ::tolower); @@ -94,8 +101,8 @@ void CRRConnectionBuilder::initialize( } } - assert(default_switch_id_.size() == rr_graph_.get_switches().size()); - sw_zero_id_ = static_cast(rr_graph_.get_switches().size()); + assert(default_switch_id_.size() == crr_graph_.get_switches().size()); + sw_zero_id_ = static_cast(crr_graph_.get_switches().size()); // Total locations is the number of locations on the FPGA grid minus the 4 // corner locations. @@ -155,27 +162,27 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, if (source_it != source_nodes.end() && sink_it != sink_nodes.end()) { RRNodeId source_node = source_it->second; - NodeType source_node_type = rr_graph_.get_node(source_node)->get_type(); + e_rr_type source_node_type = rr_graph_.node_type(source_node); RRNodeId sink_node = sink_it->second; - NodeType sink_node_type = rr_graph_.get_node(sink_node)->get_type(); + e_rr_type sink_node_type = rr_graph_.node_type(sink_node); // If the source node is an IPIN, then it should be considered as // a sink of the connection. - if (source_node_type == NodeType::IPIN) { + if (source_node_type == e_rr_type::IPIN) { SwitchId switch_id = get_edge_switch_id(cell.as_string(), - to_string(source_node_type), + rr_node_typename[source_node_type], sink_node, source_node); tile_connections.emplace_back(source_node, sink_node, switch_id); } else { int segment_length = -1; - if (sink_node_type == NodeType::CHANX || sink_node_type == NodeType::CHANY) { - segment_length = rr_graph_.get_segment(rr_graph_.get_node(sink_node)->get_segment().segment_id)->get_length(); + if (sink_node_type == e_rr_type::CHANX || sink_node_type == e_rr_type::CHANY) { + segment_length = rr_graph_.node_length(sink_node); } SwitchId switch_id = get_edge_switch_id(cell.as_string(), - to_string(sink_node_type), + rr_node_typename[sink_node_type], source_node, sink_node, segment_length); @@ -223,7 +230,7 @@ std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x prev_side, prev_seg_type, prev_ptc_number, true); } - if (node_id > 0) { + if (node_id != RRNodeId::INVALID()) { source_nodes[row] = node_id; } @@ -257,7 +264,7 @@ std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate false); } - if (node_id > 0) { + if (node_id != RRNodeId::INVALID()) { sink_nodes[col] = node_id; } @@ -331,7 +338,7 @@ RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, C return it->second; } - return 0; + return RRNodeId::INVALID(); } RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, @@ -340,7 +347,7 @@ RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coo bool is_vertical) const { // Check grid boundaries if ((info.side == Side::RIGHT && x == fpga_grid_x_) || (info.side == Side::TOP && y == fpga_grid_y_)) { - return 0; + return RRNodeId::INVALID(); } int seg_length = std::stoi( diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index 5a03816a88..103ab7abf4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -1,6 +1,6 @@ #pragma once -#include "rr_graph_fwd.h" +#include "rr_graph_view.h" #include "crr_common.h" #include "data_frame_processor.h" @@ -20,7 +20,8 @@ namespace crrgenerator { */ class CRRConnectionBuilder { public: - CRRConnectionBuilder(const RRGraph& rr_graph, + CRRConnectionBuilder(const RRGraphView& rr_graph, + const RRGraph& crr_graph, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager); @@ -88,7 +89,8 @@ class CRRConnectionBuilder { bool is_annotated_excel_; // Dependencies - const RRGraph& rr_graph_; + const RRGraphView& rr_graph_; + const RRGraph& crr_graph_; const NodeLookupManager& node_lookup_; const SwitchBlockManager& sb_manager_; SwitchId sw_zero_id_; From bdba300d3e7a772d5741be37c0a9430b108a2d11 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 07:52:22 -0700 Subject: [PATCH 065/120] [vpr][route][crr] pass RRSwitchId to graph builder --- .../tileable_rr_graph/crr_generator/crr_edge_builder.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp index 3d4d52b9d3..4637822949 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp @@ -10,6 +10,7 @@ void build_gsb_track_to_track_map(RRGraphBuilder& rr_graph_builder, std::vector gsb_connections = connection_builder.get_tile_connections(gsb_x, gsb_y); for (const auto& connection : gsb_connections) { - rr_graph_builder.create_edge_in_cache(connection.src_node(), connection.sink_node(), connection.switch_id(), false); + RRSwitchId rr_switch_id = RRSwitchId(connection.switch_id()); + rr_graph_builder.create_edge_in_cache(connection.src_node(), connection.sink_node(), rr_switch_id, false); } } From d59ae52953da85da066dbc99c45e692821ca4522 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 12:28:03 -0700 Subject: [PATCH 066/120] [lib][rr_graph] remove node_tilable_track_nums_ from rr graph view --- libs/librrgraph/src/base/rr_graph_view.cpp | 7 ++----- libs/librrgraph/src/base/rr_graph_view.h | 7 +------ 2 files changed, 3 insertions(+), 11 deletions(-) diff --git a/libs/librrgraph/src/base/rr_graph_view.cpp b/libs/librrgraph/src/base/rr_graph_view.cpp index f23762c3e7..0cb24a0a5f 100644 --- a/libs/librrgraph/src/base/rr_graph_view.cpp +++ b/libs/librrgraph/src/base/rr_graph_view.cpp @@ -10,8 +10,7 @@ RRGraphView::RRGraphView(const t_rr_graph_storage& node_storage, const std::vector& rr_rc_data, const vtr::vector& rr_segments, const vtr::vector& rr_switch_inf, - const vtr::vector>& node_in_edges, - const vtr::vector>& node_tileable_track_nums) + const vtr::vector>& node_in_edges) : node_storage_(node_storage) , node_lookup_(node_lookup) , rr_node_metadata_(rr_node_metadata) @@ -20,9 +19,7 @@ RRGraphView::RRGraphView(const t_rr_graph_storage& node_storage, , rr_rc_data_(rr_rc_data) , rr_segments_(rr_segments) , rr_switch_inf_(rr_switch_inf) - , node_in_edges_(node_in_edges) - , node_tileable_track_nums_(node_tileable_track_nums) { -} + , node_in_edges_(node_in_edges) {} std::vector RRGraphView::node_in_edges(RRNodeId node) const { VTR_ASSERT(size_t(node) < node_storage_.size()); diff --git a/libs/librrgraph/src/base/rr_graph_view.h b/libs/librrgraph/src/base/rr_graph_view.h index ca825d1564..e97173c2fe 100644 --- a/libs/librrgraph/src/base/rr_graph_view.h +++ b/libs/librrgraph/src/base/rr_graph_view.h @@ -81,8 +81,7 @@ class RRGraphView { const std::vector& rr_rc_data, const vtr::vector& rr_segments, const vtr::vector& rr_switch_inf, - const vtr::vector>& node_in_edges, - const vtr::vector>& node_ptc_nums); + const vtr::vector>& node_in_edges); /* Disable copy constructors and copy assignment operator * This is to avoid accidental copy because it could be an expensive operation considering that the @@ -812,8 +811,4 @@ class RRGraphView { /// A list of incoming edges for each routing resource node. This can be built optionally, as required by applications. /// By default, it is empty. Call build_in_edges() to construct it. const vtr::vector>& node_in_edges_; - - /// A list of extra ptc numbers for each routing resource node. This is only used for tileable architecture. - /// See details in RRGraphBuilder class - const vtr::vector>& node_tileable_track_nums_; }; From 67783beade22b608a9d3f2391c14c8708fd4290d Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 12:36:47 -0700 Subject: [PATCH 067/120] [lib][rr_graph][builder] remove direct access to node_tilable_track_nums_ --- libs/librrgraph/src/base/rr_graph_builder.cpp | 58 +++---------------- libs/librrgraph/src/base/rr_graph_builder.h | 31 ---------- 2 files changed, 7 insertions(+), 82 deletions(-) diff --git a/libs/librrgraph/src/base/rr_graph_builder.cpp b/libs/librrgraph/src/base/rr_graph_builder.cpp index a09c4a727a..da23f82e15 100644 --- a/libs/librrgraph/src/base/rr_graph_builder.cpp +++ b/libs/librrgraph/src/base/rr_graph_builder.cpp @@ -31,10 +31,6 @@ vtr::vector>& RRGraphBuilder::node_in_edge_stora return node_in_edges_; } -vtr::vector>& RRGraphBuilder::node_ptc_storage() { - return node_tilable_track_nums_; -} - void RRGraphBuilder::add_node_to_all_locs(RRNodeId node) { e_rr_type node_type = node_storage_.node_type(node); short node_ptc_num = node_storage_.node_ptc_num(node); @@ -76,7 +72,6 @@ RRNodeId RRGraphBuilder::create_node(int layer, int x, int y, e_rr_type type, in node_side = side; } node_storage_.emplace_back(); - node_tilable_track_nums_.emplace_back(); RRNodeId new_node = RRNodeId(node_storage_.size() - 1); node_storage_.set_node_layer(new_node, layer, layer); node_storage_.set_node_type(new_node, type); @@ -102,7 +97,6 @@ void RRGraphBuilder::clear() { node_lookup_.clear(); node_storage_.clear(); node_in_edges_.clear(); - node_tilable_track_nums_.clear(); rr_node_metadata_.clear(); rr_edge_metadata_.clear(); rr_segments_.clear(); @@ -232,58 +226,19 @@ std::vector RRGraphBuilder::node_in_edges(RRNodeId node) const { } void RRGraphBuilder::set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) { - VTR_ASSERT(size_t(node) < node_storage_.size()); - std::vector ptc_tokens = vtr::StringToken(ptc_str).split(","); - VTR_ASSERT(ptc_tokens.size() >= 1); - set_node_ptc_num(node, std::stoi(ptc_tokens[0])); - if (ptc_tokens.size() > 1) { - VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); - node_tilable_track_nums_[node].resize(ptc_tokens.size()); - for (size_t iptc = 0; iptc < ptc_tokens.size(); iptc++) { - node_tilable_track_nums_[node][iptc] = std::stoi(ptc_tokens[iptc]); - } - } + node_storage_.set_node_ptc_nums(node, ptc_str); } std::string RRGraphBuilder::node_ptc_nums_to_string(RRNodeId node) const { - if (node_tilable_track_nums_.empty()) { - return std::to_string(size_t(node_storage_.node_ptc_num(node))); - } - VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); - if (node_tilable_track_nums_[node].empty()) { - return std::to_string(size_t(node_storage_.node_ptc_num(node))); - } - std::string ret; - for (size_t iptc = 0; iptc < node_tilable_track_nums_[node].size(); iptc++) { - ret += std::to_string(size_t(node_tilable_track_nums_[node][iptc])) + ","; - } - // Remove the last comma - ret.pop_back(); - return ret; + return node_storage_.node_ptc_nums_to_string(node); } bool RRGraphBuilder::node_contain_multiple_ptc(RRNodeId node) const { - if (node_tilable_track_nums_.empty()) { - return false; - } - return node_tilable_track_nums_[node].size() > 1; + return node_storage_.node_contain_multiple_ptc(node); } void RRGraphBuilder::add_node_track_num(RRNodeId node, vtr::Point node_offset, short track_id) { - VTR_ASSERT(size_t(node) < node_storage_.size()); - VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); - VTR_ASSERT_MSG(node_storage_.node_type(node) == e_rr_type::CHANX || node_storage_.node_type(node) == e_rr_type::CHANY, "Track number valid only for CHANX/CHANY RR nodes"); - - size_t node_length = std::abs(node_storage_.node_xhigh(node) - node_storage_.node_xlow(node)) - + std::abs(node_storage_.node_yhigh(node) - node_storage_.node_ylow(node)); - if (node_length + 1 != node_tilable_track_nums_[node].size()) { - node_tilable_track_nums_[node].resize(node_length + 1); - } - - size_t offset = node_offset.x() - node_storage_.node_xlow(node) + node_offset.y() - node_storage_.node_ylow(node); - VTR_ASSERT(offset < node_tilable_track_nums_[node].size()); - - node_tilable_track_nums_[node][offset] = track_id; + node_storage_.add_node_tilable_track_num(node, node_offset, track_id); } void RRGraphBuilder::add_track_node_to_lookup(RRNodeId node) { @@ -309,8 +264,9 @@ void RRGraphBuilder::add_track_node_to_lookup(RRNodeId node) { // Routing channel nodes may have different ptc num // Find the track ids using the x/y offset if (e_rr_type::CHANX == node_type || e_rr_type::CHANY == node_type) { - ptc = (node_type == e_rr_type::CHANX) ? node_tilable_track_nums_[node][x - node_storage_.node_xlow(node)] : - node_tilable_track_nums_[node][y - node_storage_.node_ylow(node)]; + const std::vector& track_nums = node_storage_.node_tilable_track_nums(node); + ptc = (node_type == e_rr_type::CHANX) ? track_nums[x - node_storage_.node_xlow(node)] : + track_nums[y - node_storage_.node_ylow(node)]; node_lookup_.add_node(node, node_storage_.node_layer_low(node), x, y, node_type, ptc); } } diff --git a/libs/librrgraph/src/base/rr_graph_builder.h b/libs/librrgraph/src/base/rr_graph_builder.h index daf4274227..f916944a89 100644 --- a/libs/librrgraph/src/base/rr_graph_builder.h +++ b/libs/librrgraph/src/base/rr_graph_builder.h @@ -50,9 +50,6 @@ class RRGraphBuilder { /** @brief Return a writable object fo the incoming edge storage */ vtr::vector>& node_in_edge_storage(); - - /** @brief Return a writable object of the node ptc storage (for tileable routing resource graph) */ - vtr::vector>& node_ptc_storage(); /** @brief Return the size for rr_node_metadata */ inline size_t rr_node_metadata_size() const { @@ -420,11 +417,6 @@ class RRGraphBuilder { inline void resize_nodes(size_t size) { node_storage_.resize(size); } - /** @brief This function resize node ptc nums. Only used by RR graph I/O reader and writers. */ - inline void resize_node_ptc_nums(size_t size) { - node_tilable_track_nums_.resize(size); - } - /** @brief This function resize rr_switch to accomidate size RR Switch. */ inline void resize_switches(size_t size) { @@ -527,29 +519,6 @@ class RRGraphBuilder { */ vtr::vector> node_in_edges_; - /** - * @brief Extra ptc number for each routing resource node. - * @note This is required by tileable routing resource graphs. The first index is the node id, and - * the second index is is the relative distance from the starting point of the node. - * @details - * In a tileable routing architecture, routing tracks, e.g., CHANX and CHANY, follow a staggered organization. - * Hence, a routing track may appear in different routing channels, representing different ptc/track id. - * Here is an illustrative example of a X-direction routing track (CHANX) in INC direction, which is organized in staggered way. - * - * Coord(x,y) (1,0) (2,0) (3,0) (4,0) Another track (node) - * ptc=0 ------> ------> - * \ / - * ptc=1 ------> / - * \ / - * ptc=2 ------> / - * \ / - * ptc=3 -------> - * ^ ^ - * | | - * starting point ending point - */ - vtr::vector> node_tilable_track_nums_; - /** @warning The Metadata should stay as an independent data structure from the rest of the internal data, * e.g., node_lookup! */ /* Metadata is an extra data on rr-nodes and edges, respectively, that is not used by vpr From 7bbec6c27421a313ee1c530400c241d9662b558a Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 12:40:04 -0700 Subject: [PATCH 068/120] [lib][rr_graph][storage] add node_tilable_track_nums_ API calls to graph storage --- libs/librrgraph/src/base/rr_graph_storage.cpp | 49 +++++++++++++++++++ libs/librrgraph/src/base/rr_graph_storage.h | 41 ++++++++++++++++ 2 files changed, 90 insertions(+) diff --git a/libs/librrgraph/src/base/rr_graph_storage.cpp b/libs/librrgraph/src/base/rr_graph_storage.cpp index a9568810e3..21a67cd354 100644 --- a/libs/librrgraph/src/base/rr_graph_storage.cpp +++ b/libs/librrgraph/src/base/rr_graph_storage.cpp @@ -815,6 +815,55 @@ void t_rr_graph_storage::set_node_direction(RRNodeId id, Direction new_direction node_storage_[id].dir_side_.direction = new_direction; } +void set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) { + VTR_ASSERT(size_t(node) < node_storage_.size()); + std::vector ptc_tokens = vtr::StringToken(ptc_str).split(","); + VTR_ASSERT(ptc_tokens.size() >= 1); + set_node_ptc_num(node, std::stoi(ptc_tokens[0])); + if (ptc_tokens.size() > 1) { + VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); + node_tilable_track_nums_[node].resize(ptc_tokens.size()); + for (size_t iptc = 0; iptc < ptc_tokens.size(); iptc++) { + node_tilable_track_nums_[node][iptc] = std::stoi(ptc_tokens[iptc]); + } + } +} + +void t_rr_graph_storage::add_node_tilable_track_num(RRNodeId node, vtr::Point node_offset, short track_id) { + VTR_ASSERT(size_t(node) < node_storage_.size()); + VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); + VTR_ASSERT_MSG(node_type(node) == e_rr_type::CHANX || node_type(node) == e_rr_type::CHANY, + "Track number valid only for CHANX/CHANY RR nodes"); + + size_t node_length = std::abs(node_xhigh(node) - node_xlow(node)) + + std::abs(node_yhigh(node) - node_ylow(node)); + if (node_length + 1 != node_tilable_track_nums_[node].size()) { + node_tilable_track_nums_[node].resize(node_length + 1); + } + + size_t offset = node_offset.x() - node_xlow(node) + node_offset.y() - node_ylow(node); + VTR_ASSERT(offset < node_tilable_track_nums_[node].size()); + + node_tilable_track_nums_[node][offset] = track_id; +} + +std::string t_rr_graph_storage::node_ptc_nums_to_string(RRNodeId node) const { + if (node_tilable_track_nums_.empty()) { + return std::to_string(size_t(node_storage_.node_ptc_num(node))); + } + VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); + if (node_tilable_track_nums_[node].empty()) { + return std::to_string(size_t(node_storage_.node_ptc_num(node))); + } + std::string ret; + for (size_t iptc = 0; iptc < node_tilable_track_nums_[node].size(); iptc++) { + ret += std::to_string(size_t(node_tilable_track_nums_[node][iptc])) + ","; + } + // Remove the last comma + ret.pop_back(); + return ret; +} + void t_rr_graph_storage::add_node_side(RRNodeId id, e_side new_side) { if (node_type(id) != e_rr_type::IPIN && node_type(id) != e_rr_type::OPIN) { VTR_LOG_ERROR("Attempted to set RR node 'side' for non-pin type '%s'", node_type_string(id)); diff --git a/libs/librrgraph/src/base/rr_graph_storage.h b/libs/librrgraph/src/base/rr_graph_storage.h index 9cd7c7b6e9..046e6f119e 100644 --- a/libs/librrgraph/src/base/rr_graph_storage.h +++ b/libs/librrgraph/src/base/rr_graph_storage.h @@ -565,6 +565,7 @@ class t_rr_graph_storage { if (is_tileable_) { node_bend_start_.reserve(size); node_bend_end_.reserve(size); + node_tilable_track_nums_.reserve(size); } } @@ -602,6 +603,7 @@ class t_rr_graph_storage { node_layer_.clear(); node_bend_start_.clear(); node_bend_end_.clear(); + node_tilable_track_nums_.clear(); node_name_.clear(); virtual_clock_network_root_idx_.clear(); edge_src_node_.clear(); @@ -657,6 +659,7 @@ class t_rr_graph_storage { if (is_tileable_) { node_bend_start_.emplace_back(); node_bend_end_.emplace_back(); + node_tilable_track_nums_.emplace_back(); } } @@ -687,6 +690,21 @@ class t_rr_graph_storage { void set_node_capacity(RRNodeId, short new_capacity); void set_node_direction(RRNodeId, Direction new_direction); + void set_node_ptc_nums(RRNodeId node, const std::string& ptc_str); + void add_node_tilable_track_num(RRNodeId node, vtr::Point node_offset, short track_id); + + void emplace_back_node_tilable_track_num(); + + bool node_contain_multiple_ptc(RRNodeId node) const { + return node_tilable_track_nums_[node].size() > 1; + } + + std::string node_ptc_nums_to_string(RRNodeId node) const; + + const std::vector& node_tilable_track_nums(RRNodeId node) const { + return node_tilable_track_nums_[node]; + } + /** @brief * Add a side to the node attributes * This is the function to use when you just add a new side WITHOUT resetting side attributes @@ -895,6 +913,29 @@ class t_rr_graph_storage { */ vtr::vector node_ptc_; + /** + * @brief Extra ptc number for each routing resource node. + * @note This is required by tileable routing resource graphs. The first index is the node id, and + * the second index is is the relative distance from the starting point of the node. + * @details + * In a tileable routing architecture, routing tracks, e.g., CHANX and CHANY, follow a staggered organization. + * Hence, a routing track may appear in different routing channels, representing different ptc/track id. + * Here is an illustrative example of a X-direction routing track (CHANX) in INC direction, which is organized in staggered way. + * + * Coord(x,y) (1,0) (2,0) (3,0) (4,0) Another track (node) + * ptc=0 ------> ------> + * \ / + * ptc=1 ------> / + * \ / + * ptc=2 ------> / + * \ / + * ptc=3 -------> + * ^ ^ + * | | + * starting point ending point + */ + vtr::vector> node_tilable_track_nums_; + /** @brief * This array stores the first edge of each RRNodeId. Not that the length * of this vector is always storage_.size() + 1, where the last value is From 5c4aecabfecab171e8cfa7d91fcedc0f8233ebee Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 12:41:04 -0700 Subject: [PATCH 069/120] [lib][rr_graph][io] remove redundant API call --- libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h | 1 - 1 file changed, 1 deletion(-) diff --git a/libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h b/libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h index 629227fdff..a59e7c2879 100644 --- a/libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h +++ b/libs/librrgraph/src/io/rr_graph_uxsdcxx_serializer.h @@ -895,7 +895,6 @@ class RrGraphSerializer final : public uxsd::RrGraphBase { */ inline void preallocate_rr_nodes_node(void*& /*ctx*/, size_t size) final { rr_graph_builder_->reserve_nodes(size); - rr_graph_builder_->resize_node_ptc_nums(size); } inline int add_rr_nodes_node(void*& /*ctx*/, unsigned int capacity, unsigned int id, uxsd::enum_node_type type) final { // make_room_in_vector will not allocate if preallocate_rr_nodes_node From 0803118d8ca712c66bbcf858ef9da29f9ecdd6ac Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 12:45:48 -0700 Subject: [PATCH 070/120] [rr_graph][view] update instances with new constructor call --- vpr/src/base/vpr_context.h | 3 +-- vpr/src/route/router_lookahead/router_lookahead_map.cpp | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/vpr/src/base/vpr_context.h b/vpr/src/base/vpr_context.h index 6464f97468..f946ff7795 100644 --- a/vpr/src/base/vpr_context.h +++ b/vpr/src/base/vpr_context.h @@ -251,8 +251,7 @@ struct DeviceContext : public Context { rr_rc_data, rr_graph_builder.rr_segments(), rr_graph_builder.rr_switch(), - rr_graph_builder.node_in_edge_storage(), - rr_graph_builder.node_ptc_storage()}; + rr_graph_builder.node_in_edge_storage()}; ///@brief Track ids for each rr_node in the rr_graph. This is used by drawer for tileable routing resource graph std::map> rr_node_track_ids; diff --git a/vpr/src/route/router_lookahead/router_lookahead_map.cpp b/vpr/src/route/router_lookahead/router_lookahead_map.cpp index c7ea331f45..2cacbe1424 100644 --- a/vpr/src/route/router_lookahead/router_lookahead_map.cpp +++ b/vpr/src/route/router_lookahead/router_lookahead_map.cpp @@ -760,8 +760,7 @@ static void compute_tile_lookahead(std::unordered_map Date: Mon, 27 Oct 2025 13:15:06 -0700 Subject: [PATCH 071/120] [vpr][route][crr] update lookup maanger functions to use rr graph view --- .../crr_generator/node_lookup_manager.cpp | 86 ++++--------------- .../crr_generator/node_lookup_manager.h | 40 ++------- 2 files changed, 25 insertions(+), 101 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index ebc38a27c4..9366e5be45 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -5,47 +5,31 @@ namespace crrgenerator { -NodeLookupManager::NodeLookupManager() - : fpga_grid_x_(0) - , fpga_grid_y_(0) {} +NodeLookupManager::NodeLookupManager(const RRGraphView& rr_graph, size_t fpga_grid_x, size_t fpga_grid_y) + : rr_graph_(rr_graph) + , fpga_grid_x_(fpga_grid_x) + , fpga_grid_y_(fpga_grid_y) {} -void NodeLookupManager::initialize(const RRGraph& graph, Coordinate fpga_grid_x, Coordinate fpga_grid_y) { +void NodeLookupManager::initialize() { VTR_LOG("Initializing NodeLookupManager for %d x %d grid with %zu nodes\n", - fpga_grid_x, fpga_grid_y, static_cast(graph.get_node_count())); - - fpga_grid_x_ = fpga_grid_x; - fpga_grid_y_ = fpga_grid_y; + fpga_grid_x_, fpga_grid_y_, static_cast(rr_graph_.num_nodes())); // Clear existing data clear(); // Initialize lookup structures - column_lookup_.resize(static_cast(fpga_grid_x) + 1); - row_lookup_.resize(static_cast(fpga_grid_y) + 1); - for (int i = 0; i <= fpga_grid_x + 1; i++) { - edge_sink_lookup_.push_back(std::vector>( - static_cast(fpga_grid_y + 2), std::vector())); - } + column_lookup_.resize(static_cast(fpga_grid_x_) + 1); + row_lookup_.resize(static_cast(fpga_grid_y_) + 1); // Index all nodes - for (const auto& node : graph.get_nodes()) { - index_node(node); - } - - // Index all edges - for (const auto& edge : graph.get_edges()) { - index_edge(graph, edge); + for (RRNodeId node_id : rr_graph_.nodes()) { + index_node(node_id); } VTR_LOG("Node lookup manager initialized successfully\n"); print_statistics(); } -const RRNode* NodeLookupManager::get_node_by_hash(const NodeHash& hash) const { - auto it = global_lookup_.find(hash); - return (it != global_lookup_.end()) ? it->second : nullptr; -} - const std::unordered_map& NodeLookupManager::get_column_nodes(Coordinate x) const { if (x <= fpga_grid_x_ && x < static_cast(column_lookup_.size())) { return column_lookup_[static_cast(x)]; @@ -74,16 +58,6 @@ std::unordered_map NodeLookupManager::get_combin return combined; } -std::vector NodeLookupManager::get_nodes_by_type( - NodeType type) const { - auto it = type_lookup_.find(type); - return (it != type_lookup_.end()) ? it->second : std::vector{}; -} - -const std::vector NodeLookupManager::get_sink_edges_at_location(Coordinate x, Coordinate y) const { - return edge_sink_lookup_[static_cast(x)][static_cast(y)]; -} - bool NodeLookupManager::is_valid_coordinate(Coordinate x, Coordinate y) const { return x >= 0 && x <= fpga_grid_x_ && y >= 0 && y <= fpga_grid_y_; } @@ -91,12 +65,6 @@ bool NodeLookupManager::is_valid_coordinate(Coordinate x, Coordinate y) const { void NodeLookupManager::print_statistics() const { VTR_LOG("=== Node Lookup Manager Statistics ===\n"); VTR_LOG("Grid dimensions: %d x %d\n", fpga_grid_x_, fpga_grid_y_); - VTR_LOG("Total nodes indexed: %zu\n", global_lookup_.size()); - - // Count nodes by type - for (const auto& [type, nodes] : type_lookup_) { - VTR_LOG(" %s nodes: %zu\n", to_string(type).c_str(), nodes.size()); - } // Count nodes per column std::vector col_counts; @@ -129,26 +97,19 @@ void NodeLookupManager::print_statistics() const { void NodeLookupManager::clear() { column_lookup_.clear(); row_lookup_.clear(); - global_lookup_.clear(); - type_lookup_.clear(); } -NodeHash NodeLookupManager::build_node_hash(const RRNode& node) const { - return std::make_tuple(node.get_type(), node.get_ptc(), - node.get_location().x_low, node.get_location().x_high, - node.get_location().y_low, node.get_location().y_high); +NodeHash NodeLookupManager::build_node_hash(RRNodeId node_id) const { + const std::string& node_ptcs = rr_graph_.rr_nodes().node_ptc_nums_to_string(node_id); + return std::make_tuple(rr_graph_.node_type(node_id), node_ptcs, + rr_graph_.node_xlow(node_id), rr_graph_.node_xhigh(node_id), + rr_graph_.node_ylow(node_id), rr_graph_.node_yhigh(node_id)); } -void NodeLookupManager::index_node(const RRNode& node) { +void NodeLookupManager::index_node(RRNodeId node_id) { NodeHash hash = build_node_hash(node); const RRNode* node_ptr = &node; - // Add to global lookup - global_lookup_[hash] = node_ptr; - - // Add to type lookup - type_lookup_[node.get_type()].push_back(node_ptr); - const Location& loc = node.get_location(); VTR_ASSERT(loc.x_low <= fpga_grid_x_); @@ -172,19 +133,4 @@ void NodeLookupManager::index_node(const RRNode& node) { } } -void NodeLookupManager::index_edge(const RRGraph& graph, const RREdge& edge) { - const RRNode* sink = graph.get_node(edge.get_sink_node()); - - VTR_ASSERT(sink->get_location().x_high >= 0); - VTR_ASSERT(sink->get_location().y_high >= 0); - - VTR_ASSERT(sink->get_location().x_high <= fpga_grid_x_); - VTR_ASSERT(sink->get_location().y_high <= fpga_grid_y_); - - // Add to edge lookup - edge_sink_lookup_[static_cast(sink->get_location().x_low)] - [static_cast(sink->get_location().y_low)] - .push_back(&edge); -} - } // namespace crrgenerator diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h index bdfcee4611..7cda6f7b63 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h @@ -1,6 +1,7 @@ #pragma once #include "rr_graph_fwd.h" +#include "rr_graph_view.h" #include "crr_common.h" #include "custom_rr_graph.h" @@ -15,22 +16,18 @@ namespace crrgenerator { */ class NodeLookupManager { public: - NodeLookupManager(); - /** - * @brief Initialize lookup tables from RR graph - * @param graph RR graph to index + * @brief Constructor + * @param rr_graph RR graph to index * @param fpga_grid_x Maximum X coordinate * @param fpga_grid_y Maximum Y coordinate */ - void initialize(const RRGraph& graph, Coordinate fpga_grid_x, Coordinate fpga_grid_y); + NodeLookupManager(const RRGraphView& rr_graph, size_t fpga_grid_x, size_t fpga_grid_y); /** - * @brief Get node by hash key - * @param hash Node hash tuple - * @return Pointer to node or nullptr if not found + * @brief Initialize lookup tables from RR graph */ - const RRNode* get_node_by_hash(const NodeHash& hash) const; + void initialize(); /** * @brief Get nodes in a specific column @@ -54,21 +51,6 @@ class NodeLookupManager { */ std::unordered_map get_combined_nodes(Coordinate x, Coordinate y) const; - /** - * @brief Get all nodes by type - * @param type Node type to filter - * @return Vector of nodes of specified type - */ - std::vector get_nodes_by_type(NodeType type) const; - - /** - * @brief Get sink edge at location - * @param x X coordinate - * @param y Y coordinate - * @return Edges which sinks are in the given location - */ - const std::vector get_sink_edges_at_location(Coordinate x, Coordinate y) const; - /** * @brief Check if coordinate is valid * @param x X coordinate @@ -88,6 +70,7 @@ class NodeLookupManager { void clear(); private: + const RRGraphView& rr_graph_; // Spatial indexes - SINK and SOURCE nodes are not stored in these two maps std::vector> column_lookup_; std::vector> row_lookup_; @@ -98,19 +81,14 @@ class NodeLookupManager { // Global lookup - Return a pointer to the node corresponding to the hash std::unordered_map global_lookup_; - // Type-based lookup - Return a vector of pointers to nodes of the specified - // type - std::unordered_map> type_lookup_; - // Grid dimensions Coordinate fpga_grid_x_; Coordinate fpga_grid_y_; // Helper methods - NodeHash build_node_hash(const RRNode& node) const; + NodeHash build_node_hash(RRNodeId node_id) const; void validate_coordinates(Coordinate x, Coordinate y) const; - void index_node(const RRNode& node); - void index_edge(const RRGraph& graph, const RREdge& edge); + void index_node(RRNodeId node_id); }; } // namespace crrgenerator From 60cc0e07245e279e9828a6c1e70d5cc0600629c2 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 13:34:31 -0700 Subject: [PATCH 072/120] [lib][rr_graph][storage] pass node_offset to add_node_tilable_track_num instead of point --- libs/librrgraph/src/base/rr_graph_storage.cpp | 13 ++++++------- libs/librrgraph/src/base/rr_graph_storage.h | 2 +- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/libs/librrgraph/src/base/rr_graph_storage.cpp b/libs/librrgraph/src/base/rr_graph_storage.cpp index 21a67cd354..22fb62da48 100644 --- a/libs/librrgraph/src/base/rr_graph_storage.cpp +++ b/libs/librrgraph/src/base/rr_graph_storage.cpp @@ -815,7 +815,7 @@ void t_rr_graph_storage::set_node_direction(RRNodeId id, Direction new_direction node_storage_[id].dir_side_.direction = new_direction; } -void set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) { +void t_rr_graph_storage::set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) { VTR_ASSERT(size_t(node) < node_storage_.size()); std::vector ptc_tokens = vtr::StringToken(ptc_str).split(","); VTR_ASSERT(ptc_tokens.size() >= 1); @@ -829,7 +829,7 @@ void set_node_ptc_nums(RRNodeId node, const std::string& ptc_str) { } } -void t_rr_graph_storage::add_node_tilable_track_num(RRNodeId node, vtr::Point node_offset, short track_id) { +void t_rr_graph_storage::add_node_tilable_track_num(RRNodeId node, size_t node_offset, short track_id) { VTR_ASSERT(size_t(node) < node_storage_.size()); VTR_ASSERT(size_t(node) < node_tilable_track_nums_.size()); VTR_ASSERT_MSG(node_type(node) == e_rr_type::CHANX || node_type(node) == e_rr_type::CHANY, @@ -841,19 +841,18 @@ void t_rr_graph_storage::add_node_tilable_track_num(RRNodeId node, vtr::Point node_offset, short track_id); + void add_node_tilable_track_num(RRNodeId node, size_t node_offset, short track_id); void emplace_back_node_tilable_track_num(); From 2dc929edc4ac468c6b88082b8c695b06c0d5a5be Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Mon, 27 Oct 2025 13:35:17 -0700 Subject: [PATCH 073/120] [libs][librrgraph][builder] calculate node offset before calling add_node_tilable_track_num --- libs/librrgraph/src/base/rr_graph_builder.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libs/librrgraph/src/base/rr_graph_builder.cpp b/libs/librrgraph/src/base/rr_graph_builder.cpp index da23f82e15..a9fc82322c 100644 --- a/libs/librrgraph/src/base/rr_graph_builder.cpp +++ b/libs/librrgraph/src/base/rr_graph_builder.cpp @@ -238,7 +238,8 @@ bool RRGraphBuilder::node_contain_multiple_ptc(RRNodeId node) const { } void RRGraphBuilder::add_node_track_num(RRNodeId node, vtr::Point node_offset, short track_id) { - node_storage_.add_node_tilable_track_num(node, node_offset, track_id); + size_t node_offset_value = node_offset.x() - node_storage_.node_xlow(node) + node_offset.y() - node_storage_.node_ylow(node); + node_storage_.add_node_tilable_track_num(node, node_offset_value, track_id); } void RRGraphBuilder::add_track_node_to_lookup(RRNodeId node) { From 6086a64d145579dc5fa43a97f42c20741ea46e77 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 06:13:38 -0700 Subject: [PATCH 074/120] [vpr][route][crr] change function name to build_crr_gsb_track_to_track_edges --- .../tileable_rr_graph/crr_generator/crr_edge_builder.cpp | 6 +++--- .../tileable_rr_graph/crr_generator/crr_edge_builder.h | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp index 4637822949..e9d34f303a 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.cpp @@ -2,9 +2,9 @@ #include "crr_connection_builder.h" -void build_gsb_track_to_track_map(RRGraphBuilder& rr_graph_builder, - const RRGSB& rr_gsb, - const crrgenerator::CRRConnectionBuilder& connection_builder) { +void build_crr_gsb_track_to_track_edges(RRGraphBuilder& rr_graph_builder, + const RRGSB& rr_gsb, + const crrgenerator::CRRConnectionBuilder& connection_builder) { size_t gsb_x = rr_gsb.get_sb_x(); size_t gsb_y = rr_gsb.get_sb_y(); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h index 890f55a39c..2730c1aab8 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_edge_builder.h @@ -16,6 +16,6 @@ #include "crr_connection_builder.h" -void build_gsb_track_to_track_edges(RRGraphBuilder& rr_graph_builder, - const RRGSB& rr_gsb, - const crrgenerator::CRRConnectionBuilder& connection_builder); +void build_crr_gsb_track_to_track_edges(RRGraphBuilder& rr_graph_builder, + const RRGSB& rr_gsb, + const crrgenerator::CRRConnectionBuilder& connection_builder); From 88afdce88a629d65b19ed00123f2225eb8474c41 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 06:49:17 -0700 Subject: [PATCH 075/120] [vpr][route][crr] change node type to e_rr_type in crr ds and remove get node type function --- .../crr_generator/custom_rr_graph.cpp | 10 ---------- .../crr_generator/custom_rr_graph.h | 18 +++++++++--------- 2 files changed, 9 insertions(+), 19 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp index 664d934671..b7d5034e7a 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp @@ -132,16 +132,6 @@ void RRGraph::print_statistics() const { } } -std::vector RRGraph::get_nodes_by_type(NodeType type) const { - std::vector result; - for (const auto& node : nodes_) { - if (node.get_type() == type) { - result.push_back(node.get_id()); - } - } - return result; -} - std::unordered_set RRGraph::get_source_nodes() const { std::unordered_set result; for (const auto& node : nodes_) { diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h index 822b837a17..553db8840a 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h @@ -2,6 +2,7 @@ #include "crr_common.h" +#include "rr_node_types.h" namespace crrgenerator { /** @@ -10,7 +11,7 @@ namespace crrgenerator { class RRNode { public: RRNode() = default; - RRNode(NodeId id, NodeType type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id) + RRNode(NodeId id, e_rr_type type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id) : id_(id) , type_(type) , capacity_(capacity) @@ -21,7 +22,7 @@ class RRNode { // Getters NodeId get_id() const { return id_; } - NodeType get_type() const { return type_; } + e_rr_type get_type() const { return type_; } int get_capacity() const { return capacity_; } const std::string& get_direction() const { return direction_; } const Location& get_location() const { return location_; } @@ -31,7 +32,7 @@ class RRNode { // Setters void set_id(NodeId id) { id_ = id; } - void set_type(NodeType type) { type_ = type; } + void set_type(e_rr_type type) { type_ = type; } void set_capacity(int capacity) { capacity_ = capacity; } void set_direction(const std::string& direction) { direction_ = direction; } void set_location(const Location& location) { location_ = location; } @@ -39,10 +40,10 @@ class RRNode { void set_segment(const NodeSegmentId& segment_id) { segment_id_ = segment_id; } // Utility methods - NodeHash get_hash() const { - return std::make_tuple(type_, location_.ptc, location_.x_low, - location_.x_high, location_.y_low, location_.y_high); - } + // NodeHash get_hash() const { + // return std::make_tuple(type_, location_.ptc, location_.x_low, + // location_.x_high, location_.y_low, location_.y_high); + // } bool is_single_coordinate() const { return (location_.x_low == location_.x_high) && (location_.y_low == location_.y_high); @@ -58,7 +59,7 @@ class RRNode { private: NodeId id_{0}; - NodeType type_{NodeType::INVALID}; + e_rr_type type_{e_rr_type::NUM_RR_TYPES}; int capacity_{-1}; std::string direction_; Location location_; @@ -455,7 +456,6 @@ class RRGraph { void print_statistics() const; // Node categorization - std::vector get_nodes_by_type(NodeType type) const; std::unordered_set get_source_nodes() const; std::unordered_set get_sink_nodes() const; std::unordered_set get_ipin_nodes() const; From 21998d9acbd352109618cbfefb123fbd2f8d94cf Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 06:57:32 -0700 Subject: [PATCH 076/120] [vpr][route][crr] use rr_graph to access loc in index_node --- .../crr_generator/node_lookup_manager.cpp | 27 ++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index 9366e5be45..8b06c9bd06 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -107,29 +107,32 @@ NodeHash NodeLookupManager::build_node_hash(RRNodeId node_id) const { } void NodeLookupManager::index_node(RRNodeId node_id) { - NodeHash hash = build_node_hash(node); - const RRNode* node_ptr = &node; + NodeHash hash = build_node_hash(node_id); - const Location& loc = node.get_location(); + short x_low = rr_graph_.node_xlow(node_id); + short x_high = rr_graph_.node_xhigh(node_id); + short y_low = rr_graph_.node_ylow(node_id); + short y_high = rr_graph_.node_yhigh(node_id); - VTR_ASSERT(loc.x_low <= fpga_grid_x_); - VTR_ASSERT(loc.x_high <= fpga_grid_x_); - VTR_ASSERT(loc.y_low <= fpga_grid_y_); - VTR_ASSERT(loc.y_high <= fpga_grid_y_); + + VTR_ASSERT(x_low <= fpga_grid_x_); + VTR_ASSERT(x_high <= fpga_grid_x_); + VTR_ASSERT(y_low <= fpga_grid_y_); + VTR_ASSERT(y_high <= fpga_grid_y_); // Skip spatial indexing for source/sink nodes - if (node.get_type() == NodeType::SOURCE || node.get_type() == NodeType::SINK) { + if (rr_graph_.node_type(node_id) == e_rr_type::SOURCE || rr_graph_.node_type(node_id) == e_rr_type::SINK) { return; } // Add to column lookup (for single-column nodes) - if (loc.x_low == loc.x_high) { - column_lookup_[static_cast(loc.x_low)][hash] = RRNodeId(node_ptr->get_id()); + if (x_low == x_high) { + column_lookup_[static_cast(x_low)][hash] = node_id; } // Add to row lookup (for single-row nodes) - if (loc.y_low == loc.y_high) { - row_lookup_[static_cast(loc.y_low)][hash] = RRNodeId(node_ptr->get_id()); + if (y_low == y_high) { + row_lookup_[static_cast(y_low)][hash] = node_id; } } From 44990a9881270d79fdfe00c67f6d105b6555bf7c Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 08:17:03 -0700 Subject: [PATCH 077/120] [vpr][route][crr] fix typing issues in crr_common --- .../crr_generator/crr_common.h | 40 ++++++------------- 1 file changed, 13 insertions(+), 27 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h index 95a7a38258..9042fbf2b4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h @@ -28,6 +28,7 @@ #include // For getrusage on Unix/Linux #include "rr_graph_fwd.h" +#include "rr_node_types.h" namespace crrgenerator { // Forward declarations @@ -182,30 +183,18 @@ class Connection { SwitchId switch_id_; }; -// Hash function for Location -struct LocationHash { - std::size_t operator()(const Location& loc) const { - auto h1 = std::hash{}(loc.x_low); - auto h2 = std::hash{}(loc.x_high); - auto h3 = std::hash{}(loc.y_low); - auto h4 = std::hash{}(loc.y_high); - auto h5 = std::hash{}(loc.ptc); - return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 3) ^ (h5 << 4); - } -}; - // Node hash type for lookups -using NodeHash = std::tuple; +using NodeHash = std::tuple; // Hash function for NodeHash struct NodeHasher { std::size_t operator()(const NodeHash& hash) const { auto h1 = std::hash{}(static_cast(std::get<0>(hash))); auto h2 = std::hash{}(std::get<1>(hash)); - auto h3 = std::hash{}(std::get<2>(hash)); - auto h4 = std::hash{}(std::get<3>(hash)); - auto h5 = std::hash{}(std::get<4>(hash)); - auto h6 = std::hash{}(std::get<5>(hash)); + auto h3 = std::hash{}(std::get<2>(hash)); + auto h4 = std::hash{}(std::get<3>(hash)); + auto h5 = std::hash{}(std::get<4>(hash)); + auto h6 = std::hash{}(std::get<5>(hash)); // Combine hashes using a better mixing function std::size_t result = h1; @@ -219,9 +208,6 @@ struct NodeHasher { } }; -// Edge hash type for lookups -using EdgeKey = std::tuple; - // Utility functions inline std::string to_string(NodeType type) { switch (type) { @@ -242,13 +228,13 @@ inline std::string to_string(NodeType type) { } } -inline NodeType string_to_node_type(const std::string& str) { - if (str == "SOURCE" || str == "source") return NodeType::SOURCE; - if (str == "SINK" || str == "sink") return NodeType::SINK; - if (str == "IPIN" || str == "ipin") return NodeType::IPIN; - if (str == "OPIN" || str == "opin") return NodeType::OPIN; - if (str == "CHANX" || str == "chanx") return NodeType::CHANX; - if (str == "CHANY" || str == "chany") return NodeType::CHANY; +inline e_rr_type string_to_node_type(const std::string& str) { + if (str == "SOURCE" || str == "source") return e_rr_type::SOURCE; + if (str == "SINK" || str == "sink") return e_rr_type::SINK; + if (str == "IPIN" || str == "ipin") return e_rr_type::IPIN; + if (str == "OPIN" || str == "opin") return e_rr_type::OPIN; + if (str == "CHANX" || str == "chanx") return e_rr_type::CHANX; + if (str == "CHANY" || str == "chany") return e_rr_type::CHANY; throw std::invalid_argument("Unknown node type: " + str); } From fc88092b6aac33ac499b6620ebced688c23b7bf8 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 08:18:44 -0700 Subject: [PATCH 078/120] [vpr][route][crr] comment parts releated to switch in connection builder --- .../crr_generator/crr_connection_builder.cpp | 125 +++++++++--------- .../crr_generator/crr_connection_builder.h | 2 - 2 files changed, 63 insertions(+), 64 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index cde330d498..2d6b702061 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -53,11 +53,9 @@ static bool is_integer(const std::string& s) { // } CRRConnectionBuilder::CRRConnectionBuilder(const RRGraphView& rr_graph, - const RRGraph& crr_graph, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager) : rr_graph_(rr_graph) - , crr_graph_(crr_graph) , node_lookup_(node_lookup) , sb_manager_(sb_manager) {} @@ -70,39 +68,39 @@ void CRRConnectionBuilder::initialize( fpga_grid_y_ = fpga_grid_y; is_annotated_excel_ = is_annotated_excel; - for (const auto& original_switch : crr_graph_.get_switches()) { - std::string switch_name = original_switch.get_name(); - std::transform(switch_name.begin(), switch_name.end(), switch_name.begin(), - ::tolower); - - if (switch_name.find("delayless") != std::string::npos) { - VTR_LOG("Adding delayless switch: %s\n", switch_name.c_str()); - default_switch_id_["delayless"] = original_switch.get_id(); - } else if (switch_name.find("ipin") != std::string::npos) { - VTR_LOG("Adding ipin switch: %s\n", switch_name.c_str()); - default_switch_id_["ipin"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l1(_.*)?)"))) { - VTR_LOG("Adding l1 switch: %s\n", switch_name.c_str()); - default_switch_id_["l1"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l2(_.*)?)"))) { - VTR_LOG("Adding l2 switch: %s\n", switch_name.c_str()); - default_switch_id_["l2"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l4(_.*)?)"))) { - VTR_LOG("Adding l4 switch: %s\n", switch_name.c_str()); - default_switch_id_["l4"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l8(_.*)?)"))) { - VTR_LOG("Adding l8 switch: %s\n", switch_name.c_str()); - default_switch_id_["l8"] = original_switch.get_id(); - } else if (std::regex_match(switch_name, std::regex(R"(l12(_.*)?)"))) { - VTR_LOG("Adding l12 switch: %s\n", switch_name.c_str()); - default_switch_id_["l12"] = original_switch.get_id(); - } else { - VTR_LOG_ERROR("Unknown switch type: %s\n", switch_name.c_str()); - } - } - - assert(default_switch_id_.size() == crr_graph_.get_switches().size()); - sw_zero_id_ = static_cast(crr_graph_.get_switches().size()); + // for (const auto& original_switch : rr_graph_.rr_switches()) { + // std::string switch_name = original_switch.name; + // std::transform(switch_name.begin(), switch_name.end(), switch_name.begin(), + // ::tolower); + + // if (switch_name.find("delayless") != std::string::npos) { + // VTR_LOG("Adding delayless switch: %s\n", switch_name.c_str()); + // default_switch_id_["delayless"] = original_switch.get_id(); + // } else if (switch_name.find("ipin") != std::string::npos) { + // VTR_LOG("Adding ipin switch: %s\n", switch_name.c_str()); + // default_switch_id_["ipin"] = original_switch.get_id(); + // } else if (std::regex_match(switch_name, std::regex(R"(l1(_.*)?)"))) { + // VTR_LOG("Adding l1 switch: %s\n", switch_name.c_str()); + // default_switch_id_["l1"] = original_switch.get_id(); + // } else if (std::regex_match(switch_name, std::regex(R"(l2(_.*)?)"))) { + // VTR_LOG("Adding l2 switch: %s\n", switch_name.c_str()); + // default_switch_id_["l2"] = original_switch.get_id(); + // } else if (std::regex_match(switch_name, std::regex(R"(l4(_.*)?)"))) { + // VTR_LOG("Adding l4 switch: %s\n", switch_name.c_str()); + // default_switch_id_["l4"] = original_switch.get_id(); + // } else if (std::regex_match(switch_name, std::regex(R"(l8(_.*)?)"))) { + // VTR_LOG("Adding l8 switch: %s\n", switch_name.c_str()); + // default_switch_id_["l8"] = original_switch.get_id(); + // } else if (std::regex_match(switch_name, std::regex(R"(l12(_.*)?)"))) { + // VTR_LOG("Adding l12 switch: %s\n", switch_name.c_str()); + // default_switch_id_["l12"] = original_switch.get_id(); + // } else { + // VTR_LOG_ERROR("Unknown switch type: %s\n", switch_name.c_str()); + // } + // } + + // assert(default_switch_id_.size() == crr_graph_.get_switches().size()); + // sw_zero_id_ = static_cast(crr_graph_.get_switches().size()); // Total locations is the number of locations on the FPGA grid minus the 4 // corner locations. @@ -275,7 +273,8 @@ std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate return sink_nodes; } -CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const DataFrame& df, size_t row_or_col, +CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const DataFrame& df, + size_t row_or_col, bool is_vertical) const { SegmentInfo info; @@ -326,12 +325,12 @@ CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const } RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const { + const std::unordered_map& node_lookup) const { assert(info.side == Side::OPIN || info.side == Side::IPIN); - NodeType node_type = - (info.side == Side::OPIN) ? NodeType::OPIN : NodeType::IPIN; - NodeHash hash = - std::make_tuple(node_type, std::to_string(info.seg_index), x, x, y, y); + e_rr_type node_type = (info.side == Side::OPIN) ? e_rr_type::OPIN : e_rr_type::IPIN; + NodeHash hash = std::make_tuple(node_type, + std::to_string(info.seg_index), + x, x, y, y); auto it = node_lookup.find(hash); if (it != node_lookup.end()) { @@ -385,7 +384,8 @@ RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coo // Create node hash and lookup NodeHash hash = std::make_tuple(string_to_node_type(seg_type_label), - seg_sequence, x_low, x_high, y_low, y_high); + seg_sequence, + x_low, x_high, y_low, y_high); auto it = node_lookup.find(hash); if (it != node_lookup.end()) { @@ -539,31 +539,32 @@ SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, // TODO: This is a temporary solution. We need to have an API call to get // the switch id from delay. if (cell_value == "0") { - return sw_zero_id_; + return static_cast(0); } int switch_delay_ps = std::stoi(cell_value); int switch_id = switch_delay_ps; return static_cast(switch_id); } else { - std::string switch_id_key = ""; - if (segment_length > 0) { - switch_id_key = "l" + std::to_string(segment_length); - } else { - switch_id_key = lower_case_sink_node_type; - } - - std::string capitalized_switch_id_key = switch_id_key; - std::transform(capitalized_switch_id_key.begin(), - capitalized_switch_id_key.end(), - capitalized_switch_id_key.begin(), ::toupper); - - if (default_switch_id_.find(switch_id_key) != default_switch_id_.end()) { - return default_switch_id_.at(switch_id_key); - } else if (default_switch_id_.find(capitalized_switch_id_key) != default_switch_id_.end()) { - return default_switch_id_.at(capitalized_switch_id_key); - } else { - throw std::runtime_error("Default switch id not found for Node Type: " + lower_case_sink_node_type + " and Switch ID Key: " + capitalized_switch_id_key); - } + VTR_LOG_ERROR("Not implemented - get_edge_switch_id\n"); + // std::string switch_id_key = ""; + // if (segment_length > 0) { + // switch_id_key = "l" + std::to_string(segment_length); + // } else { + // switch_id_key = lower_case_sink_node_type; + // } + + // std::string capitalized_switch_id_key = switch_id_key; + // std::transform(capitalized_switch_id_key.begin(), + // capitalized_switch_id_key.end(), + // capitalized_switch_id_key.begin(), ::toupper); + + // if (default_switch_id_.find(switch_id_key) != default_switch_id_.end()) { + // return default_switch_id_.at(switch_id_key); + // } else if (default_switch_id_.find(capitalized_switch_id_key) != default_switch_id_.end()) { + // return default_switch_id_.at(capitalized_switch_id_key); + // } else { + // throw std::runtime_error("Default switch id not found for Node Type: " + lower_case_sink_node_type + " and Switch ID Key: " + capitalized_switch_id_key); + // } } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index 103ab7abf4..99ae67a0e7 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -21,7 +21,6 @@ namespace crrgenerator { class CRRConnectionBuilder { public: CRRConnectionBuilder(const RRGraphView& rr_graph, - const RRGraph& crr_graph, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager); @@ -90,7 +89,6 @@ class CRRConnectionBuilder { // Dependencies const RRGraphView& rr_graph_; - const RRGraph& crr_graph_; const NodeLookupManager& node_lookup_; const SwitchBlockManager& sb_manager_; SwitchId sw_zero_id_; From a393fbe7477f8afafab826dce5712d8c69b9f522 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 08:22:44 -0700 Subject: [PATCH 079/120] [vpr][route][crr] comment out parts not used in crr generator --- .../crr_generator/crr_generator.cpp | 248 +++++++++--------- .../crr_generator/crr_generator.h | 8 +- 2 files changed, 129 insertions(+), 127 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp index 3834572272..59f75c8e59 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.cpp @@ -9,7 +9,7 @@ namespace crrgenerator { CRRGraphGenerator::CRRGraphGenerator(const t_crr_opts& crr_opts, - const RRGraph& input_graph, + const RRGraphView& input_graph, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager, const std::string& output_graph_xml) @@ -57,7 +57,9 @@ void CRRGraphGenerator::initialize_components() { xml_handler_ = std::make_unique(); // Initialize connection builder - connection_builder_ = std::make_unique(input_graph_, node_lookup_, sb_manager_); + connection_builder_ = std::make_unique(input_graph_, + node_lookup_, + sb_manager_); // Initialize thread pool if parallel processing is enabled VTR_ASSERT(crr_opts_.crr_num_threads > 0); @@ -80,112 +82,112 @@ void CRRGraphGenerator::build_connections() { VTR_LOG("CRR Graph Generator: Connection building completed\n"); } -void CRRGraphGenerator::create_output_graph() { - VTR_LOG("CRR Graph Generator: Creating output graph\n"); - - // Create new graph based on input graph - output_graph_ = std::make_unique(input_graph_); - - // Add new switches to output graph - if (crr_opts_.annotated_rr_graph) { - size_t nxt_switch_id = - connection_builder_->get_default_swithes_map().size(); - int max_sw_delay_ps = sb_manager_.get_max_switch_delay_ps(); - std::string default_sw_type = ""; - Timing default_timing; - Sizing default_sizing; - - // Get default timing and sizing from input graph - for (const auto& graph_sw : input_graph_.get_switches()) { - std::string sw_name = graph_sw.get_name(); - std::transform(sw_name.begin(), sw_name.end(), sw_name.begin(), - ::tolower); - if (sw_name.find("l1") != std::string::npos || sw_name.find("l4") != std::string::npos) { - default_sw_type = graph_sw.get_type(); - default_timing = graph_sw.get_timing(); - default_sizing = graph_sw.get_sizing(); - } - } - - // Add sw_zero switch - we don't use delayless switch because OpenFPGA doesn't work with it. - Switch sw_zero(static_cast(nxt_switch_id), "sw_zero", default_sw_type, Timing(0, 0), default_sizing); - output_graph_->add_switch(sw_zero); - - // Add new switches to output graph - for (int curr_sw_delay_ps = static_cast(nxt_switch_id) + 1; - curr_sw_delay_ps <= max_sw_delay_ps; curr_sw_delay_ps++) { - float curr_sw_delay_s = static_cast(curr_sw_delay_ps) * 1e-12f; - Switch curr_switch( - static_cast(curr_sw_delay_ps), - "sw_" + std::to_string(curr_sw_delay_ps), default_sw_type, - Timing(default_timing.Cin, curr_sw_delay_s), default_sizing); - VTR_LOG_DEBUG("Adding switch: %s with delay: %e s\n", curr_switch.get_name().c_str(), curr_sw_delay_s); - output_graph_->add_switch(curr_switch); - } - } - - // Get all connections from connection builder - auto all_connections = connection_builder_->get_all_connections(); - - auto preserved_edges = input_graph_.get_preserved_edges( - crr_opts_.preserve_pin_connections); - VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu\n", preserved_edges.size()); - - // Clear existing edges and add new ones - output_graph_->get_edges().clear(); - - // Add preserved edges - for (const auto& edge : preserved_edges) { - output_graph_->add_edge(edge); - } - - add_custom_edges(); - - output_graph_->sort_nodes(); - output_graph_->sort_edges(); - output_graph_->shrink_to_fit(); - - VTR_LOG("CRR Graph Generator: Output graph created with %zu edges\n", - output_graph_->get_edge_count()); -} - -void CRRGraphGenerator::add_custom_edges() { - VTR_LOG("CRR Graph Generator: Adding custom edges\n"); - - // Add new connections - const DeviceGrid& grid = g_vpr_ctx.device().grid; - size_t total_tiles = - static_cast((grid.width() + 1 - 2) * (grid.height() + 1 - 2)); - ProgressTracker tracker(total_tiles, "Adding new connections"); - std::vector> futures; - std::mutex graph_mutex; - - for (Coordinate tile_x = 0; tile_x <= grid.width() - 2; tile_x++) { - for (Coordinate tile_y = 0; tile_y <= grid.height() - 2; tile_y++) { - auto fut = thread_pool_->submit([this, tile_x, tile_y, &graph_mutex, &tracker]() { - std::vector tile_connections = - connection_builder_->get_tile_connections(tile_x, tile_y); - - { - std::lock_guard lock(graph_mutex); - for (const auto& connection : tile_connections) { - output_graph_->add_edge(connection.src_node(), - connection.sink_node(), - connection.switch_id()); - } - } - - tracker.increment(); - }); - futures.push_back(std::move(fut)); - } - } - - // Wait for all tasks to complete - for (auto& fut : futures) { - fut.get(); - } -} +// void CRRGraphGenerator::create_output_graph() { +// VTR_LOG("CRR Graph Generator: Creating output graph\n"); + +// // Create new graph based on input graph +// output_graph_ = std::make_unique(input_graph_); + +// // Add new switches to output graph +// if (crr_opts_.annotated_rr_graph) { +// size_t nxt_switch_id = +// connection_builder_->get_default_swithes_map().size(); +// int max_sw_delay_ps = sb_manager_.get_max_switch_delay_ps(); +// std::string default_sw_type = ""; +// Timing default_timing; +// Sizing default_sizing; + +// // Get default timing and sizing from input graph +// for (const auto& graph_sw : input_graph_.get_switches()) { +// std::string sw_name = graph_sw.get_name(); +// std::transform(sw_name.begin(), sw_name.end(), sw_name.begin(), +// ::tolower); +// if (sw_name.find("l1") != std::string::npos || sw_name.find("l4") != std::string::npos) { +// default_sw_type = graph_sw.get_type(); +// default_timing = graph_sw.get_timing(); +// default_sizing = graph_sw.get_sizing(); +// } +// } + +// // Add sw_zero switch - we don't use delayless switch because OpenFPGA doesn't work with it. +// Switch sw_zero(static_cast(nxt_switch_id), "sw_zero", default_sw_type, Timing(0, 0), default_sizing); +// output_graph_->add_switch(sw_zero); + +// // Add new switches to output graph +// for (int curr_sw_delay_ps = static_cast(nxt_switch_id) + 1; +// curr_sw_delay_ps <= max_sw_delay_ps; curr_sw_delay_ps++) { +// float curr_sw_delay_s = static_cast(curr_sw_delay_ps) * 1e-12f; +// Switch curr_switch( +// static_cast(curr_sw_delay_ps), +// "sw_" + std::to_string(curr_sw_delay_ps), default_sw_type, +// Timing(default_timing.Cin, curr_sw_delay_s), default_sizing); +// VTR_LOG_DEBUG("Adding switch: %s with delay: %e s\n", curr_switch.get_name().c_str(), curr_sw_delay_s); +// output_graph_->add_switch(curr_switch); +// } +// } + +// // Get all connections from connection builder +// auto all_connections = connection_builder_->get_all_connections(); + +// auto preserved_edges = input_graph_.get_preserved_edges( +// crr_opts_.preserve_pin_connections); +// VTR_LOG("CRR Graph Generator: Number of preserved edges: %zu\n", preserved_edges.size()); + +// // Clear existing edges and add new ones +// output_graph_->get_edges().clear(); + +// // Add preserved edges +// for (const auto& edge : preserved_edges) { +// output_graph_->add_edge(edge); +// } + +// add_custom_edges(); + +// output_graph_->sort_nodes(); +// output_graph_->sort_edges(); +// output_graph_->shrink_to_fit(); + +// VTR_LOG("CRR Graph Generator: Output graph created with %zu edges\n", +// output_graph_->get_edge_count()); +// } + +// void CRRGraphGenerator::add_custom_edges() { +// VTR_LOG("CRR Graph Generator: Adding custom edges\n"); + +// // Add new connections +// const DeviceGrid& grid = g_vpr_ctx.device().grid; +// size_t total_tiles = +// static_cast((grid.width() + 1 - 2) * (grid.height() + 1 - 2)); +// ProgressTracker tracker(total_tiles, "Adding new connections"); +// std::vector> futures; +// std::mutex graph_mutex; + +// for (Coordinate tile_x = 0; tile_x <= grid.width() - 2; tile_x++) { +// for (Coordinate tile_y = 0; tile_y <= grid.height() - 2; tile_y++) { +// auto fut = thread_pool_->submit([this, tile_x, tile_y, &graph_mutex, &tracker]() { +// std::vector tile_connections = +// connection_builder_->get_tile_connections(tile_x, tile_y); + +// { +// std::lock_guard lock(graph_mutex); +// for (const auto& connection : tile_connections) { +// output_graph_->add_edge(connection.src_node(), +// connection.sink_node(), +// connection.switch_id()); +// } +// } + +// tracker.increment(); +// }); +// futures.push_back(std::move(fut)); +// } +// } + +// // Wait for all tasks to complete +// for (auto& fut : futures) { +// fut.get(); +// } +// } void CRRGraphGenerator::write_output_files() { if (!output_graph_xml_.empty()) { @@ -198,26 +200,26 @@ void CRRGraphGenerator::write_output_files() { } void CRRGraphGenerator::print_processing_summary() { - VTR_LOG("CRR Graph Generator: === Processing Summary ===\n"); + // VTR_LOG("CRR Graph Generator: === Processing Summary ===\n"); - VTR_LOG("CRR Graph Generator: Input graph:\n"); - VTR_LOG(" Nodes: %zu\n", input_graph_.get_node_count()); - VTR_LOG(" Edges: %zu\n", input_graph_.get_edge_count()); - VTR_LOG(" Switches: %zu\n", input_graph_.get_switch_count()); + // VTR_LOG("CRR Graph Generator: Input graph:\n"); + // VTR_LOG(" Nodes: %zu\n", input_graph_.get_node_count()); + // VTR_LOG(" Edges: %zu\n", input_graph_.get_edge_count()); + // VTR_LOG(" Switches: %zu\n", input_graph_.get_switch_count()); - VTR_LOG("CRR Graph Generator: Output graph:\n"); - VTR_LOG(" Nodes: %zu\n", output_graph_->get_node_count()); - VTR_LOG(" Edges: %zu\n", output_graph_->get_edge_count()); - VTR_LOG(" Switches: %zu\n", output_graph_->get_switch_count()); + // VTR_LOG("CRR Graph Generator: Output graph:\n"); + // VTR_LOG(" Nodes: %zu\n", output_graph_->get_node_count()); + // VTR_LOG(" Edges: %zu\n", output_graph_->get_edge_count()); + // VTR_LOG(" Switches: %zu\n", output_graph_->get_switch_count()); - int new_edges = - static_cast(output_graph_->get_edge_count()) - static_cast(input_graph_.get_edge_count()); - VTR_LOG(" New edges added: %d\n", new_edges); + // int new_edges = + // static_cast(output_graph_->get_edge_count()) - static_cast(input_graph_.get_edge_count()); + // VTR_LOG(" New edges added: %d\n", new_edges); - VTR_LOG("Switch blocks processed: %zu\n", sb_manager_.get_all_patterns().size()); - VTR_LOG("Total connections: %zu\n", sb_manager_.get_total_connections()); + // VTR_LOG("Switch blocks processed: %zu\n", sb_manager_.get_all_patterns().size()); + // VTR_LOG("Total connections: %zu\n", sb_manager_.get_total_connections()); - VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width() - 2, g_vpr_ctx.device().grid.height() - 2); + // VTR_LOG("Grid locations processed: %dx%d\n", g_vpr_ctx.device().grid.width() - 2, g_vpr_ctx.device().grid.height() - 2); } void CRRGraphGenerator::validate_processing_results() { diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h index 6e6d9aa73d..6f2ffaf981 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_generator.h @@ -23,7 +23,7 @@ namespace crrgenerator { class CRRGraphGenerator { public: CRRGraphGenerator(const t_crr_opts& crr_opts, - const RRGraph& input_graph, + const RRGraphView& input_graph, const NodeLookupManager& node_lookup, const SwitchBlockManager& sb_manager, const std::string& output_graph_xml); @@ -40,7 +40,7 @@ class CRRGraphGenerator { private: const t_crr_opts& crr_opts_; - const RRGraph& input_graph_; + const RRGraphView& input_graph_; const NodeLookupManager& node_lookup_; const SwitchBlockManager& sb_manager_; const std::string& output_graph_xml_; @@ -54,8 +54,8 @@ class CRRGraphGenerator { void initialize_components(); void process_switch_blocks(); void build_connections(); - void create_output_graph(); - void add_custom_edges(); + // void create_output_graph(); + // void add_custom_edges(); void write_output_files(); // Utility methods From 38ee748759efa0fc7f12909e04ab2a1e3b7ea39b Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 08:24:59 -0700 Subject: [PATCH 080/120] [vpr][route][crr] use e_rr_type for node type in custom_rr_graph --- .../crr_generator/custom_rr_graph.cpp | 14 +++++++------- .../crr_generator/custom_rr_graph.h | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp index b7d5034e7a..175d3d9523 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.cpp @@ -11,7 +11,7 @@ void RRGraph::add_node(const RRNode& node) { update_node_index(node.get_id(), nodes_.size() - 1); } -void RRGraph::add_node(NodeId id, NodeType type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id) { +void RRGraph::add_node(NodeId id, e_rr_type type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id) { add_node(RRNode(id, type, capacity, direction, location, timing, segment_id)); } @@ -117,13 +117,13 @@ void RRGraph::print_statistics() const { VTR_LOG("Segments: %zu\n", segments_.size()); // Count nodes by type - std::map type_counts; + std::map type_counts; for (const auto& node : nodes_) { type_counts[node.get_type()]++; } for (const auto& [type, count] : type_counts) { - VTR_LOG(" %s nodes: %zu\n", to_string(type), count); + VTR_LOG(" %s nodes: %zu\n", rr_node_typename[type], count); } VTR_LOG("Tool: %s v%s\n", tool_name_.c_str(), tool_version_.c_str()); @@ -135,7 +135,7 @@ void RRGraph::print_statistics() const { std::unordered_set RRGraph::get_source_nodes() const { std::unordered_set result; for (const auto& node : nodes_) { - if (node.get_type() == NodeType::SOURCE) { + if (node.get_type() == e_rr_type::SOURCE) { result.insert(node.get_id()); } } @@ -145,7 +145,7 @@ std::unordered_set RRGraph::get_source_nodes() const { std::unordered_set RRGraph::get_sink_nodes() const { std::unordered_set result; for (const auto& node : nodes_) { - if (node.get_type() == NodeType::SINK) { + if (node.get_type() == e_rr_type::SINK) { result.insert(node.get_id()); } } @@ -155,7 +155,7 @@ std::unordered_set RRGraph::get_sink_nodes() const { std::unordered_set RRGraph::get_ipin_nodes() const { std::unordered_set result; for (const auto& node : nodes_) { - if (node.get_type() == NodeType::IPIN) { + if (node.get_type() == e_rr_type::IPIN) { result.insert(node.get_id()); } } @@ -165,7 +165,7 @@ std::unordered_set RRGraph::get_ipin_nodes() const { std::unordered_set RRGraph::get_opin_nodes() const { std::unordered_set result; for (const auto& node : nodes_) { - if (node.get_type() == NodeType::OPIN) { + if (node.get_type() == e_rr_type::OPIN) { result.insert(node.get_id()); } } diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h index 553db8840a..c71b53e545 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/custom_rr_graph.h @@ -366,7 +366,7 @@ class RRGraph { // Node management void add_node(const RRNode& node); - void add_node(NodeId id, NodeType type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id); + void add_node(NodeId id, e_rr_type type, int capacity, const std::string& direction, const Location& location, const NodeTiming& timing, const NodeSegmentId& segment_id); const RRNode* get_node(NodeId id) const; RRNode* get_node(NodeId id); const std::vector& get_nodes() const { return nodes_; } From dae8bc64048013eed2c236a1f141a284d4a8df59 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 08:32:09 -0700 Subject: [PATCH 081/120] [vpr][route][crr] update xml handler with e_rr_type --- .../tileable_rr_graph/crr_generator/xml_handler.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp index 486840d71c..ae55477972 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/xml_handler.cpp @@ -5,6 +5,7 @@ #include "vtr_log.h" #include "vtr_assert.h" +#include "rr_node_types.h" namespace crrgenerator { @@ -351,7 +352,7 @@ void XMLHandler::parse_nodes(const pugi::xml_node& nodes_node, RRGraph& graph) { RRNode XMLHandler::parse_node(const pugi::xml_node& node_xml) { NodeId id = node_xml.attribute("id").as_int(); - NodeType type = string_to_node_type(node_xml.attribute("type").as_string()); + e_rr_type type = string_to_node_type(node_xml.attribute("type").as_string()); int capacity = node_xml.attribute("capacity").as_int(); std::string direction = ""; if (node_xml.attribute("direction")) { @@ -550,7 +551,7 @@ void XMLHandler::write_nodes(std::ostream& out, const RRGraph& graph) { void XMLHandler::write_node(std::ostream& out, const RRNode& n) { out << " \n"; From 3c2350a4199881d1a15712d7c02c0a694153549a Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 08:35:02 -0700 Subject: [PATCH 082/120] [vpr][route][crr] add crr builder to tileable_rr_graph_edge_builder --- .../tileable_rr_graph_edge_builder.cpp | 45 ++++++++++--------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp index be9777205e..8f0d8e48bf 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp @@ -15,7 +15,9 @@ #include "tileable_rr_graph_gsb.h" #include "tileable_rr_graph_edge_builder.h" +#include "crr_generator.h" #include "crr_edge_builder.h" +#include "xml_handler.h" /************************************************************************ * Build the edges for all the SOURCE and SINKs nodes: @@ -327,12 +329,9 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, // Building CRR Graph crrgenerator::SwitchBlockManager sb_manager; sb_manager.initialize(crr_opts.sb_maps, crr_opts.sb_templates, crr_opts.annotated_rr_graph); - std::unique_ptr crr_input_graph; - crrgenerator::XMLHandler xml_handler; - crr_input_graph = xml_handler.read_rr_graph(det_routing_arch.read_rr_graph_filename); - crrgenerator::NodeLookupManager node_lookup; - node_lookup.initialize(*crr_input_graph, grid.width(), grid.height()); - crrgenerator::CRRGraphGenerator parser(crr_opts, *crr_input_graph, node_lookup, sb_manager, det_routing_arch.write_rr_graph_filename); + crrgenerator::NodeLookupManager node_lookup(rr_graph, grids.width(), grids.height()); + node_lookup.initialize(); + crrgenerator::CRRGraphGenerator parser(crr_opts, rr_graph, node_lookup, sb_manager, "vpr_custom_rr_graph.xml"); parser.run(); /* Go Switch Block by Switch Block */ @@ -361,25 +360,27 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, /* adapt the switch_block_conn for the GSB nodes */ t_track2track_map sb_conn; /* [0..from_gsb_side][0..chan_width-1][track_indices] */ if (build_crr_edges) { - sb_conn = build_gsb_crr_track_to_track_map(rr_graph, - rr_gsb, - grids, - segment_inf, - Fc_in, - Fc_out); + build_crr_gsb_track_to_track_edges(rr_graph_builder, rr_gsb, *parser.get_connection_builder()); } else { - build_gsb_track_to_track_edges(rr_graph_builder, rr_gsb, *parser.get_connection_builder()); + sb_conn = build_gsb_track_to_track_map(rr_graph, + rr_gsb, + sb_type, + Fs, + sb_subtype, + sub_fs, + concat_wire, + wire_opposite_side, + segment_inf); + /* Build edges for a GSB */ + build_edges_for_one_tileable_rr_gsb(rr_graph_builder, + rr_gsb, + track2ipin_map, + opin2track_map, + sb_conn, + rr_node_driver_switches, + num_edges_to_create); } - /* Build edges for a GSB */ - build_edges_for_one_tileable_rr_gsb(rr_graph_builder, - rr_gsb, - track2ipin_map, - opin2track_map, - sb_conn, - rr_node_driver_switches, - num_edges_to_create); - /* Finish this GSB, go to the next*/ rr_graph_builder.build_edges(true); } From e3b345f8288c4c910a57ddd58f1ae11e606cc369 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 10:06:54 -0700 Subject: [PATCH 083/120] [vpr][route][crr] use size_t instead of coordinate in node_lookup_manager --- .../crr_generator/node_lookup_manager.cpp | 26 +++++++------------ .../crr_generator/node_lookup_manager.h | 19 ++++---------- 2 files changed, 14 insertions(+), 31 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index 8b06c9bd06..01b3b76ade 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -18,8 +18,8 @@ void NodeLookupManager::initialize() { clear(); // Initialize lookup structures - column_lookup_.resize(static_cast(fpga_grid_x_) + 1); - row_lookup_.resize(static_cast(fpga_grid_y_) + 1); + column_lookup_.resize(fpga_grid_x_ + 1); + row_lookup_.resize(fpga_grid_y_ + 1); // Index all nodes for (RRNodeId node_id : rr_graph_.nodes()) { @@ -30,21 +30,17 @@ void NodeLookupManager::initialize() { print_statistics(); } -const std::unordered_map& NodeLookupManager::get_column_nodes(Coordinate x) const { - if (x <= fpga_grid_x_ && x < static_cast(column_lookup_.size())) { - return column_lookup_[static_cast(x)]; - } - return std::unordered_map(); +const std::unordered_map& NodeLookupManager::get_column_nodes(size_t x) const { + VTR_ASSERT(x <= fpga_grid_x_ && x < column_lookup_.size()); + return column_lookup_[x]; } -const std::unordered_map& NodeLookupManager::get_row_nodes(Coordinate y) const { - if (y <= fpga_grid_y_ && y < static_cast(row_lookup_.size())) { - return row_lookup_[static_cast(y)]; - } - return std::unordered_map(); +const std::unordered_map& NodeLookupManager::get_row_nodes(size_t y) const { + VTR_ASSERT(y <= fpga_grid_y_ && y < row_lookup_.size()); + return row_lookup_[y]; } -std::unordered_map NodeLookupManager::get_combined_nodes(Coordinate x, Coordinate y) const { +std::unordered_map NodeLookupManager::get_combined_nodes(size_t x, size_t y) const { std::unordered_map combined; // Add column nodes @@ -58,10 +54,6 @@ std::unordered_map NodeLookupManager::get_combin return combined; } -bool NodeLookupManager::is_valid_coordinate(Coordinate x, Coordinate y) const { - return x >= 0 && x <= fpga_grid_x_ && y >= 0 && y <= fpga_grid_y_; -} - void NodeLookupManager::print_statistics() const { VTR_LOG("=== Node Lookup Manager Statistics ===\n"); VTR_LOG("Grid dimensions: %d x %d\n", fpga_grid_x_, fpga_grid_y_); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h index 7cda6f7b63..387443bf74 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.h @@ -34,14 +34,14 @@ class NodeLookupManager { * @param x Column coordinate * @return Map of hash to node for nodes in column */ - const std::unordered_map& get_column_nodes(Coordinate x) const; + const std::unordered_map& get_column_nodes(size_t x) const; /** * @brief Get nodes in a specific row * @param y Row coordinate * @return Map of hash to node for nodes in row */ - const std::unordered_map& get_row_nodes(Coordinate y) const; + const std::unordered_map& get_row_nodes(size_t y) const; /** * @brief Get combined nodes for column and row (for switch block processing) @@ -49,15 +49,7 @@ class NodeLookupManager { * @param y Row coordinate * @return Combined map of nodes */ - std::unordered_map get_combined_nodes(Coordinate x, Coordinate y) const; - - /** - * @brief Check if coordinate is valid - * @param x X coordinate - * @param y Y coordinate - * @return true if coordinates are within grid bounds - */ - bool is_valid_coordinate(Coordinate x, Coordinate y) const; + std::unordered_map get_combined_nodes(size_t x, size_t y) const; /** * @brief Print lookup statistics @@ -82,12 +74,11 @@ class NodeLookupManager { std::unordered_map global_lookup_; // Grid dimensions - Coordinate fpga_grid_x_; - Coordinate fpga_grid_y_; + size_t fpga_grid_x_; + size_t fpga_grid_y_; // Helper methods NodeHash build_node_hash(RRNodeId node_id) const; - void validate_coordinates(Coordinate x, Coordinate y) const; void index_node(RRNodeId node_id); }; From 9f723a5c409300ad5b0ab060fa3bd2debe56ce8e Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 10:34:48 -0700 Subject: [PATCH 084/120] [lib][rr_graph][storage] check if node_tilable_track_nums_ is empty before accessing it --- libs/librrgraph/src/base/rr_graph_storage.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/libs/librrgraph/src/base/rr_graph_storage.h b/libs/librrgraph/src/base/rr_graph_storage.h index 05b1abf4dc..fcc236532a 100644 --- a/libs/librrgraph/src/base/rr_graph_storage.h +++ b/libs/librrgraph/src/base/rr_graph_storage.h @@ -696,7 +696,11 @@ class t_rr_graph_storage { void emplace_back_node_tilable_track_num(); bool node_contain_multiple_ptc(RRNodeId node) const { - return node_tilable_track_nums_[node].size() > 1; + if (node_tilable_track_nums_.empty()) { + return false; + } else { + return node_tilable_track_nums_[node].size() > 1; + } } std::string node_ptc_nums_to_string(RRNodeId node) const; From d064a1594a96b10b102c80b39a8fd14cb071fc10 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 10:38:45 -0700 Subject: [PATCH 085/120] [vpr][route][crr] add noexcept to some of the class construtors to fix compiler warnings --- .../tileable_rr_graph/crr_generator/crr_common.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h index 9042fbf2b4..7e22b9e83a 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_common.h @@ -161,7 +161,7 @@ struct Sizing { */ class Connection { public: - Connection(RRNodeId sink_node, RRNodeId src_node, SwitchId switch_id) + Connection(RRNodeId sink_node, RRNodeId src_node, SwitchId switch_id) noexcept : sink_node_(sink_node) , src_node_(src_node) , switch_id_(switch_id) {} @@ -188,7 +188,7 @@ using NodeHash = std::tuple; // Hash function for NodeHash struct NodeHasher { - std::size_t operator()(const NodeHash& hash) const { + std::size_t operator()(const NodeHash& hash) const noexcept { auto h1 = std::hash{}(static_cast(std::get<0>(hash))); auto h2 = std::hash{}(std::get<1>(hash)); auto h3 = std::hash{}(std::get<2>(hash)); From f9c1c66c5a3ee51cecfa9fde0d028159a02b893e Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 10:41:41 -0700 Subject: [PATCH 086/120] [vpr][route][crr] change coordinate to size_t for for connection builder --- .../crr_generator/crr_connection_builder.cpp | 17 +++++++++-------- .../crr_generator/crr_connection_builder.h | 6 +++--- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index 2d6b702061..316c9bc473 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -114,8 +114,8 @@ void CRRConnectionBuilder::initialize( fpga_grid_x_, fpga_grid_y_, total_locations_); } -void CRRConnectionBuilder::build_connections_for_location(Coordinate x, - Coordinate y, +void CRRConnectionBuilder::build_connections_for_location(size_t x, + size_t y, std::vector& tile_connections) const { // Find matching switch block pattern @@ -124,17 +124,17 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, tile_connections.clear(); if (pattern.empty()) { - VTR_LOG_DEBUG("No pattern found for switch block at (%d, %d)\n", x, y); + VTR_LOG_DEBUG("No pattern found for switch block at (%zu, %zu)\n", x, y); return; } const DataFrame* df = sb_manager_.get_switch_block_dataframe(pattern); if (df == nullptr) { - VTR_LOG_WARN("No dataframe found for pattern '%s' at (%d, %d)\n", pattern.c_str(), x, y); + VTR_LOG_WARN("No dataframe found for pattern '%s' at (%zu, %zu)\n", pattern.c_str(), x, y); return; } - VTR_LOG("Processing switch block '%s' with pattern '%s' at (%d, %d)\n", + VTR_LOG("Processing switch block '%s' with pattern '%s' at (%zu, %zu)\n", sw_name.c_str(), pattern.c_str(), x, y); // Get combined nodes for this location @@ -198,11 +198,11 @@ void CRRConnectionBuilder::build_connections_for_location(Coordinate x, tile_connections.end()); tile_connections.shrink_to_fit(); - VTR_LOG_DEBUG("Generated %zu connections for location (%d, %d)\n", + VTR_LOG_DEBUG("Generated %zu connections for location (%zu, %zu)\n", tile_connections.size(), x, y); } -std::vector CRRConnectionBuilder::get_tile_connections(Coordinate tile_x, Coordinate tile_y) const { +std::vector CRRConnectionBuilder::get_tile_connections(size_t tile_x, size_t tile_y) const { std::vector tile_connections; build_connections_for_location(tile_x, tile_y, tile_connections); @@ -529,7 +529,7 @@ std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, RRNodeId /*source_node*/, RRNodeId /*sink_node*/, - int segment_length) const { + int /*segment_length*/) const { std::string lower_case_sink_node_type = sink_node_type; std::transform(lower_case_sink_node_type.begin(), lower_case_sink_node_type.end(), @@ -546,6 +546,7 @@ SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, return static_cast(switch_id); } else { VTR_LOG_ERROR("Not implemented - get_edge_switch_id\n"); + return static_cast(-1); // std::string switch_id_key = ""; // if (segment_length > 0) { // switch_id_key = "l" + std::to_string(segment_length); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index 99ae67a0e7..77d1287e2f 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -40,7 +40,7 @@ class CRRConnectionBuilder { * @param tile_y Tile y coordinate * @return Vector of connections */ - std::vector get_tile_connections(Coordinate tile_x, Coordinate tile_y) const; + std::vector get_tile_connections(size_t tile_x, size_t tile_y) const; /** * @brief Get all generated connections @@ -104,8 +104,8 @@ class CRRConnectionBuilder { std::map default_switch_id_; // Connection building methods - void build_connections_for_location(Coordinate x, - Coordinate y, + void build_connections_for_location(size_t x, + size_t y, std::vector& tile_connections) const; // Node processing methods From 6883c93ce59ae0030c8ca9f550d68e3ad38f8e0a Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 12:47:45 -0700 Subject: [PATCH 087/120] [vpr][route][crr] cast coordinates returned by rr_graph to size_t --- .../crr_generator/node_lookup_manager.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index 01b3b76ade..cbc2f5d118 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -107,10 +107,10 @@ void NodeLookupManager::index_node(RRNodeId node_id) { short y_high = rr_graph_.node_yhigh(node_id); - VTR_ASSERT(x_low <= fpga_grid_x_); - VTR_ASSERT(x_high <= fpga_grid_x_); - VTR_ASSERT(y_low <= fpga_grid_y_); - VTR_ASSERT(y_high <= fpga_grid_y_); + VTR_ASSERT(static_cast(x_low) <= fpga_grid_x_); + VTR_ASSERT(static_cast(x_high) <= fpga_grid_x_); + VTR_ASSERT(static_cast(y_low) <= fpga_grid_y_); + VTR_ASSERT(static_cast(y_high) <= fpga_grid_y_); // Skip spatial indexing for source/sink nodes if (rr_graph_.node_type(node_id) == e_rr_type::SOURCE || rr_graph_.node_type(node_id) == e_rr_type::SINK) { From 6b4a95b42b81c9f3c0246906406a5c4671ffb5e9 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 15:11:55 -0700 Subject: [PATCH 088/120] [lib][rr_graph][base] resize node_tilable_track_nums_ in relevant functions --- libs/librrgraph/src/base/rr_graph_storage.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/libs/librrgraph/src/base/rr_graph_storage.h b/libs/librrgraph/src/base/rr_graph_storage.h index fcc236532a..7f502c0640 100644 --- a/libs/librrgraph/src/base/rr_graph_storage.h +++ b/libs/librrgraph/src/base/rr_graph_storage.h @@ -552,6 +552,9 @@ class t_rr_graph_storage { node_bend_end_.reserve(node_storage_.capacity()); node_bend_end_.resize(node_storage_.size()); + + node_tilable_track_nums_.reserve(node_storage_.capacity()); + node_tilable_track_nums_.resize(node_storage_.size()); } } @@ -579,6 +582,7 @@ class t_rr_graph_storage { if (is_tileable_) { node_bend_start_.resize(size); node_bend_end_.resize(size); + node_tilable_track_nums_.resize(size); } } @@ -613,7 +617,6 @@ class t_rr_graph_storage { edges_read_ = false; partitioned_ = false; remapped_edges_ = false; - is_tileable_ = false; } /** @brief @@ -642,7 +645,7 @@ class t_rr_graph_storage { node_layer_.shrink_to_fit(); node_bend_start_.shrink_to_fit(); node_bend_end_.shrink_to_fit(); - + node_tilable_track_nums_.shrink_to_fit(); edge_src_node_.shrink_to_fit(); edge_dest_node_.shrink_to_fit(); edge_switch_.shrink_to_fit(); From 10b08885683339cfbf21c14e2323abbae7dff8af Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 15:14:17 -0700 Subject: [PATCH 089/120] [lib][rr_graph][io] set tileable to true before loading graph --- libs/librrgraph/src/io/rr_graph_reader.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libs/librrgraph/src/io/rr_graph_reader.cpp b/libs/librrgraph/src/io/rr_graph_reader.cpp index ff0f8b9e4a..41d3d76211 100644 --- a/libs/librrgraph/src/io/rr_graph_reader.cpp +++ b/libs/librrgraph/src/io/rr_graph_reader.cpp @@ -83,6 +83,10 @@ void load_rr_file(RRGraphBuilder* rr_graph_builder, rr_graph_builder->add_rr_segment(segment_inf[(iseg)]); } + if (graph_type == e_graph_type::UNIDIR_TILEABLE) { + rr_graph_builder->set_tileable(true); + } + RrGraphSerializer reader( graph_type, base_cost_type, From 7139c9e70751853156c98645138f53c225720258 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 15:16:59 -0700 Subject: [PATCH 090/120] [vpr][route][crr] init crr data strutures only if crr is created --- .../tileable_rr_graph_edge_builder.cpp | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp index 8f0d8e48bf..9469841ed8 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/tileable_rr_graph_edge_builder.cpp @@ -318,7 +318,7 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, const bool& opin2all_sides, const bool& concat_wire, const bool& wire_opposite_side) { - bool build_crr_edges = crr_opts.sb_templates.empty(); + bool build_crr_edges = !crr_opts.sb_templates.empty(); size_t num_edges_to_create = 0; /* Create edges for SOURCE and SINK nodes for a tileable rr_graph */ build_rr_graph_edges_for_source_nodes(rr_graph, rr_graph_builder, rr_node_driver_switches, grids, layer, num_edges_to_create); @@ -327,12 +327,16 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, vtr::Point gsb_range(grids.width() - 1, grids.height() - 1); // Building CRR Graph - crrgenerator::SwitchBlockManager sb_manager; - sb_manager.initialize(crr_opts.sb_maps, crr_opts.sb_templates, crr_opts.annotated_rr_graph); - crrgenerator::NodeLookupManager node_lookup(rr_graph, grids.width(), grids.height()); - node_lookup.initialize(); - crrgenerator::CRRGraphGenerator parser(crr_opts, rr_graph, node_lookup, sb_manager, "vpr_custom_rr_graph.xml"); - parser.run(); + const crrgenerator::CRRConnectionBuilder* crr_connection_builder = nullptr; + if (build_crr_edges) { + crrgenerator::SwitchBlockManager sb_manager; + sb_manager.initialize(crr_opts.sb_maps, crr_opts.sb_templates, crr_opts.annotated_rr_graph); + crrgenerator::NodeLookupManager node_lookup(rr_graph, grids.width(), grids.height()); + node_lookup.initialize(); + crrgenerator::CRRGraphGenerator parser(crr_opts, rr_graph, node_lookup, sb_manager, "vpr_custom_rr_graph.xml"); + parser.run(); + crr_connection_builder = parser.get_connection_builder(); + } /* Go Switch Block by Switch Block */ for (size_t ix = 0; ix <= gsb_range.x(); ++ix) { @@ -360,7 +364,7 @@ void build_rr_graph_regular_edges(const RRGraphView& rr_graph, /* adapt the switch_block_conn for the GSB nodes */ t_track2track_map sb_conn; /* [0..from_gsb_side][0..chan_width-1][track_indices] */ if (build_crr_edges) { - build_crr_gsb_track_to_track_edges(rr_graph_builder, rr_gsb, *parser.get_connection_builder()); + build_crr_gsb_track_to_track_edges(rr_graph_builder, rr_gsb, *crr_connection_builder); } else { sb_conn = build_gsb_track_to_track_map(rr_graph, rr_gsb, From 7ef33f1da9bbe22312d5563d934d4897182be1b4 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Tue, 28 Oct 2025 15:24:49 -0700 Subject: [PATCH 091/120] make format --- vpr/src/base/read_options.cpp | 7 ++-- .../crr_generator/crr_connection_builder.cpp | 32 ++++++++----------- .../crr_generator/crr_connection_builder.h | 18 +++-------- .../crr_generator/node_lookup_manager.cpp | 1 - 4 files changed, 22 insertions(+), 36 deletions(-) diff --git a/vpr/src/base/read_options.cpp b/vpr/src/base/read_options.cpp index 139571579d..e09a0f33c3 100644 --- a/vpr/src/base/read_options.cpp +++ b/vpr/src/base/read_options.cpp @@ -3286,7 +3286,7 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio .help("Switch block map file that specifed the switch block template used for each location") .default_value("") .show_in(argparse::ShowIn::HELP_ONLY); - + crr_grp.add_argument(args.sb_templates, "--sb_templates") .help("Directory containing the switch block templates") .default_value("") @@ -3296,17 +3296,16 @@ argparse::ArgumentParser create_arg_parser(const std::string& prog_name, t_optio .help("Number of threads to use for the CRR generation") .default_value("1") .show_in(argparse::ShowIn::HELP_ONLY); - + crr_grp.add_argument(args.preserve_pin_connections, "--preserve_pin_connections") .help("If it set to on, the pin connections will be generated by the default flow and not from the CRR template") .default_value("off") .show_in(argparse::ShowIn::HELP_ONLY); - + crr_grp.add_argument(args.annotated_rr_graph, "--annotated_rr_graph") .help("Whether the generated CRR should be annotated with delay") .default_value("off") .show_in(argparse::ShowIn::HELP_ONLY); - auto& power_grp = parser.add_argument_group("power analysis options"); diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp index 316c9bc473..69dd1c6bb4 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.cpp @@ -209,8 +209,7 @@ std::vector CRRConnectionBuilder::get_tile_connections(size_t tile_x return tile_connections; } -std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const { +std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, const std::unordered_map& node_lookup) const { std::map source_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; @@ -239,8 +238,7 @@ std::map CRRConnectionBuilder::get_vertical_nodes(Coordinate x return source_nodes; } -std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const { +std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, const std::unordered_map& node_lookup) const { std::map sink_nodes; std::string prev_seg_type = ""; int prev_seg_index = -1; @@ -273,7 +271,7 @@ std::map CRRConnectionBuilder::get_horizontal_nodes(Coordinate return sink_nodes; } -CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const DataFrame& df, +CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical) const { SegmentInfo info; @@ -324,8 +322,7 @@ CRRConnectionBuilder::SegmentInfo CRRConnectionBuilder::parse_segment_info(const return info; } -RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const { +RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, const std::unordered_map& node_lookup) const { assert(info.side == Side::OPIN || info.side == Side::IPIN); e_rr_type node_type = (info.side == Side::OPIN) ? e_rr_type::OPIN : e_rr_type::IPIN; NodeHash hash = std::make_tuple(node_type, @@ -340,10 +337,7 @@ RRNodeId CRRConnectionBuilder::process_opin_ipin_node(const SegmentInfo& info, C return RRNodeId::INVALID(); } -RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup, - int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, - bool is_vertical) const { +RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical) const { // Check grid boundaries if ((info.side == Side::RIGHT && x == fpga_grid_x_) || (info.side == Side::TOP && y == fpga_grid_y_)) { return RRNodeId::INVALID(); @@ -398,10 +392,14 @@ RRNodeId CRRConnectionBuilder::process_channel_node(const SegmentInfo& info, Coo } void CRRConnectionBuilder::calculate_segment_coordinates(const SegmentInfo& info, - Coordinate x, Coordinate y, - Coordinate& x_low, Coordinate& x_high, - Coordinate& y_low, Coordinate& y_high, - int& physical_length, int& truncated, + Coordinate x, + Coordinate y, + Coordinate& x_low, + Coordinate& x_high, + Coordinate& y_low, + Coordinate& y_high, + int& physical_length, + int& truncated, bool is_vertical) const { int seg_length = std::stoi(info.seg_type.substr(1)); int tap = info.tap; @@ -527,9 +525,7 @@ std::string CRRConnectionBuilder::get_ptc_sequence(int seg_index, return result; } -SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, - RRNodeId /*source_node*/, RRNodeId /*sink_node*/, - int /*segment_length*/) const { +SwitchId CRRConnectionBuilder::get_edge_switch_id(const std::string& cell_value, const std::string& sink_node_type, RRNodeId /*source_node*/, RRNodeId /*sink_node*/, int /*segment_length*/) const { std::string lower_case_sink_node_type = sink_node_type; std::transform(lower_case_sink_node_type.begin(), lower_case_sink_node_type.end(), diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h index 77d1287e2f..c75918bc23 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/crr_connection_builder.h @@ -109,11 +109,9 @@ class CRRConnectionBuilder { std::vector& tile_connections) const; // Node processing methods - std::map get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const; + std::map get_vertical_nodes(Coordinate x, Coordinate y, const DataFrame& df, const std::unordered_map& node_lookup) const; - std::map get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, - const std::unordered_map& node_lookup) const; + std::map get_horizontal_nodes(Coordinate x, Coordinate y, const DataFrame& df, const std::unordered_map& node_lookup) const; // PTC sequence calculation std::string get_ptc_sequence(int seg_index, int seg_length, int physical_length, Direction direction, int truncated) const; @@ -138,18 +136,12 @@ class CRRConnectionBuilder { SegmentInfo parse_segment_info(const DataFrame& df, size_t row_or_col, bool is_vertical) const; - RRNodeId process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup) const; + RRNodeId process_opin_ipin_node(const SegmentInfo& info, Coordinate x, Coordinate y, const std::unordered_map& node_lookup) const; - RRNodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, - const std::unordered_map& node_lookup, - int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, - bool is_vertical) const; + RRNodeId process_channel_node(const SegmentInfo& info, Coordinate x, Coordinate y, const std::unordered_map& node_lookup, int& prev_seg_index, Side& prev_side, std::string& prev_seg_type, int& prev_ptc_number, bool is_vertical) const; // Coordinate and direction calculations - void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, Coordinate y, - Coordinate& x_low, Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, - int& physical_length, int& truncated, bool is_vertical) const; + void calculate_segment_coordinates(const SegmentInfo& info, Coordinate x, Coordinate y, Coordinate& x_low, Coordinate& x_high, Coordinate& y_low, Coordinate& y_high, int& physical_length, int& truncated, bool is_vertical) const; Direction get_direction_for_side(Side side, bool is_vertical) const; std::string get_segment_type_label(Side side) const; diff --git a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp index cbc2f5d118..966ecd3a21 100644 --- a/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp +++ b/vpr/src/route/rr_graph_generation/tileable_rr_graph/crr_generator/node_lookup_manager.cpp @@ -106,7 +106,6 @@ void NodeLookupManager::index_node(RRNodeId node_id) { short y_low = rr_graph_.node_ylow(node_id); short y_high = rr_graph_.node_yhigh(node_id); - VTR_ASSERT(static_cast(x_low) <= fpga_grid_x_); VTR_ASSERT(static_cast(x_high) <= fpga_grid_x_); VTR_ASSERT(static_cast(y_low) <= fpga_grid_y_); From 6ab4258602b4acea6d2511382566c490af70145d Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 29 Oct 2025 07:07:49 -0700 Subject: [PATCH 092/120] [submodule] clone submodules recursively --- .github/workflows/containers.yml | 2 +- .github/workflows/nightly_test.yml | 2 +- .github/workflows/nightly_test_manual.yml | 4 ++-- .github/workflows/test.yml | 24 +++++++++++------------ 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/.github/workflows/containers.yml b/.github/workflows/containers.yml index 4cc24013f1..e71c322116 100644 --- a/.github/workflows/containers.yml +++ b/.github/workflows/containers.yml @@ -40,7 +40,7 @@ jobs: - name: 🧰 Repository Checkout uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: 🔧 Generate image name id: generate diff --git a/.github/workflows/nightly_test.yml b/.github/workflows/nightly_test.yml index a6782293b5..ccafdec876 100644 --- a/.github/workflows/nightly_test.yml +++ b/.github/workflows/nightly_test.yml @@ -76,7 +76,7 @@ jobs: # to v4, need to upgrade the machine to support node20. - uses: actions/checkout@v3 with: - submodules: 'true' + submodules: 'recursive' - name: Setup run: stdbuf -i0 -i0 -e0 ./.github/scripts/hostsetup.sh diff --git a/.github/workflows/nightly_test_manual.yml b/.github/workflows/nightly_test_manual.yml index 656670bb32..4e8def65b8 100644 --- a/.github/workflows/nightly_test_manual.yml +++ b/.github/workflows/nightly_test_manual.yml @@ -41,7 +41,7 @@ jobs: # Checkout the VTR repo. - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' # Get the extra benchmarks - name: 'Get Extra Benchmarks' @@ -148,7 +148,7 @@ jobs: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 0665cc6a24..27514e289c 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -40,7 +40,7 @@ jobs: steps: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -81,7 +81,7 @@ jobs: steps: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -193,7 +193,7 @@ jobs: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -236,7 +236,7 @@ jobs: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: 'Get number of CPU cores' uses: SimenB/github-actions-cpu-cores@v2 @@ -358,7 +358,7 @@ jobs: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -445,7 +445,7 @@ jobs: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -523,7 +523,7 @@ jobs: python-version: 3.12.3 - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -570,7 +570,7 @@ jobs: python-version: 3.12.3 - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -609,7 +609,7 @@ jobs: python-version: 3.12.3 - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -649,7 +649,7 @@ jobs: python-version: 3.12.3 - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -694,7 +694,7 @@ jobs: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -725,7 +725,7 @@ jobs: steps: - uses: actions/checkout@v4 with: - submodules: 'true' + submodules: 'recursive' - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 From f14e6e0a2169387f83e81be5aa36714092d39832 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 29 Oct 2025 07:18:34 -0700 Subject: [PATCH 093/120] [github] add fetch-depth to submodule --- .github/workflows/containers.yml | 1 + .github/workflows/nightly_test.yml | 1 + .github/workflows/nightly_test_manual.yml | 1 + .github/workflows/test.yml | 12 ++++++++++++ 4 files changed, 15 insertions(+) diff --git a/.github/workflows/containers.yml b/.github/workflows/containers.yml index e71c322116..58275e0575 100644 --- a/.github/workflows/containers.yml +++ b/.github/workflows/containers.yml @@ -41,6 +41,7 @@ jobs: uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: 🔧 Generate image name id: generate diff --git a/.github/workflows/nightly_test.yml b/.github/workflows/nightly_test.yml index ccafdec876..875716ee4c 100644 --- a/.github/workflows/nightly_test.yml +++ b/.github/workflows/nightly_test.yml @@ -77,6 +77,7 @@ jobs: - uses: actions/checkout@v3 with: submodules: 'recursive' + fetch-depth: 0 - name: Setup run: stdbuf -i0 -i0 -e0 ./.github/scripts/hostsetup.sh diff --git a/.github/workflows/nightly_test_manual.yml b/.github/workflows/nightly_test_manual.yml index 4e8def65b8..432d3faefb 100644 --- a/.github/workflows/nightly_test_manual.yml +++ b/.github/workflows/nightly_test_manual.yml @@ -149,6 +149,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 27514e289c..dce87c02a3 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -41,6 +41,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -82,6 +83,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -194,6 +196,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -237,6 +240,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: 'Get number of CPU cores' uses: SimenB/github-actions-cpu-cores@v2 @@ -359,6 +363,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -446,6 +451,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -524,6 +530,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -571,6 +578,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -610,6 +618,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -650,6 +659,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -695,6 +705,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 @@ -726,6 +737,7 @@ jobs: - uses: actions/checkout@v4 with: submodules: 'recursive' + fetch-depth: 0 - name: Get number of CPU cores uses: SimenB/github-actions-cpu-cores@v2 From 2ba93e579df69f80eb7cc6e914155eb0e467f078 Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 29 Oct 2025 09:39:57 -0700 Subject: [PATCH 094/120] [submodule] remove xlnt --- .gitmodules | 3 --- libs/EXTERNAL/xlnt | 1 - 2 files changed, 4 deletions(-) delete mode 160000 libs/EXTERNAL/xlnt diff --git a/.gitmodules b/.gitmodules index eeb1abfa63..2c1f73cb34 100644 --- a/.gitmodules +++ b/.gitmodules @@ -19,6 +19,3 @@ [submodule "libs/EXTERNAL/yaml-cpp"] path = libs/EXTERNAL/yaml-cpp url = https://github.com/jbeder/yaml-cpp.git -[submodule "libs/EXTERNAL/xlnt"] - path = libs/EXTERNAL/xlnt - url = https://github.com/tfussell/xlnt.git diff --git a/libs/EXTERNAL/xlnt b/libs/EXTERNAL/xlnt deleted file mode 160000 index 297b331435..0000000000 --- a/libs/EXTERNAL/xlnt +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 297b331435d6dee09bf89c8a5ad974b01f18039b From 1933857e7af1a41508564153539eed04df1a5d4d Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 29 Oct 2025 09:56:00 -0700 Subject: [PATCH 095/120] [subtree] add xlnt to subtree config file --- dev/subtree_config.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/dev/subtree_config.xml b/dev/subtree_config.xml index c932531177..5f88b5c58e 100644 --- a/dev/subtree_config.xml +++ b/dev/subtree_config.xml @@ -54,4 +54,9 @@ internal_path="parmys" external_url="https://github.com/CAS-Atlantic/parmys-plugin.git" default_external_ref="v3.0"/> + From ef41a0b0e984b59017472ec31a8935c0231dd39f Mon Sep 17 00:00:00 2001 From: Amin Mohaghegh Date: Wed, 29 Oct 2025 09:56:13 -0700 Subject: [PATCH 096/120] Squashed 'libs/EXTERNAL/xlnt/' content from commit 297b331435 git-subtree-dir: libs/EXTERNAL/xlnt git-subtree-split: 297b331435d6dee09bf89c8a5ad974b01f18039b --- .appveyor.yml | 36 + .circleci/config.yml | 79 + .clang-format | 67 + .gitattributes | 1 + .gitignore | 25 + .gitmodules | 3 + .release-it.json | 24 + AUTHORS.md | 13 + CHANGELOG.md | 4 + CMakeLists.txt | 59 + CODE_OF_CONDUCT.md | 46 + CONTRIBUTING.md | 31 + LICENSE.md | 493 ++ README.md | 52 + SUMMARY.md | 1 + benchmarks/CMakeLists.txt | 48 + benchmarks/data/large.xlsx | Bin 0 -> 1927750 bytes benchmarks/data/very_large.xlsx | Bin 0 -> 4333464 bytes benchmarks/disabled/bufzip.cpp | 23 + benchmarks/disabled/memory.cpp | 65 + benchmarks/disabled/profiling.cpp | 131 + benchmarks/disabled/reader.cpp | 45 + benchmarks/disabled/speed.cpp | 31 + benchmarks/microbenchmarks/CMakeLists.txt | 36 + .../microbenchmarks/double_to_string.cpp | 207 + .../microbenchmarks/string_to_double.cpp | 223 + benchmarks/spreadsheet-load.cpp | 58 + benchmarks/styles.cpp | 250 + benchmarks/writer.cpp | 90 + book.json | 10 + cmake/FindArrow.cmake | 133 + cmake/XlntConfig.cmake.in | 13 + cmake/cmake_uninstall.cmake.in | 33 + cmake/pkg-config.pc.cmake | 10 + cmake/ucm.cmake | 634 ++ docs/README.md | 25 + docs/advanced/Encryption.md | 1 + docs/advanced/Formatting.md | 37 + docs/advanced/Printing.md | 1 + docs/advanced/Properties.md | 54 + docs/advanced/README.md | 7 + docs/advanced/Views.md | 1 + docs/api/README.md | 4 + docs/api/cell.md | 188 + docs/api/cell_reference.md | 55 + docs/basics/Cell.md | 1 + docs/basics/Iteration.md | 1 + docs/basics/MemoryModel.md | 31 + docs/basics/README.md | 6 + docs/basics/Workbook.md | 1 + docs/basics/Worksheet.md | 1 + docs/introduction/Examples.md | 195 + docs/introduction/Features.md | 54 + docs/introduction/Installation.md | 79 + docs/introduction/Motivation.md | 1 + docs/introduction/README.md | 6 + docs/template.ejs | 3 + docs/tools/Doxyfile | 315 + docs/tools/generate-md.js | 100 + docs/xlnt.3 | 1859 ++++ include/xlnt/cell/cell.hpp | 712 ++ include/xlnt/cell/cell_reference.hpp | 272 + include/xlnt/cell/cell_type.hpp | 58 + include/xlnt/cell/comment.hpp | 166 + include/xlnt/cell/hyperlink.hpp | 70 + include/xlnt/cell/index_types.hpp | 309 + include/xlnt/cell/phonetic_run.hpp | 46 + include/xlnt/cell/rich_text.hpp | 179 + include/xlnt/cell/rich_text_run.hpp | 48 + include/xlnt/drawing/spreadsheet_drawing.hpp | 59 + include/xlnt/packaging/ext_list.hpp | 79 + include/xlnt/packaging/manifest.hpp | 199 + include/xlnt/packaging/relationship.hpp | 178 + include/xlnt/packaging/uri.hpp | 239 + include/xlnt/styles/alignment.hpp | 168 + include/xlnt/styles/border.hpp | 227 + include/xlnt/styles/color.hpp | 350 + include/xlnt/styles/conditional_format.hpp | 170 + include/xlnt/styles/fill.hpp | 369 + include/xlnt/styles/font.hpp | 324 + include/xlnt/styles/format.hpp | 235 + include/xlnt/styles/number_format.hpp | 274 + include/xlnt/styles/protection.hpp | 107 + include/xlnt/styles/style.hpp | 261 + include/xlnt/utils/calendar.hpp | 40 + include/xlnt/utils/date.hpp | 93 + include/xlnt/utils/datetime.hpp | 136 + include/xlnt/utils/exceptions.hpp | 347 + include/xlnt/utils/numeric.hpp | 194 + include/xlnt/utils/optional.hpp | 337 + include/xlnt/utils/path.hpp | 221 + include/xlnt/utils/scoped_enum_hash.hpp | 47 + include/xlnt/utils/time.hpp | 93 + include/xlnt/utils/timedelta.hpp | 84 + include/xlnt/utils/variant.hpp | 195 + .../xlnt/workbook/calculation_properties.hpp | 55 + include/xlnt/workbook/document_security.hpp | 99 + include/xlnt/workbook/external_book.hpp | 38 + include/xlnt/workbook/metadata_property.hpp | 86 + include/xlnt/workbook/named_range.hpp | 93 + .../workbook/streaming_workbook_reader.hpp | 143 + .../workbook/streaming_workbook_writer.hpp | 116 + include/xlnt/workbook/theme.hpp | 43 + include/xlnt/workbook/workbook.hpp | 932 ++ include/xlnt/workbook/workbook_view.hpp | 118 + include/xlnt/workbook/worksheet_iterator.hpp | 253 + include/xlnt/worksheet/cell_iterator.hpp | 317 + include/xlnt/worksheet/cell_vector.hpp | 216 + include/xlnt/worksheet/column_properties.hpp | 75 + include/xlnt/worksheet/header_footer.hpp | 329 + include/xlnt/worksheet/major_order.hpp | 39 + include/xlnt/worksheet/page_margins.hpp | 136 + include/xlnt/worksheet/page_setup.hpp | 244 + include/xlnt/worksheet/pane.hpp | 98 + include/xlnt/worksheet/phonetic_pr.hpp | 167 + include/xlnt/worksheet/print_options.hpp | 67 + include/xlnt/worksheet/range.hpp | 315 + include/xlnt/worksheet/range_iterator.hpp | 273 + include/xlnt/worksheet/range_reference.hpp | 189 + include/xlnt/worksheet/row_properties.hpp | 86 + include/xlnt/worksheet/selection.hpp | 163 + .../worksheet/sheet_format_properties.hpp | 67 + include/xlnt/worksheet/sheet_pr.hpp | 94 + include/xlnt/worksheet/sheet_protection.hpp | 63 + include/xlnt/worksheet/sheet_view.hpp | 270 + include/xlnt/worksheet/worksheet.hpp | 841 ++ include/xlnt/xlnt.hpp | 92 + include/xlnt/xlnt_config.hpp | 43 + logo/logo.png | Bin 0 -> 7042 bytes package-lock.json | 5957 +++++++++++++ package.json | 27 + python/CMakeLists.txt | 47 + python/python_streambuf.hpp | 343 + python/setup.py | 256 + python/xlntpyarrow.lib.cpp | 452 + python/xlntpyarrow/__init__.py | 86 + samples/CMakeLists.txt | 44 + samples/data/cafe.jpg | Bin 0 -> 10705 bytes samples/data/documentation-print.xlsx | Bin 0 -> 8831 bytes samples/data/encrypted.xlsx | Bin 0 -> 14848 bytes samples/data/penguin.jpg | Bin 0 -> 1267 bytes samples/data/sample1.xlsx | Bin 0 -> 495074 bytes samples/decrypt.cpp | 36 + samples/disabled/add_comments.cpp | 1 + .../disabled/basic_conditional_formatting.cpp | 1 + samples/disabled/comment_error.cpp | 1 + samples/disabled/copy_style.cpp | 1 + samples/disabled/create.cpp | 45 + samples/disabled/default_styles.cpp | 1 + samples/disabled/font_legacy_colors.cpp | 1 + samples/disabled/font_rgb_colors.cpp | 1 + samples/disabled/group_columns.cpp | 1 + samples/disabled/header_footer.cpp | 1 + samples/disabled/image.cpp | 1 + samples/disabled/merge_unmerge.cpp | 1 + samples/disabled/page_setup.cpp | 1 + samples/disabled/parse_formulae.cpp | 1 + samples/disabled/print_options.cpp | 1 + samples/disabled/read.cpp | 36 + samples/disabled/row_column_style.cpp | 1 + samples/disabled/style_application.cpp | 1 + samples/disabled/style_side_effects.cpp | 1 + samples/disabled/using_formulae.cpp | 1 + samples/disabled/using_number_formats.cpp | 1 + samples/disabled/validate_cells.cpp | 1 + samples/disabled/worksheet_properties.cpp | 1 + samples/disabled/write.cpp | 44 + samples/documentation.cpp | 226 + samples/img2xlsx.cpp | 242 + samples/stb_image.h | 7177 +++++++++++++++ source/CMakeLists.txt | 332 + source/cell/cell.cpp | 1023 +++ source/cell/cell_reference.cpp | 282 + source/cell/comment.cpp | 120 + source/cell/hyperlink.cpp | 116 + source/cell/index_types.cpp | 299 + source/cell/phonetic_run.cpp | 39 + source/cell/rich_text.cpp | 172 + source/cell/rich_text_run.cpp | 38 + source/detail/binary.hpp | 327 + source/detail/constants.cpp | 175 + source/detail/constants.hpp | 138 + source/detail/cryptography/aes.cpp | 3139 +++++++ source/detail/cryptography/aes.hpp | 55 + source/detail/cryptography/base64.cpp | 184 + source/detail/cryptography/base64.hpp | 36 + source/detail/cryptography/cipher.hpp | 58 + .../detail/cryptography/compound_document.cpp | 1364 +++ .../detail/cryptography/compound_document.hpp | 225 + .../detail/cryptography/encryption_info.cpp | 179 + .../detail/cryptography/encryption_info.hpp | 97 + source/detail/cryptography/hash.cpp | 55 + source/detail/cryptography/hash.hpp | 53 + source/detail/cryptography/sha.cpp | 109 + source/detail/cryptography/sha.hpp | 37 + source/detail/cryptography/sha1.c | 181 + source/detail/cryptography/sha512.c | 268 + source/detail/cryptography/value_traits.hpp | 91 + .../cryptography/xlsx_crypto_consumer.cpp | 352 + .../cryptography/xlsx_crypto_consumer.hpp | 36 + .../cryptography/xlsx_crypto_producer.cpp | 323 + .../cryptography/xlsx_crypto_producer.hpp | 36 + source/detail/default_case.hpp | 34 + source/detail/external/include_libstudxml.hpp | 36 + source/detail/external/include_windows.hpp | 53 + .../header_footer/header_footer_code.cpp | 541 ++ .../header_footer/header_footer_code.hpp | 39 + source/detail/implementations/cell_impl.cpp | 44 + source/detail/implementations/cell_impl.hpp | 92 + .../conditional_format_impl.hpp | 50 + source/detail/implementations/format_impl.hpp | 79 + .../implementations/formatting_record.hpp | 35 + .../detail/implementations/hyperlink_impl.hpp | 51 + source/detail/implementations/style_impl.hpp | 81 + source/detail/implementations/stylesheet.hpp | 576 ++ .../detail/implementations/workbook_impl.hpp | 174 + .../detail/implementations/worksheet_impl.hpp | 166 + .../detail/number_format/number_formatter.cpp | 2097 +++++ .../detail/number_format/number_formatter.hpp | 701 ++ .../serialization/custom_value_traits.cpp | 480 ++ .../serialization/custom_value_traits.hpp | 615 ++ source/detail/serialization/defined_name.hpp | 40 + .../detail/serialization/excel_thumbnail.hpp | 455 + source/detail/serialization/open_stream.cpp | 63 + source/detail/serialization/open_stream.hpp | 48 + .../serialization/serialisation_helpers.hpp | 96 + .../detail/serialization/vector_streambuf.cpp | 245 + .../detail/serialization/vector_streambuf.hpp | 109 + source/detail/serialization/xlsx_consumer.cpp | 3463 ++++++++ source/detail/serialization/xlsx_consumer.hpp | 433 + source/detail/serialization/xlsx_producer.cpp | 3512 ++++++++ source/detail/serialization/xlsx_producer.hpp | 247 + source/detail/serialization/zstream.cpp | 631 ++ source/detail/serialization/zstream.hpp | 153 + source/detail/unicode.cpp | 86 + source/detail/unicode.hpp | 35 + source/drawing/spreadsheet_drawing.cpp | 116 + source/packaging/ext_list.cpp | 140 + source/packaging/manifest.cpp | 346 + source/packaging/relationship.cpp | 78 + source/packaging/uri.cpp | 29 + source/styles/alignment.cpp | 169 + source/styles/border.cpp | 196 + source/styles/color.cpp | 327 + source/styles/conditional_format.cpp | 133 + source/styles/fill.cpp | 322 + source/styles/font.cpp | 273 + source/styles/format.cpp | 238 + source/styles/number_format.cpp | 358 + source/styles/protection.cpp | 86 + source/styles/style.cpp | 261 + source/utils/date.cpp | 138 + source/utils/datetime.cpp | 134 + source/utils/exceptions.cpp | 161 + source/utils/path.cpp | 363 + source/utils/time.cpp | 132 + source/utils/timedelta.cpp | 98 + source/utils/variant.cpp | 188 + source/workbook/named_range.cpp | 132 + source/workbook/streaming_workbook_reader.cpp | 172 + source/workbook/streaming_workbook_writer.cpp | 108 + source/workbook/workbook.cpp | 1716 ++++ source/workbook/worksheet_iterator.cpp | 127 + source/worksheet/cell_iterator.cpp | 289 + source/worksheet/cell_vector.cpp | 174 + source/worksheet/header_footer.cpp | 311 + source/worksheet/page_margins.cpp | 102 + source/worksheet/page_setup.cpp | 146 + source/worksheet/phonetic_pr.cpp | 161 + source/worksheet/range.cpp | 320 + source/worksheet/range_iterator.cpp | 276 + source/worksheet/range_reference.cpp | 196 + source/worksheet/sheet_protection.cpp | 78 + source/worksheet/worksheet.cpp | 1355 +++ tests/CMakeLists.txt | 85 + tests/cell/cell_test_suite.cpp | 838 ++ tests/cell/index_types_test_suite.cpp | 105 + tests/cell/rich_text_test_suite.cpp | 146 + .../data/10_comments_hyperlinks_formulae.xlsx | Bin 0 -> 16965 bytes tests/data/11_print_settings.xlsx | Bin 0 -> 21510 bytes tests/data/12_advanced_properties.xlsx | Bin 0 -> 21544 bytes tests/data/13_custom_heights_widths.xlsx | Bin 0 -> 13124 bytes tests/data/14_images.xlsx | Bin 0 -> 21723 bytes tests/data/15_phonetics.xlsx | Bin 0 -> 10122 bytes tests/data/16_hidden_sheet.xlsx | Bin 0 -> 9297 bytes tests/data/17_xlsm.xlsm | Bin 0 -> 16010 bytes tests/data/18_formulae.xlsx | Bin 0 -> 9283 bytes tests/data/19_defined_names.xlsx | Bin 0 -> 9599 bytes tests/data/1_powerpoint_presentation.xlsx | Bin 0 -> 30395 bytes tests/data/20_active_sheet.xlsx | Bin 0 -> 6035 bytes tests/data/2_minimal.xlsx | Bin 0 -> 1707 bytes tests/data/3_default.xlsx | Bin 0 -> 13095 bytes tests/data/4_every_style.xlsx | Bin 0 -> 43567 bytes tests/data/5_encrypted_agile.xlsx | Bin 0 -> 14848 bytes tests/data/6_encrypted_libre.xlsx | Bin 0 -> 8192 bytes tests/data/7_encrypted_standard.xlsx | Bin 0 -> 12800 bytes tests/data/8_encrypted_numbers.xlsx | Bin 0 -> 500736 bytes .../9_unicode_\316\233_\360\237\230\207.xlsx" | Bin 0 -> 21892 bytes .../data/Issue279_workbook_delete_rename.xlsx | Bin 0 -> 11341 bytes ...Issue353_first_row_empty_w_properties.xlsx | Bin 0 -> 10062 bytes tests/data/Issue445_inline_str.xlsx | Bin 0 -> 4593 bytes tests/data/Issue492_empty_row.xlsx | Bin 0 -> 4573 bytes tests/data/Issue494_shared_string.xlsx | Bin 0 -> 15618 bytes tests/data/Issue503_external_link.xlsx | Bin 0 -> 19619 bytes tests/data/excel_test_sheet.xlsx | Bin 0 -> 9296 bytes tests/detail/numeric_util_test_suite.cpp | 223 + tests/drawing/drawing_test_suite.cpp | 59 + tests/helpers/assertions.hpp | 61 + tests/helpers/path_helper.hpp | 79 + tests/helpers/temporary_directory.hpp | 48 + tests/helpers/temporary_file.hpp | 39 + tests/helpers/test_suite.cpp | 48 + tests/helpers/test_suite.hpp | 42 + tests/helpers/timing.hpp | 39 + tests/helpers/xml_helper.hpp | 417 + tests/runner.cpp | 48 + tests/styles/alignment_test_suite.cpp | 47 + tests/styles/color_test_suite.cpp | 78 + .../styles/conditional_format_test_suite.cpp | 64 + tests/styles/fill_test_suite.cpp | 109 + tests/styles/number_format_test_suite.cpp | 1036 +++ tests/styles/protection_test_suite.cpp | 55 + tests/styles/style_test_suite.cpp | 65 + tests/utils/datetime_test_suite.cpp | 127 + tests/utils/helper_test_suite.cpp | 157 + tests/utils/optional_tests.cpp | 307 + tests/utils/path_test_suite.cpp | 53 + tests/utils/timedelta_test_suite.cpp | 85 + tests/utils/variant_tests.cpp | 69 + tests/workbook/named_range_test_suite.cpp | 257 + tests/workbook/serialization_test_suite.cpp | 813 ++ tests/workbook/workbook_test_suite.cpp | 547 ++ tests/worksheet/page_setup_test_suite.cpp | 62 + tests/worksheet/range_test_suite.cpp | 118 + tests/worksheet/worksheet_test_suite.cpp | 1679 ++++ third-party/libstudxml | 1 + third-party/libstudxml.build/CMakeLists.txt | 79 + third-party/miniz/LICENSE | 22 + third-party/miniz/miniz.c | 7661 +++++++++++++++++ third-party/miniz/miniz.h | 1338 +++ third-party/pybind11/.appveyor.yml | 59 + third-party/pybind11/.gitignore | 37 + third-party/pybind11/.gitmodules | 3 + third-party/pybind11/.readthedocs.yml | 3 + third-party/pybind11/.travis.yml | 200 + third-party/pybind11/CMakeLists.txt | 139 + third-party/pybind11/CONTRIBUTING.md | 37 + third-party/pybind11/ISSUE_TEMPLATE.md | 17 + third-party/pybind11/LICENSE | 36 + third-party/pybind11/MANIFEST.in | 2 + third-party/pybind11/README.md | 129 + third-party/pybind11/include/pybind11/attr.h | 471 + .../pybind11/include/pybind11/buffer_info.h | 108 + third-party/pybind11/include/pybind11/cast.h | 2015 +++++ .../pybind11/include/pybind11/chrono.h | 162 + .../pybind11/include/pybind11/class_support.h | 602 ++ .../pybind11/include/pybind11/common.h | 876 ++ .../pybind11/include/pybind11/complex.h | 61 + third-party/pybind11/include/pybind11/descr.h | 185 + third-party/pybind11/include/pybind11/eigen.h | 610 ++ third-party/pybind11/include/pybind11/embed.h | 195 + third-party/pybind11/include/pybind11/eval.h | 117 + .../pybind11/include/pybind11/functional.h | 85 + third-party/pybind11/include/pybind11/numpy.h | 1598 ++++ .../pybind11/include/pybind11/operators.h | 167 + .../pybind11/include/pybind11/options.h | 65 + .../pybind11/include/pybind11/pybind11.h | 1852 ++++ .../pybind11/include/pybind11/pytypes.h | 1282 +++ third-party/pybind11/include/pybind11/stl.h | 367 + .../pybind11/include/pybind11/stl_bind.h | 588 ++ .../pybind11/include/pybind11/typeid.h | 53 + third-party/pybind11/pybind11/__init__.py | 11 + third-party/pybind11/pybind11/__main__.py | 31 + third-party/pybind11/pybind11/_version.py | 2 + third-party/pybind11/setup.cfg | 10 + third-party/pybind11/setup.py | 86 + third-party/pybind11/tools/FindCatch.cmake | 57 + third-party/pybind11/tools/FindEigen3.cmake | 81 + .../pybind11/tools/FindPythonLibsNew.cmake | 194 + third-party/pybind11/tools/check-style.sh | 82 + third-party/pybind11/tools/libsize.py | 38 + third-party/pybind11/tools/mkdoc.py | 304 + .../pybind11/tools/pybind11Config.cmake.in | 100 + .../pybind11/tools/pybind11Tools.cmake | 198 + third-party/utfcpp/LICENSE | 23 + third-party/utfcpp/utf8.h | 38 + third-party/utfcpp/utf8/checked.h | 324 + third-party/utfcpp/utf8/core.h | 321 + third-party/utfcpp/utf8/cpp11.h | 103 + third-party/utfcpp/utf8/unchecked.h | 269 + 390 files changed, 101032 insertions(+) create mode 100644 .appveyor.yml create mode 100644 .circleci/config.yml create mode 100644 .clang-format create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 .release-it.json create mode 100644 AUTHORS.md create mode 100644 CHANGELOG.md create mode 100644 CMakeLists.txt create mode 100644 CODE_OF_CONDUCT.md create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE.md create mode 100644 README.md create mode 120000 SUMMARY.md create mode 100644 benchmarks/CMakeLists.txt create mode 100644 benchmarks/data/large.xlsx create mode 100644 benchmarks/data/very_large.xlsx create mode 100644 benchmarks/disabled/bufzip.cpp create mode 100644 benchmarks/disabled/memory.cpp create mode 100644 benchmarks/disabled/profiling.cpp create mode 100644 benchmarks/disabled/reader.cpp create mode 100644 benchmarks/disabled/speed.cpp create mode 100644 benchmarks/microbenchmarks/CMakeLists.txt create mode 100644 benchmarks/microbenchmarks/double_to_string.cpp create mode 100644 benchmarks/microbenchmarks/string_to_double.cpp create mode 100644 benchmarks/spreadsheet-load.cpp create mode 100644 benchmarks/styles.cpp create mode 100644 benchmarks/writer.cpp create mode 100644 book.json create mode 100644 cmake/FindArrow.cmake create mode 100644 cmake/XlntConfig.cmake.in create mode 100644 cmake/cmake_uninstall.cmake.in create mode 100644 cmake/pkg-config.pc.cmake create mode 100644 cmake/ucm.cmake create mode 100644 docs/README.md create mode 100644 docs/advanced/Encryption.md create mode 100644 docs/advanced/Formatting.md create mode 100644 docs/advanced/Printing.md create mode 100644 docs/advanced/Properties.md create mode 100644 docs/advanced/README.md create mode 100644 docs/advanced/Views.md create mode 100644 docs/api/README.md create mode 100644 docs/api/cell.md create mode 100644 docs/api/cell_reference.md create mode 100644 docs/basics/Cell.md create mode 100644 docs/basics/Iteration.md create mode 100644 docs/basics/MemoryModel.md create mode 100644 docs/basics/README.md create mode 100644 docs/basics/Workbook.md create mode 100644 docs/basics/Worksheet.md create mode 100644 docs/introduction/Examples.md create mode 100644 docs/introduction/Features.md create mode 100644 docs/introduction/Installation.md create mode 100644 docs/introduction/Motivation.md create mode 100644 docs/introduction/README.md create mode 100644 docs/template.ejs create mode 100644 docs/tools/Doxyfile create mode 100644 docs/tools/generate-md.js create mode 100644 docs/xlnt.3 create mode 100644 include/xlnt/cell/cell.hpp create mode 100644 include/xlnt/cell/cell_reference.hpp create mode 100644 include/xlnt/cell/cell_type.hpp create mode 100644 include/xlnt/cell/comment.hpp create mode 100644 include/xlnt/cell/hyperlink.hpp create mode 100644 include/xlnt/cell/index_types.hpp create mode 100644 include/xlnt/cell/phonetic_run.hpp create mode 100644 include/xlnt/cell/rich_text.hpp create mode 100644 include/xlnt/cell/rich_text_run.hpp create mode 100644 include/xlnt/drawing/spreadsheet_drawing.hpp create mode 100644 include/xlnt/packaging/ext_list.hpp create mode 100644 include/xlnt/packaging/manifest.hpp create mode 100644 include/xlnt/packaging/relationship.hpp create mode 100644 include/xlnt/packaging/uri.hpp create mode 100644 include/xlnt/styles/alignment.hpp create mode 100644 include/xlnt/styles/border.hpp create mode 100644 include/xlnt/styles/color.hpp create mode 100644 include/xlnt/styles/conditional_format.hpp create mode 100644 include/xlnt/styles/fill.hpp create mode 100644 include/xlnt/styles/font.hpp create mode 100644 include/xlnt/styles/format.hpp create mode 100644 include/xlnt/styles/number_format.hpp create mode 100644 include/xlnt/styles/protection.hpp create mode 100644 include/xlnt/styles/style.hpp create mode 100644 include/xlnt/utils/calendar.hpp create mode 100644 include/xlnt/utils/date.hpp create mode 100644 include/xlnt/utils/datetime.hpp create mode 100644 include/xlnt/utils/exceptions.hpp create mode 100644 include/xlnt/utils/numeric.hpp create mode 100644 include/xlnt/utils/optional.hpp create mode 100644 include/xlnt/utils/path.hpp create mode 100644 include/xlnt/utils/scoped_enum_hash.hpp create mode 100644 include/xlnt/utils/time.hpp create mode 100644 include/xlnt/utils/timedelta.hpp create mode 100644 include/xlnt/utils/variant.hpp create mode 100644 include/xlnt/workbook/calculation_properties.hpp create mode 100644 include/xlnt/workbook/document_security.hpp create mode 100644 include/xlnt/workbook/external_book.hpp create mode 100644 include/xlnt/workbook/metadata_property.hpp create mode 100644 include/xlnt/workbook/named_range.hpp create mode 100644 include/xlnt/workbook/streaming_workbook_reader.hpp create mode 100644 include/xlnt/workbook/streaming_workbook_writer.hpp create mode 100644 include/xlnt/workbook/theme.hpp create mode 100644 include/xlnt/workbook/workbook.hpp create mode 100644 include/xlnt/workbook/workbook_view.hpp create mode 100644 include/xlnt/workbook/worksheet_iterator.hpp create mode 100644 include/xlnt/worksheet/cell_iterator.hpp create mode 100644 include/xlnt/worksheet/cell_vector.hpp create mode 100644 include/xlnt/worksheet/column_properties.hpp create mode 100644 include/xlnt/worksheet/header_footer.hpp create mode 100644 include/xlnt/worksheet/major_order.hpp create mode 100644 include/xlnt/worksheet/page_margins.hpp create mode 100644 include/xlnt/worksheet/page_setup.hpp create mode 100644 include/xlnt/worksheet/pane.hpp create mode 100644 include/xlnt/worksheet/phonetic_pr.hpp create mode 100644 include/xlnt/worksheet/print_options.hpp create mode 100644 include/xlnt/worksheet/range.hpp create mode 100644 include/xlnt/worksheet/range_iterator.hpp create mode 100644 include/xlnt/worksheet/range_reference.hpp create mode 100644 include/xlnt/worksheet/row_properties.hpp create mode 100644 include/xlnt/worksheet/selection.hpp create mode 100644 include/xlnt/worksheet/sheet_format_properties.hpp create mode 100644 include/xlnt/worksheet/sheet_pr.hpp create mode 100644 include/xlnt/worksheet/sheet_protection.hpp create mode 100644 include/xlnt/worksheet/sheet_view.hpp create mode 100644 include/xlnt/worksheet/worksheet.hpp create mode 100644 include/xlnt/xlnt.hpp create mode 100644 include/xlnt/xlnt_config.hpp create mode 100644 logo/logo.png create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 python/CMakeLists.txt create mode 100644 python/python_streambuf.hpp create mode 100644 python/setup.py create mode 100644 python/xlntpyarrow.lib.cpp create mode 100644 python/xlntpyarrow/__init__.py create mode 100644 samples/CMakeLists.txt create mode 100644 samples/data/cafe.jpg create mode 100644 samples/data/documentation-print.xlsx create mode 100644 samples/data/encrypted.xlsx create mode 100644 samples/data/penguin.jpg create mode 100644 samples/data/sample1.xlsx create mode 100644 samples/decrypt.cpp create mode 100644 samples/disabled/add_comments.cpp create mode 100644 samples/disabled/basic_conditional_formatting.cpp create mode 100644 samples/disabled/comment_error.cpp create mode 100644 samples/disabled/copy_style.cpp create mode 100644 samples/disabled/create.cpp create mode 100644 samples/disabled/default_styles.cpp create mode 100644 samples/disabled/font_legacy_colors.cpp create mode 100644 samples/disabled/font_rgb_colors.cpp create mode 100644 samples/disabled/group_columns.cpp create mode 100644 samples/disabled/header_footer.cpp create mode 100644 samples/disabled/image.cpp create mode 100644 samples/disabled/merge_unmerge.cpp create mode 100644 samples/disabled/page_setup.cpp create mode 100644 samples/disabled/parse_formulae.cpp create mode 100644 samples/disabled/print_options.cpp create mode 100644 samples/disabled/read.cpp create mode 100644 samples/disabled/row_column_style.cpp create mode 100644 samples/disabled/style_application.cpp create mode 100644 samples/disabled/style_side_effects.cpp create mode 100644 samples/disabled/using_formulae.cpp create mode 100644 samples/disabled/using_number_formats.cpp create mode 100644 samples/disabled/validate_cells.cpp create mode 100644 samples/disabled/worksheet_properties.cpp create mode 100644 samples/disabled/write.cpp create mode 100644 samples/documentation.cpp create mode 100644 samples/img2xlsx.cpp create mode 100644 samples/stb_image.h create mode 100644 source/CMakeLists.txt create mode 100644 source/cell/cell.cpp create mode 100644 source/cell/cell_reference.cpp create mode 100644 source/cell/comment.cpp create mode 100644 source/cell/hyperlink.cpp create mode 100644 source/cell/index_types.cpp create mode 100644 source/cell/phonetic_run.cpp create mode 100644 source/cell/rich_text.cpp create mode 100644 source/cell/rich_text_run.cpp create mode 100644 source/detail/binary.hpp create mode 100644 source/detail/constants.cpp create mode 100644 source/detail/constants.hpp create mode 100644 source/detail/cryptography/aes.cpp create mode 100644 source/detail/cryptography/aes.hpp create mode 100644 source/detail/cryptography/base64.cpp create mode 100644 source/detail/cryptography/base64.hpp create mode 100644 source/detail/cryptography/cipher.hpp create mode 100644 source/detail/cryptography/compound_document.cpp create mode 100644 source/detail/cryptography/compound_document.hpp create mode 100644 source/detail/cryptography/encryption_info.cpp create mode 100644 source/detail/cryptography/encryption_info.hpp create mode 100644 source/detail/cryptography/hash.cpp create mode 100644 source/detail/cryptography/hash.hpp create mode 100644 source/detail/cryptography/sha.cpp create mode 100644 source/detail/cryptography/sha.hpp create mode 100644 source/detail/cryptography/sha1.c create mode 100644 source/detail/cryptography/sha512.c create mode 100644 source/detail/cryptography/value_traits.hpp create mode 100644 source/detail/cryptography/xlsx_crypto_consumer.cpp create mode 100644 source/detail/cryptography/xlsx_crypto_consumer.hpp create mode 100644 source/detail/cryptography/xlsx_crypto_producer.cpp create mode 100644 source/detail/cryptography/xlsx_crypto_producer.hpp create mode 100644 source/detail/default_case.hpp create mode 100644 source/detail/external/include_libstudxml.hpp create mode 100644 source/detail/external/include_windows.hpp create mode 100644 source/detail/header_footer/header_footer_code.cpp create mode 100644 source/detail/header_footer/header_footer_code.hpp create mode 100644 source/detail/implementations/cell_impl.cpp create mode 100644 source/detail/implementations/cell_impl.hpp create mode 100644 source/detail/implementations/conditional_format_impl.hpp create mode 100644 source/detail/implementations/format_impl.hpp create mode 100644 source/detail/implementations/formatting_record.hpp create mode 100644 source/detail/implementations/hyperlink_impl.hpp create mode 100644 source/detail/implementations/style_impl.hpp create mode 100644 source/detail/implementations/stylesheet.hpp create mode 100644 source/detail/implementations/workbook_impl.hpp create mode 100644 source/detail/implementations/worksheet_impl.hpp create mode 100644 source/detail/number_format/number_formatter.cpp create mode 100644 source/detail/number_format/number_formatter.hpp create mode 100644 source/detail/serialization/custom_value_traits.cpp create mode 100644 source/detail/serialization/custom_value_traits.hpp create mode 100644 source/detail/serialization/defined_name.hpp create mode 100644 source/detail/serialization/excel_thumbnail.hpp create mode 100644 source/detail/serialization/open_stream.cpp create mode 100644 source/detail/serialization/open_stream.hpp create mode 100644 source/detail/serialization/serialisation_helpers.hpp create mode 100644 source/detail/serialization/vector_streambuf.cpp create mode 100644 source/detail/serialization/vector_streambuf.hpp create mode 100644 source/detail/serialization/xlsx_consumer.cpp create mode 100644 source/detail/serialization/xlsx_consumer.hpp create mode 100644 source/detail/serialization/xlsx_producer.cpp create mode 100644 source/detail/serialization/xlsx_producer.hpp create mode 100644 source/detail/serialization/zstream.cpp create mode 100644 source/detail/serialization/zstream.hpp create mode 100644 source/detail/unicode.cpp create mode 100644 source/detail/unicode.hpp create mode 100644 source/drawing/spreadsheet_drawing.cpp create mode 100644 source/packaging/ext_list.cpp create mode 100644 source/packaging/manifest.cpp create mode 100644 source/packaging/relationship.cpp create mode 100644 source/packaging/uri.cpp create mode 100644 source/styles/alignment.cpp create mode 100644 source/styles/border.cpp create mode 100644 source/styles/color.cpp create mode 100644 source/styles/conditional_format.cpp create mode 100644 source/styles/fill.cpp create mode 100644 source/styles/font.cpp create mode 100644 source/styles/format.cpp create mode 100644 source/styles/number_format.cpp create mode 100644 source/styles/protection.cpp create mode 100644 source/styles/style.cpp create mode 100644 source/utils/date.cpp create mode 100644 source/utils/datetime.cpp create mode 100644 source/utils/exceptions.cpp create mode 100644 source/utils/path.cpp create mode 100644 source/utils/time.cpp create mode 100644 source/utils/timedelta.cpp create mode 100644 source/utils/variant.cpp create mode 100644 source/workbook/named_range.cpp create mode 100644 source/workbook/streaming_workbook_reader.cpp create mode 100644 source/workbook/streaming_workbook_writer.cpp create mode 100644 source/workbook/workbook.cpp create mode 100644 source/workbook/worksheet_iterator.cpp create mode 100644 source/worksheet/cell_iterator.cpp create mode 100644 source/worksheet/cell_vector.cpp create mode 100644 source/worksheet/header_footer.cpp create mode 100644 source/worksheet/page_margins.cpp create mode 100644 source/worksheet/page_setup.cpp create mode 100644 source/worksheet/phonetic_pr.cpp create mode 100644 source/worksheet/range.cpp create mode 100644 source/worksheet/range_iterator.cpp create mode 100644 source/worksheet/range_reference.cpp create mode 100644 source/worksheet/sheet_protection.cpp create mode 100644 source/worksheet/worksheet.cpp create mode 100644 tests/CMakeLists.txt create mode 100644 tests/cell/cell_test_suite.cpp create mode 100644 tests/cell/index_types_test_suite.cpp create mode 100644 tests/cell/rich_text_test_suite.cpp create mode 100644 tests/data/10_comments_hyperlinks_formulae.xlsx create mode 100644 tests/data/11_print_settings.xlsx create mode 100644 tests/data/12_advanced_properties.xlsx create mode 100644 tests/data/13_custom_heights_widths.xlsx create mode 100644 tests/data/14_images.xlsx create mode 100644 tests/data/15_phonetics.xlsx create mode 100644 tests/data/16_hidden_sheet.xlsx create mode 100644 tests/data/17_xlsm.xlsm create mode 100644 tests/data/18_formulae.xlsx create mode 100644 tests/data/19_defined_names.xlsx create mode 100644 tests/data/1_powerpoint_presentation.xlsx create mode 100644 tests/data/20_active_sheet.xlsx create mode 100644 tests/data/2_minimal.xlsx create mode 100644 tests/data/3_default.xlsx create mode 100644 tests/data/4_every_style.xlsx create mode 100644 tests/data/5_encrypted_agile.xlsx create mode 100644 tests/data/6_encrypted_libre.xlsx create mode 100644 tests/data/7_encrypted_standard.xlsx create mode 100644 tests/data/8_encrypted_numbers.xlsx create mode 100644 "tests/data/9_unicode_\316\233_\360\237\230\207.xlsx" create mode 100644 tests/data/Issue279_workbook_delete_rename.xlsx create mode 100644 tests/data/Issue353_first_row_empty_w_properties.xlsx create mode 100644 tests/data/Issue445_inline_str.xlsx create mode 100644 tests/data/Issue492_empty_row.xlsx create mode 100755 tests/data/Issue494_shared_string.xlsx create mode 100755 tests/data/Issue503_external_link.xlsx create mode 100644 tests/data/excel_test_sheet.xlsx create mode 100644 tests/detail/numeric_util_test_suite.cpp create mode 100644 tests/drawing/drawing_test_suite.cpp create mode 100644 tests/helpers/assertions.hpp create mode 100644 tests/helpers/path_helper.hpp create mode 100644 tests/helpers/temporary_directory.hpp create mode 100644 tests/helpers/temporary_file.hpp create mode 100644 tests/helpers/test_suite.cpp create mode 100644 tests/helpers/test_suite.hpp create mode 100644 tests/helpers/timing.hpp create mode 100644 tests/helpers/xml_helper.hpp create mode 100644 tests/runner.cpp create mode 100644 tests/styles/alignment_test_suite.cpp create mode 100644 tests/styles/color_test_suite.cpp create mode 100644 tests/styles/conditional_format_test_suite.cpp create mode 100644 tests/styles/fill_test_suite.cpp create mode 100644 tests/styles/number_format_test_suite.cpp create mode 100644 tests/styles/protection_test_suite.cpp create mode 100644 tests/styles/style_test_suite.cpp create mode 100644 tests/utils/datetime_test_suite.cpp create mode 100644 tests/utils/helper_test_suite.cpp create mode 100644 tests/utils/optional_tests.cpp create mode 100644 tests/utils/path_test_suite.cpp create mode 100644 tests/utils/timedelta_test_suite.cpp create mode 100644 tests/utils/variant_tests.cpp create mode 100644 tests/workbook/named_range_test_suite.cpp create mode 100644 tests/workbook/serialization_test_suite.cpp create mode 100644 tests/workbook/workbook_test_suite.cpp create mode 100644 tests/worksheet/page_setup_test_suite.cpp create mode 100644 tests/worksheet/range_test_suite.cpp create mode 100644 tests/worksheet/worksheet_test_suite.cpp create mode 160000 third-party/libstudxml create mode 100644 third-party/libstudxml.build/CMakeLists.txt create mode 100644 third-party/miniz/LICENSE create mode 100644 third-party/miniz/miniz.c create mode 100644 third-party/miniz/miniz.h create mode 100644 third-party/pybind11/.appveyor.yml create mode 100644 third-party/pybind11/.gitignore create mode 100644 third-party/pybind11/.gitmodules create mode 100644 third-party/pybind11/.readthedocs.yml create mode 100644 third-party/pybind11/.travis.yml create mode 100644 third-party/pybind11/CMakeLists.txt create mode 100644 third-party/pybind11/CONTRIBUTING.md create mode 100644 third-party/pybind11/ISSUE_TEMPLATE.md create mode 100644 third-party/pybind11/LICENSE create mode 100644 third-party/pybind11/MANIFEST.in create mode 100644 third-party/pybind11/README.md create mode 100644 third-party/pybind11/include/pybind11/attr.h create mode 100644 third-party/pybind11/include/pybind11/buffer_info.h create mode 100644 third-party/pybind11/include/pybind11/cast.h create mode 100644 third-party/pybind11/include/pybind11/chrono.h create mode 100644 third-party/pybind11/include/pybind11/class_support.h create mode 100644 third-party/pybind11/include/pybind11/common.h create mode 100644 third-party/pybind11/include/pybind11/complex.h create mode 100644 third-party/pybind11/include/pybind11/descr.h create mode 100644 third-party/pybind11/include/pybind11/eigen.h create mode 100644 third-party/pybind11/include/pybind11/embed.h create mode 100644 third-party/pybind11/include/pybind11/eval.h create mode 100644 third-party/pybind11/include/pybind11/functional.h create mode 100644 third-party/pybind11/include/pybind11/numpy.h create mode 100644 third-party/pybind11/include/pybind11/operators.h create mode 100644 third-party/pybind11/include/pybind11/options.h create mode 100644 third-party/pybind11/include/pybind11/pybind11.h create mode 100644 third-party/pybind11/include/pybind11/pytypes.h create mode 100644 third-party/pybind11/include/pybind11/stl.h create mode 100644 third-party/pybind11/include/pybind11/stl_bind.h create mode 100644 third-party/pybind11/include/pybind11/typeid.h create mode 100644 third-party/pybind11/pybind11/__init__.py create mode 100644 third-party/pybind11/pybind11/__main__.py create mode 100644 third-party/pybind11/pybind11/_version.py create mode 100644 third-party/pybind11/setup.cfg create mode 100644 third-party/pybind11/setup.py create mode 100644 third-party/pybind11/tools/FindCatch.cmake create mode 100644 third-party/pybind11/tools/FindEigen3.cmake create mode 100644 third-party/pybind11/tools/FindPythonLibsNew.cmake create mode 100644 third-party/pybind11/tools/check-style.sh create mode 100644 third-party/pybind11/tools/libsize.py create mode 100644 third-party/pybind11/tools/mkdoc.py create mode 100644 third-party/pybind11/tools/pybind11Config.cmake.in create mode 100644 third-party/pybind11/tools/pybind11Tools.cmake create mode 100644 third-party/utfcpp/LICENSE create mode 100644 third-party/utfcpp/utf8.h create mode 100644 third-party/utfcpp/utf8/checked.h create mode 100644 third-party/utfcpp/utf8/core.h create mode 100644 third-party/utfcpp/utf8/cpp11.h create mode 100644 third-party/utfcpp/utf8/unchecked.h diff --git a/.appveyor.yml b/.appveyor.yml new file mode 100644 index 0000000000..ca280af420 --- /dev/null +++ b/.appveyor.yml @@ -0,0 +1,36 @@ +version: "{build}" +os: Visual Studio 2015 + +cache: + - vcpkg -> .appveyor.yml + +platform: + - x64 + +configuration: + - Debug + +environment: + matrix: + - STATIC: OFF + - STATIC: ON + +matrix: + fast_finish: true + +init: [] + +before_build: + - git submodule update --init --recursive + - mkdir build + - cd build + - cmake -G "Visual Studio 14 2015" -D CMAKE_GENERATOR_PLATFORM=%platform% -D STATIC=%STATIC% -D SAMPLES=ON -D BENCHMARKS=ON -D TESTS=ON .. + +build: + project: build/xlnt_all.sln + parallel: true + verbosity: minimal + +test_script: + - tests\%configuration%\xlnt.test.exe + - samples\%configuration%\sample-documentation.exe diff --git a/.circleci/config.yml b/.circleci/config.yml new file mode 100644 index 0000000000..e3d2a887a2 --- /dev/null +++ b/.circleci/config.yml @@ -0,0 +1,79 @@ +version: 2.1 + +jobs: + build: + docker: + - image: lycantropos/cmake:3.9.5 + parameters: + benchmarks: + default: "OFF" + type: string + build-type: + default: Release + type: string + coverage: + default: "OFF" + type: string + cxx-ver: + default: "11" + type: string + samples: + default: "OFF" + type: string + static: + default: "ON" + type: string + steps: + - checkout + - run: git submodule update --init --recursive + - run: cmake -D XLNT_CXX_LANG=<< parameters.cxx-ver >> -D STATIC=<< parameters.static >> -D BENCHMARKS=<< parameters.benchmarks >> -D TESTS=ON -D SAMPLES=<< parameters.samples >> -D COVERAGE=<< parameters.coverage >> -D CMAKE_BUILD_TYPE=<< parameters.build-type >> . + - run: cmake --build . -- -j2 + - run: ./tests/xlnt.test + - when: + condition: + equal: ["ON", << parameters.samples >>] + steps: + - run: ./samples/sample-decrypt + - run: ./samples/sample-img2xlsx ./samples/data/penguin.jpg img.xlsx + - run: ./samples/sample-documentation + - when: + condition: + equal: ["ON", << parameters.benchmarks >>] + steps: + - run: ./benchmarks/benchmark-styles + - run: ./benchmarks/benchmark-writer + - when: + condition: + equal: ["ON", << parameters.coverage >>] + steps: + - run: lcov --directory source/CMakeFiles/xlnt.dir --capture --output-file coverage.info --base-directory ../source --no-external --gcov-tool /usr/bin/gcov-6 + - run: lcov --output-file coverage.info --remove coverage.info source/detail/serialization/miniz.cpp + - run: i=$(dirname $(pwd)) + - run: sed -i "s|$i/||" coverage.info + - run: cd .. + - run: coveralls-lcov build/coverage.info + +workflows: + build: + jobs: + - build: + name: tests + matrix: + parameters: + cxx-ver: + - "11" + - "17" + build-type: + - Release + - Debug + static: + - "ON" + - "OFF" + - build: + name: samples-benchmarks-coverage + cxx-ver: "11" + build-type: Debug + static: "ON" + samples: "ON" + benchmarks: "ON" + coverage: "OFF" diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000000..f6c1ac6d06 --- /dev/null +++ b/.clang-format @@ -0,0 +1,67 @@ +--- +BasedOnStyle: LLVM +AccessModifierOffset: -4 +AlignAfterOpenBracket: DontAlign +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignOperands: false +AlignTrailingComments: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: None +AllowShortIfStatementsOnASingleLine: true +AllowShortLoopsOnASingleLine: false +AlwaysBreakBeforeMultilineStrings: true +AlwaysBreakTemplateDeclarations: true +BraceWrapping: + AfterClass: true + AfterControlStatement: true + AfterEnum: true + AfterFunction: true + AfterNamespace: false + AfterObjCDeclaration: true + AfterStruct: true + AfterUnion: true + BeforeCatch: true + BeforeElse: true +BreakBeforeBinaryOperators: NonAssignment +BreakBeforeBraces: Custom +ColumnLimit: 0 +ConstructorInitializerAllOnOneLineOrOnePerLine: true +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +IncludeCategories: + - Regex: '^$' + Priority: 2 + - Regex: '^&' + Priority: 1 + - Regex: '^".*"' + Priority: 5 +IndentCaseLabels: false +IndentWidth: 4 +KeepEmptyLinesAtTheStartOfBlocks: false +Language: Cpp +NamespaceIndentation: None +MaxEmptyLinesToKeep: 1 +PenaltyBreakComment: 1000 +PointerAlignment: Right +SortIncludes: true +SpaceAfterCStyleCast: false +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInCStyleCastParentheses: false +SpacesInContainerLiterals: true +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Cpp11 +UseTab: Never + +... diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..2125666142 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +* text=auto \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000..41450d729a --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +build/ +docs/build/ +docs/doxyxml/ +node_modules/ +*.obj +*.sdf +*.suo +*.opensdf +*.vcxproj.user +*.o +#*# +*~ +.DS_Store +__pycache__/ +Win32/ +*.pyd +python/record.txt +python/xlntpyarrow.egg-info/ +/x64/ +.envrc +.vscode +/dist/ +/.vs/ +/out/ +/CMakeSettings.json diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000000..0612ce3772 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "third-party/libstudxml"] + path = third-party/libstudxml + url = https://git.codesynthesis.com/libstudxml/libstudxml.git diff --git a/.release-it.json b/.release-it.json new file mode 100644 index 0000000000..109f217534 --- /dev/null +++ b/.release-it.json @@ -0,0 +1,24 @@ +{ + "git": { + "commitMessage": "release v${version}", + "requireBranch": "master", + "requireCommits": true, + "tagAnnotation": "release v${version}", + "tagName": "v${version}" + }, + "github": { + "release": true, + "releaseName": "xlnt v${version}" + }, + "npm": { + "publish": false + }, + "plugins": { + "@release-it/bumper": { + "out": { + "file": "source/CMakeLists.txt", + "type": "text/plain" + } + } + } +} diff --git a/AUTHORS.md b/AUTHORS.md new file mode 100644 index 0000000000..7f58746d0a --- /dev/null +++ b/AUTHORS.md @@ -0,0 +1,13 @@ +This project was started by Thomas Fussell. + +It was initially inspired by the openpyxl library: https://openpyxl.readthedocs.org + +Thanks to everyone who has contributed to this project (in alphabetical order): + +* adam-nielsen +* Malvineous +* sukoi26 +* tpmccallum +* xpol + +Project logo designed by Thomas Fussell. diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000..89ab4780b8 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,4 @@ +# Change Log + +This project adheres to [Semantic Versioning](http://semver.org/). +Every release is documented on the Github [Releases](https://github.com/tfussell/xlnt/releases) page. diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000000..a9ed23fd9b --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,59 @@ +cmake_minimum_required(VERSION 3.1) +project(xlnt_all) + +add_compile_options("$<$:/utf-8>") +add_compile_options("$<$:/utf-8>") + +# CTest setup +# include (CTest) # Add this for valgrind support; CTest works without it +enable_testing() + +# This indicates to CMakeLists in subdirectories that they are part of a larger project +set(COMBINED_PROJECT TRUE) + +# Library type +option(STATIC "Set to ON to build xlnt as a static library instead of a shared library" OFF) + +# c++ language standard to use +set(XLNT_VALID_LANGS 11 14 17) +set(XLNT_CXX_LANG "14" CACHE STRING "c++ language features to compile with") +# enumerate allowed values for cmake gui +set_property(CACHE XLNT_CXX_LANG PROPERTY STRINGS ${XLNT_VALID_LANGS}) +# validate value is in XLNT_VALID_LANGS +list(FIND XLNT_VALID_LANGS ${XLNT_CXX_LANG} index) +if(index EQUAL -1) + message(FATAL_ERROR "XLNT_CXX_LANG must be one of ${XLNT_VALID_LANGS}") +endif() + + +# Optional components +option(TESTS "Set to ON to build test executable (in ./tests)" OFF) +option(SAMPLES "Set to ON to build executable code samples (in ./samples)" OFF) +option(BENCHMARKS "Set to ON to build performance benchmarks (in ./benchmarks)" OFF) +option(PYTHON "Set to ON to build Arrow conversion functions (in ./python)" OFF) + +# Platform specific options +if(MSVC) + option(STATIC_CRT "Link with the static version of MSVCRT (/MD[d])" OFF) +else() + option(COVERAGE "Generate coverage data using gcov" OFF) +endif() + +# Add components according to selected options +if(SAMPLES) + add_subdirectory(samples) +endif() + +if(BENCHMARKS) + add_subdirectory(benchmarks) +endif() + +if(TESTS) + add_subdirectory(tests) +endif() + +if(PYTHON) + add_subdirectory(python) +endif() + +add_subdirectory(source) diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000000..76d62a21b6 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,46 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at thomas.fussell@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version] + +[homepage]: http://contributor-covenant.org +[version]: http://contributor-covenant.org/version/1/4/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000..29f07242bb --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,31 @@ +# Contributing to xlnt + +xlnt welcomes contributions from everyone regardless of skill level (provided you can write C++ or documentation). + +## Getting Started + +Look through the list of issues to find something interesting to work on. Help is appreciated with any issues, but important timely issues are labeled as "help wanted". Issues labeled "docs" might be good for those who want to contribute without having to know too much C++. You might also find something that the code is missing without an associated issue. That's fine to work on to, but it might be best to make an issue first in case someone else is working on it. + +## Contributions + +Contributions to xlnt should be made in the form of pull requests on GitHub. Each pull request will be reviewed and either merged into the current development branch or given feedback for changes that would be required to do so. + +All code in this repository is under the MIT License. You should agree to these terms before submitting any code to xlnt. + +## Pull Request Checklist + +- Branch from the head of the current development branch. Until version 1.0 is released, this the master branch. + +- Commits should be as small as possible, while ensuring that each commit is correct independently (i.e. each commit should compile and pass all tests). Commits that don't follow the coding style indicated in .clang-format (e.g. indentation) are less likely to be accepted until they are fixed. + +- If your pull request is not getting reviewed or you need a specific person to review it, you can @-reply a reviewer asking for a review in the pull request or a comment. + +- Add tests relevant to the fixed defect or new feature. It's best to do this before making any changes, make sure that the tests fail, then make changes ensuring that it ultimately passes the tests (i.e. TDD). xlnt uses cxxtest for testing. Tests are contained in a tests directory inside each module (e.g. source/workbook/tests/test_workbook.hpp) in the form of a header file. Each test is a separate function with a name that starts like "test_". See http://cxxtest.com/guide.html for information about CxxTest or take a look at existing tests. + +## Conduct + +Just try to be nice--we're all volunteers here. + +## Communication + +Add a comment to an existing issue on GitHub, open a new issue for defects or feature requests, or contact @tfussell if you want. diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000000..0ff4e1d986 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,493 @@ +# License + +## [xlnt](https://github.com/tfussell/xlnt) +>[MIT License](https://github.com/tfussell/xlnt/blob/master/LICENSE.md) + +``` +Copyright (c) 2014-2018 Thomas Fussell + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +``` + +# Dependency Licences + +## [utfcpp](https://github.com/nemtrif/utfcpp) +>[Boost Software License - Version 1.0](https://github.com/nemtrif/utfcpp/blob/master/source/utf8.h) + +``` +Copyright 2006 Nemanja Trifunovic + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +``` + +## [POLE](http://www.dimin.net/software/pole/) +>[BSD 2-Clause License](https://bitbucket.org/dimin/pole/src/c15e513bdce4c3a52b3dbc925d4d2bb520dc71d8/pole/LICENSE) + +``` +POLE - Portable C++ library to access OLE Storage +Copyright (C) 2002-2007 Ariya Hidayat (ariya@kde.org). All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +``` + +## [libstudxml](http://www.codesynthesis.com/projects/libstudxml/) +>[MIT License](http://www.codesynthesis.com/licenses/mit.txt) + +``` +Summary: Everything is licensed under the MIT License (text below). + +Code found in the xml/details/expat/ directory is distributed under +the MIT License (see the xml/details/expat/LICENSE file for copyright +information). + +Code found in the xml/details/genx/ directory is distributed under +the MIT License (see the xml/details/genx/LICENSE file for copyright +information). + +The rest is Copyright (c) 2013-2014 Code Synthesis Tools CC and is +distributed under the MIT License: + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +``` + +## [PartIO](https://www.disneyanimation.com/technology/partio.html) +>[BSD 3-Clause License (with specific non-attribution clause)](https://github.com/wdas/partio/blob/master/src/lib/io/ZIP.h) + +``` +Copyright 2010 Disney Enterprises, Inc. All rights reserved + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in +the documentation and/or other materials provided with the +distribution. + +* The names "Disney", "Walt Disney Pictures", "Walt Disney Animation +Studios" or the names of its contributors may NOT be used to +endorse or promote products derived from this software without +specific prior written permission from Walt Disney Pictures. + +Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND +CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, +BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED. +IN NO EVENT SHALL WALT DISNEY PICTURES, THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND BASED ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +``` + +## [miniz](https://github.com/richgel999/miniz) +>[Public Domain/MIT License](https://github.com/richgel999/miniz/blob/master/LICENSE) + +``` +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to + +Copyright 2013-2014 RAD Game Tools and Valve Software +Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +``` + + +## [SHA-512 hash in C](https://www.nayuki.io/page/fast-sha2-hashes-in-x86-assembly) +>[MIT License](https://www.nayuki.io/res/fast-sha2-hashes-in-x86-assembly/sha512.c) + +``` +Copyright (c) 2016 Project Nayuki + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +``` + +## [SHA-1 hash in C](https://www.nayuki.io/page/fast-sha1-hash-implementation-in-x86-assembly) +>[MIT License](https://www.nayuki.io/res/fast-sha1-hash-implementation-in-x86-assembly/sha1-fast.c) + +``` +Copyright (c) 2014 Project Nayuki + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +``` + +## [LibTomCrypt](http://www.libtom.net/) +>[Public Domain](https://github.com/libtom/libtomcrypt/blob/develop/LICENSE) + +``` +LibTomCrypt is public domain. As should all quality software be. + +Tom St Denis +``` + +# Dependency Licences (Python Module) + +## [pybind11](https://github.com/pybind/pybind11) +>[BSD 3-Clause License](https://github.com/pybind/pybind11/blob/master/LICENSE) + +``` +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +You are under no obligation whatsoever to provide any bug fixes, patches, or +upgrades to the features, functionality or performance of the source code +("Enhancements") to anyone; however, if you choose to make your Enhancements +available either publicly, or directly to the author of this software, without +imposing a separate written license agreement for such Enhancements, then you +hereby grant the following license: a non-exclusive, royalty-free perpetual +license to install, use, modify, prepare derivative works, incorporate into +other computer software, distribute, and sublicense such enhancements or +derivative works thereof, in binary and source code form. +``` + + +# Dependency Licences (Testing Only) + +## [CxxTest](http://cxxtest.com/) +>[LGPL License](https://github.com/CxxTest/cxxtest/blob/master/COPYING) + +``` + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. +``` diff --git a/README.md b/README.md new file mode 100644 index 0000000000..18484d387c --- /dev/null +++ b/README.md @@ -0,0 +1,52 @@ +xlnt logo
+==== + +[![Travis Build Status](https://travis-ci.org/tfussell/xlnt.svg?branch=master)](https://travis-ci.org/tfussell/xlnt) +[![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/2hs79a1xoxy16sol?svg=true)](https://ci.appveyor.com/project/tfussell/xlnt) +[![Coverage Status](https://coveralls.io/repos/github/tfussell/xlnt/badge.svg?branch=master)](https://coveralls.io/github/tfussell/xlnt?branch=master) +[![Documentation Status](https://legacy.gitbook.com/button/status/book/tfussell/xlnt)](https://tfussell.gitbooks.io/xlnt/content/) +[![License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](http://opensource.org/licenses/MIT) + +## Introduction +xlnt is a modern C++ library for manipulating spreadsheets in memory and reading/writing them from/to XLSX files as described in [ECMA 376 4th edition](http://www.ecma-international.org/publications/standards/Ecma-376.htm). The first public release of xlnt version 1.0 was on May 10th, 2017. Current work is focused on increasing compatibility, improving performance, and brainstorming future development goals. For a high-level summary of what you can do with this library, see [the feature list](https://tfussell.gitbooks.io/xlnt/content/docs/introduction/Features.html). Contributions are welcome in the form of pull requests or discussions on [the repository's Issues page](https://github.com/tfussell/xlnt/issues). + +## Example + +Including xlnt in your project, creating a new spreadsheet, and saving it as "example.xlsx" + +```c++ +#include + +int main() +{ + xlnt::workbook wb; + xlnt::worksheet ws = wb.active_sheet(); + ws.cell("A1").value(5); + ws.cell("B2").value("string data"); + ws.cell("C3").formula("=RAND()"); + ws.merge_cells("C3:C4"); + ws.freeze_panes("B2"); + wb.save("example.xlsx"); + return 0; +} +// compile with -std=c++14 -Ixlnt/include -lxlnt +``` + +## Documentation + +Documentation for the current release of xlnt is available [here](https://tfussell.gitbooks.io/xlnt/content/). + +## Building xlnt - Using vcpkg + +You can download and install xlnt using the [vcpkg](https://github.com/microsoft/vcpkg) dependency manager: + + git clone https://github.com/microsoft/vcpkg.git + cd vcpkg + ./bootstrap-vcpkg.sh + ./vcpkg integrate install + ./vcpkg install xlnt + +The xlnt port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/microsoft/vcpkg) on the vcpkg repository. + +## License +xlnt is released to the public for free under the terms of the MIT License. See [LICENSE.md](https://github.com/tfussell/xlnt/blob/master/LICENSE.md) for the full text of the license and the licenses of xlnt's third-party dependencies. [LICENSE.md](https://github.com/tfussell/xlnt/blob/master/LICENSE.md) should be distributed alongside any assemblies that use xlnt in source or compiled form. diff --git a/SUMMARY.md b/SUMMARY.md new file mode 120000 index 0000000000..0e01b4308c --- /dev/null +++ b/SUMMARY.md @@ -0,0 +1 @@ +docs/README.md \ No newline at end of file diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt new file mode 100644 index 0000000000..3c00ccda1f --- /dev/null +++ b/benchmarks/CMakeLists.txt @@ -0,0 +1,48 @@ +cmake_minimum_required(VERSION 3.1) +project(xlnt.benchmarks) + +# Require C++11 compiler +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +if(NOT COMBINED_PROJECT) + # Include xlnt library + add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../source ${CMAKE_CURRENT_BINARY_DIR}/source) +endif() + +if(STATIC_CRT) + include(${CMAKE_CURRENT_SOURCE_DIR}/../cmake/ucm.cmake) + ucm_set_runtime(STATIC) +endif() + +set(XLNT_BENCHMARK_DATA_DIR ${CMAKE_CURRENT_SOURCE_DIR}/data) + +file(GLOB BENCHMARK_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) + +foreach(BENCHMARK_SOURCE IN ITEMS ${BENCHMARK_SOURCES}) + # Convert .cpp to benchmark- + get_filename_component(BENCHMARK_NAME ${BENCHMARK_SOURCE} NAME_WE) + set(BENCHMARK_EXECUTABLE benchmark-${BENCHMARK_NAME}) + + add_executable(${BENCHMARK_EXECUTABLE} ${BENCHMARK_SOURCE}) + + target_link_libraries(${BENCHMARK_EXECUTABLE} PRIVATE xlnt) + # Need to use some test helpers + target_include_directories(${BENCHMARK_EXECUTABLE} + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../tests) + target_compile_definitions(${BENCHMARK_EXECUTABLE} + PRIVATE XLNT_BENCHMARK_DATA_DIR=${XLNT_BENCHMARK_DATA_DIR}) + + if(MSVC AND NOT STATIC) + # Copy xlnt DLL into benchmarks directory + add_custom_command(TARGET ${BENCHMARK_EXECUTABLE} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + $ + $) + endif() +endforeach() + +option(XLNT_MICROBENCH_ENABLED "Enable small benchmarks typically used for development" OFF) +if (XLNT_MICROBENCH_ENABLED) + add_subdirectory(microbenchmarks) +endif() \ No newline at end of file diff --git a/benchmarks/data/large.xlsx b/benchmarks/data/large.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..22d8d9f5a0f78f1d75839be95a2c9152cf7fe659 GIT binary patch literal 1927750 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

2tHsy;fU_4z&m!>TPtW!Gj=!2c)dA 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�FX67et>KN?FD3m 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 DmY2zE{K>7}E9J*EJobwER6NRtpfrsu}+_B#> zQ69p&;(68;W4F;L*E6mwO5V0Kmcff2yCuoHHl3UX z98dSG&~~{Q>Sg4d@)>oXiX}RR?i9wD>3}8bizWIqmgowsq7_71IAa6{61I3ZHJoas zEK$V}yrFYVQA2ch34bm#a@|uj#!j{PXf%HbBmYYt8ZKf8!>RG(x^(U@m>zg#Sa?>} zwWik{yT;>QH65?czRRl|zP)drpMsSI-AV;cY14tT zz+BzXkgwcriWXGRDImN$&{h(_Rhp=)h^7K6POJKo)5u^Ckus59+Wb*|YbiET3{hvv zjJA^7;>vC5z%C+bRbR0+O0|UDDIKrRHq3!wp<=0;F;8wzUvJL9-W;1a0*gpZoFZ6I zj=&_2pzTwGwRFze0K}H2XBiYEmJK^XZ)}#v+Q>$&tgH>jfR_xA+?I0e@+hb1>^>|f zWxeE7QaX8V_;$71;9zEK=a{i= z*P5|$7hccjk_|sejvXvneUYml!_aR0pf0_bD~FS3rQlEJpCO*#Gh zgZdxgO|CYTTcC~|%EZi+4|bJH?#^SNGEK5_d%T{b<(2*t!@MdvsUJZDSgFmYd$tSQ_R%h`leJ&g&&y4OO&4O}T@6H%8DU|~`WH__7 zdd%8BV5QM(|ANerE=b5)5b>4waL!BqN7$X-=o? zgFKJmn&NTq_mt}?kNc!NOi4-D^Zfpvub$q2vN+|RO({=i_gyN-?Jdg5|$K&{y3D-WBv!n{$G` zdXV(|x!;|_z9m01-x5{_+xBufn@85LivX@_S$&go zNC;QUk-U+*b1(>3gOR!;b>&z{jgZ_0XVtk=(c8%>b|dRJZt2l+%+zoCCKj;0H0Q{{ z56}O()OlRxh12J)u>Pd{#%bT&T06I4SFi4kigXw>V#1XvH;dZ4x03IlgpgGLXx4oQ zSx!i8MQRZ|`Ne1%Q%R6nPp?*RS~=m_q!Q8QEl%dU zKeMyYvZk~uoH%RTm5F11`Km;8Tvx$nMNZwF9I-n@C|YNVDtuF9rT%h&DYinHvVukB zB9y7&P^OkcnX-mOg)|1~E0L}uWo=>;KZ?RLdx>H`n`~{w%+S6q%5x|+XeJcYy7WLefuhD^TBO}`EYKUuynT9 z5|+-OhEAVU8d_A)D;XGB5hY{x(V$0RxkO0o+Q@?et_hybYS1)(@{=>Lu=W?8e?;+V zyxt6)O5w16itD$(lu6^tHlgov$MVDTg4j|7e$6Dga?ANbvnjw8Hif5?yOqXpTm{LB z8`a=T%Lkk^yO6A(?^Sv?X5Un~^Bd)6+no?J${hLQru=ayt&^?b4+tv_b}cwydk5Z8 z^H$QN)0at;mJk-6fR_?RL~S;`*BcPlxXtssUuZhCEbyyt#RPtJ?0dz^x};cHBNZ!a zmttl0QLL;FVP(nPvFBcy@*~pmSFe;n2HC$7lJ(`#U1n|-cz{}Q&vFTpWyP_w3(2~@ zXgzR0KihQH6~rU=Y)bC@ZVmp*K_0xrdZk9YY|d#zl0Mj7=e+HL-tPgw8fpsss+(eE zHB_vu)rysMTCuVQD^^wm#mcI%aYC(2QSvO5goCFG*W91S>>%WSRl?57WU#Xv){*R9(z2cJ0llsLn<`1ExXvkNF zN&g*utQSi%@UaAq)vtD9z@LL_*A4jdOwR#V)A?8{1-#Qpz&jNH?*Kxw29|YFs7O-< zo3l}{Irf4`a@l+B`Re+y$WuhNk~)EqlV-^ur9Ar#4E7FPQ^&KNPuR1Cm%Kx-s^VM0 zQmpYIY5|IVs`xg=HL7ST#nY9yx!7Myll`|$K4Sl=mCZrh&OQ|VD4tZsVM_Hy4OFTsPLkq!bp?t}1%_&Zu)bcBev_Yf znp0&aVrgTuLTl9bbnyxE4qha`Ruu}3YlLQi#J zUqk=mn$$h|x6&u4Z^=EMAvb>oq%z=14WtdnT@fDAA}CljzY!i%SNK@#779JdP)j!ot9*1u7e+$@Kt>lkU@`sDh znz@}9c&`1ci+AX?kJ15ENQp@GU}m+YmQk5i&EYUIgt4Tp{Onqs(T$5(D0d>~ z(kG_{WmccgHAhIea3f*yE+^qRvCy`HW0D8@dRv)k|&@Sz_jl}rNu{9 zlor2{UmlVIF^$*$6<|V_r&(J_v-(Q2#tI)#vCrm$#HuQktXJ}{thw6-^zhO^L*+#! z4Xf%ZAg?i8fw835p=0ey=~Tsci7Z`T63&9Hq>zn_y-=jy5!rmlUc$Jd2;)jHX&*gI zrLUbRvM6Ah7Te?hWADx5Yr4Mwe;Pv(w3IZ6ISCasgCS|mv&0w)iK&$dHB`ks1g$D+ z3?VTS5hT0`T54*G2x5w%L21=Y4UMTH$!|S(>LyoilAB1b_xt<#{c|7ZzOr-9xo4j} zti9HHZcoCvqF7O#t-`oiQMGqdJ_{C8e?3{G%&0^7re>STf~#<|I^VrVlqU>T0 z3pv*ckxn5!L7E`a2&6xd{y~~3(srarNQp@PB0WLM-(RHs!6HrKTq{L-AE_YHWX^?D z1*wQ+pD&!^Bj;Kvxg6GHpBG2^N~9-9&5+(l`dXxVt3>L8R0e6PNF$IwLo!ABhI1he zLo!2}#<`FtBUM5AmUEGPKCiz-E1P@BeNC5)j}b_#kZK~OB!Nt|OOQ=gB*rS0s*!Q7 zs5l=b1>)#zsg`se3r$>4nhiQ6wsxc2HszsW>z$h(IH$JbcK)0^rtb1%GELg>z`y5~ zy;3y@z)v6Pl=q&D;_wA%ASzqJgava4F9L-%^oG3&*0;s>iUgRy?c=2Lt#mN)d`H?W~r8H|ucVc^k%WA;Cff zlcrvArb03-q$O>{+ut2;|7INheTdfEO|;$^qV?kM(By=hMa+PBoIckX+9Cb;cCAg+ zWW#SEM0D4k++wgS4_v*oBD^$r2k>!1_3_p zBLjM~Bx<|@Uxj56yvD##?u0C`u1;)Z1>Dw`Qk8`afufSMB&(az~+eqw)J^sd2 ztVf>Hu~cHo|2uT7yoqV58nf56)`rXjJ|d4xGxl9ZdzU@J1$R}43hzx&z%IhyN6-u3 zW%6{6$y2yi&9{pbIM1CT5-608bcx3`OlAzVQuiQFP0pZyQ{hrMN#V|UAQU55>J_<( zHw#V5aXNS|#5A>ylqiB-dXJ~l=l(`bs*Hyguf^?=#@2!)CY9^Zg1M8?fTxlY^RCXJ zoCl{@q@H%6Y-D(3cL#KO>&#AXN1tAtQbu(1n)Gl(NZE~(N&#N!ohd34W>1}isl7J_ z&=CxvZbXx;CvCAb>5ct2Af8boAto-#cy2{)v5@gHS8Rzuefp#9}u5m-^+_o$qSVgwjz_#c3$V;omu(pV{ z_0vY4`2}9J*US?GNU3pDl@;sC93zEzy)ne=#rJ1=e2RFzHRKcuHf!LrMlkPEX3Sk8 zZn5BzN#2?)cqm?v+Q863E4L*St04VJf*d9HHZr!rqBKD0L-d1`8S z-bn?6CnQRG*%NxoPpHIE44e;0482Tk@2*8{pQpBmP}{#z+dr-;Evf4C-%p99&%!Dq z*Km(c95^jjWxN~44AEiu2x-a-%cK>SiT;O)!XqyM&9|R<90Yu6&BuLvmbv zmbGFaoykBt4wH!9okahR@*W83Fu_Ti1+Srdw2YA)m@bhj2?diTf!zHho}yx1NfLfG z5n0;lEQ_!YGr$38Qd+=dNiW)-?xYk`cUA>HLdqM{gjJQSGt9HJA9R=$8A%o~k|MaF zn)JXKhec}^8SATb#nD<$#fXDJCgsOybTDkg{7@a}7${1pLpy!6=Joo=y(}WS) zffp&8W=>K1^{lW2Itn!nmdN)SY_6df9xEx#?E|gR^eLI5_sA5DGohK+rB(N3g0>e6 zSnyb~ytS7GK7j_V;;>&eaJ5SJM%f|%OXOZUg>t-{t*KscNBwgw(E|kYs;DW9xHKYg zX}m5~Rm3YjN7HtZvTPiix%=QamA#b8wh!=;CF~pII~*rLbtws|_6_6>7(Rq4y6gzz zX2<$q4DY2TSL4m3*OEMRcPudp z(pSgaDTR2|iz%}{K=270-9D%!^|@17!AGf2H^%7*tYCv>e;7RRe4FNqxtUU)&2ueK zYg1jBE4z?Vq`2HJEHb&U$fSteE-W&sg$I|Eu~QbP24pc;mN^xkVDTVGf4qP<;S~U0 zGj1>E)l=32Ii-FEg=HDuKG9rJ*$H_~#$x5H11W^N>Pk&$9(iLr)bVVm^3MlYLN#e? zE{vY*7(GiWpwuQ0sDwClqkIq zRVuaq$>3`CthJqnB4a&8607J229h_4==vYNW({dzSt{?G^XkRPQVt-&ZK+Ij_myHR z=zpj$J^1v!XW}U`lm57(%&s!9kARE1v+xutT!#*|K03;X8pw!h#fa)&pFa(f7r-}; z7eKgKsj&cJ7A1DQyHw{w$miITMqp`WFZlTsO38o6n;WN+M(&bt z>=J~FWW}ucpfop~L^{m|MvCTMucXxJAgVh~Rd;R7;hq>lJ4pH;Oy_>OZdmE?GhcPN-jwfYL)RmBJCn&@3LSZvi75R<|X8rr;oMqWu_$Etjv_eKYK$@ z4?-~&edWZoZ4pbHby(u;m70LA+#B>LWoZey?qhi){BEXhm&~}m>L07h)F$r(xYF-U za)GC*yeG5Net@-TU~UYO5lo$W;;{W5*ZUCcqD$|jjayXlR6BIK-Zcx0j?%1saSp1b zsf$`r%SNnQjia(hQJtxQU6}WI>`Y1ZoER#SOLN66cP3;ZA{PtIgW}Mhfzy$Ja|{D# zycNy@1rd#8;PhqSJi)-ZoPpD^U8Jyrm+7>E)4PjO3hP9Ir`kbz=OWRVAQ?Gj3}KaM zM{;SdnAee9b6G!Hu48Me=HZb?Y#bkXcDy$F>fnwajJ|q)X^lq*qLx->lR;PaS(Zul zEz3DR^6t28^wl}`r~a6}$o_qr>KvIK6_&o+o}f9J_I#hsGXK^Y z*Re`ml~tnmq5dY39(=3~MZr&PfPba`;Y7S3$~1xen|@=#RKJi8cvg2DC$8c+!TBRr z;RXO%VdBBa#$gsdBXPtguRUi<JYyPo>Q?M+6#2aemAZv- z+>>!UigA24<9LN!a+GLWG8s8aa>@G0^z{576=0RAjglv&beJ2GS|ZU@>zOm3W@&#d z9y%vHbc-@_!Ap7l0a+W|wmD*Bfxo*MtWrw|i2s~`_&iB1(XlDX|H*64W5B{z(r?e{wwepV)psA8g|95&r$lo1K>Ykrcn~pwC_Zq-~2ok3X@ZtkYl$g#0E2 z?%BSSzxg*D*JI{~7xPsz`MmrefA$+vdVH^YgTI+G^QYPmVPrL~V__ol@bcq(eK%y< zoSA3M9`-feva3KPlZ~H#t^9=+czV35tEsK>#^*Q~c#7>#vaAHBa~zyO>5QFg(`kF6(L7)^9u7QMex zfRA9S{2*m@fs{2*NLB%!B5hl|G^s(Gdv!&diuS2!kHKO+f^IbiskcaWNIxMBM)Kff zkh10>eTLMXlYzzh49OL#8|PXelJ#1FQ?(N~RX`VkQ`tef%8%3tsiR1K0V16WS=nSz z>4aLMIf=Fn($y-kR^}9IE7D`IR>P1?ky>#wq-IFPMT-B`dD!Vn4VUEaBQ%_cLO_`! z1eEetwhonB_vrek^_(LM1cYO2<>XL#WDh|z7;gzzjH}K+zUO4sQ!pt#M*8i)wgWUn z&E&;}y7tRw;}lZB%b{(%_YW_aJKtvRfGXxwE4#F4-@aMsv;`l0<@|olnuUWbx^{if z#x=xIxGDVr@Kg_I2kGj9kgkFncAf8h=M+e*=Yq6~>LW<2lOV0e2$9MN?$sr@S3e5( zstbi~QK**`np-UT+C+zGCBiECuQa+-@RVQEJy#c$2s^*>RQ@MbD>H^Yeq~#(-BfUVH zgtU@UV6DnQy80GrHKmXokmh#%)8rOFrvOM-+aO(8L%Ql9q^kf(SC5gJA$1WtRRE+b zI~Z1709LsoLAvro`V7e(3DVUzq+v+Cksw_?Mw*QD8B!0<73i~ObN3|*eDwal-vGSGQ&g;>zx^t3q6DQi!WKL0kpy{Y!{gPJN$A@d%;d^y?Wb6r3GU zk_I~gzM5TPanuqxXZM5|c9l1v&DdMNSPi2>ZAI=SwR^R_$kpVF@V;IrT`Bn0qx{t) z6=^0=&=zX}zTAcZ1-Wq)H2q z9llH`ReQP%zbb!UtLlLbPcBi2tFsDmHAEqEm0cTKG&3Px zDWX-<;;DK-vGSO7rB0u8dVb2Cq^D`Aeo0}=@}7H@WV}+{hPq~kq$}R;Srbd1#eo~jO{oN@{|cJX z{wtkKoE&LWsah^!tCJY>(sfrP(bnBhAk7b7^*? z>r1nHG>8T#1ko)AY)?wh&JIq*(FZ z&+D0Z?0RTzGAZo)>9yU<3gybHlOS&j3-ZPu$PQec<6w_g31p|1P;tJKFQxu7)_;8l z?46e9774D&`;Jp!fV;&$FZ&?x7wT|7hee%Hf8wy5I{cZ#kJRBWa`;4XreHcHf^zBu zSxOsel?nGsL%IqdDyW{LenH`tBb^sV7qvOMKph5ixJ?}{% z>c+x^|CNq=wfITGq6=PdsVt>}c0(%bAaz&?ew8=aqa$FCTu%!2XhVo#kIF25veBWV zYb@Va$#+*Lz*n;YUqQKgN_E3jswQV!Drc*%%5N6}QuIRkduwn=r{v2r`2x&I2kA;l zZ;5mTTk9>6uIzG?bfwO<_(>PDb+f3EHBuv=NR2qsMs-$p++_DkXNT=t3eTz_JgfGA zuUvTpHu46X=MC7jR%*O=8^Bjh>vq^wSXOTK ze-^2CRNTA0H;ryy+*Z84$BK6f8*qPg^TF}5mbnxc@N&QA=F9#dh@*jc2*qv=6`6SlL71EVCSgYdXfD}N2bmfg?hV(8Hq^q@Ht!jg!G7gsef^>BqsS(n9NRY0~ z0akTD`Tz;il{Zpvqz{oGU9CkLj8p*$($#gO2}qTZAYGZ0z&;DCRdo-!2}oDoL_aM< zs)0m6)Y_DQs46i@;z25sX;fC)oy{UVPHokh{drkV5wA#Au+7es>bofJ$x{4#06HvvkY@`BhV+CrDovFbC)dRBz#!a@MyFlDr*j|kBU^b!8YwMTpGDKZ=&XM zDu*u5cj!n*x>8rHDv7pke%GZX#eYOga-}70#GBh4Z|-Kixqa~F?sg!2tDwYY$cBWH zyk8Fg(W`i7>Bln&(~$soaW*Z~>1?`8+tNfU`4O#QutbixLAp{Y=AmV-o3eM_@>P1v~dI87i@NZ$nS0Z(5zMZ~8aL4B7qf;uvSj$s6iX9T^$2zrbWG)NKyV`u!m zn;~=zLuh>3AykvntqByV9@D391_AW1M`=k=)NX>Jjuaz4O7Fva>bGW)!@ZV_5gv$k zqWAZteWy=ckw@Q$#PaLr)PmlJIo;A-+PQW*xk}&2#*TY3`0J4`zAtmexn!OMa_?(=I^GhdFj+8mSik%Qo4=w2-3)ubfuC- zvXKJLK$KDHMk>Qf|59%$om?TZGTL5`yVo;OT;==?(R(}&?ttVT<2kBcl$pTpEXSH$PJk=D{M}> z%+HQ0uUjRn5P&zFaLb!5NmmRWC{5hH9^yd6GrSWuNspjr#lp~;cutQZMn@Lu>6%hv zD7+2Qm6#?G*devV4#}&;jLc4-sYziTGtsq{2gxcsNAmQGXKEHn@7jI)>UxAeixE6R zjNk~2;AP4P=8M({E~$o+J#H^U_ICyOV50mTBlvgq_{dAE#bDH3s9ws)78Mm^?x3f{l<^}tr6XsGG3JkwY9td3%AJ*HMY=Ov`oq<%VZvwiT;O~ zlCH?d&?}ppLXxU5qXJnAYIk$J41!5A7GZMNy8v@E3BJ1tdS+!~CTO{` zbgWiInHn#UN{*}?lT<$HJVOfMLB^L<)=)Y?qLDP zDGOM!zB{qJ6*iOxeuW0!IBf%0ATyYocX(IF^3$^kzbeO1FT_9Ux5IgEmSP<{=fEo7 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%0Abk+2&=ra zfUx3VW7#0;hNzc_D$I}Yu(n%e9`4}0&d$8N%g~S`y%4z}>W#=%MDq~&AnJ#xw}|2p z`5_vFsE>#$go!8+k^8z9PyM&MU3C%$(*2T`y#gOp6pq!5kp zbp*Q<33kar#FfD=DXN%Yho(VrswLOt1FxtG)RSU0+FHXqOBMA+6hJ{C-IUwFEu$44oReD$#I`xEKrBi>eI9Bcodu0vw>axOK zH7X7EYNx_p4O7^wy$XAE^^=Fg>a~!=j909yQ^LBkSp)0p1L^1qAyBR!)UjK=8D&{!jGP5SHl5>Cr)dvW#QTs;F#xVGqEjTl8T%q-VYl_3GzV4q4Ha4HAP zPtkXS`lgOCy3WBxyK>t3oR(q7t>8pIEG^Vjy*26_%{lEXP7Bp8o(GUFT6x8!=`7Ec zHHygRuv?S*T&<)%(n>GaCJQESU7Hi>?sTKLh=W^y?G_hgcK6BK+Xn}}pWG$d$MXH; zuIkf4eLAVn?tIc|oTRsH1z(p)Z_7_naSs219DdX|2GX~naGz$>A0;qJ@QDuYHl3MgPf6>C%NTFP7{5yX|F-=9lDr^SKaj3jUQ@Y|R2~cT z5W3+&=!Sbnad2+4KQ~>OHjwqo!BGV);tjgQ8C!5hp>ZA@Wh_xy&IoJsPu?k8E~21C zhXo;e-H#bH%yaawNBbYX^}P_TmX&PeyF9Aol^gArm27jPUB}9oZ?to){34=c=>bm` zmTVh$@j#g6458g@T`9DiR>HWddQ%uzAdoBo;sD#3DnOh~AdtTD4_N1T7t+o$sT?Tc zC45;SUpkxvOyzmoJ}lJDe7}c{(4xfhsPO;vIDbJ>*Ce zfo#=~BV`h0C0k{Kzw!)nbPaJckM}SO_l!`*3l!I@;zf$PRq+zVA64;ZDL(AYGk_(f zPQEf{{MEa6{%E9)9Xql}nxysU?>@5j;Nuz}75JFP$0WA^mqTw<6!cN4W_$oaD%Fq= zh)19D4y=)uG~pc(%vIfm4||V^d^h6@Fp78Nefd8Gqc=eQOa^l_M*u(?{FO5RqF(&3 zA~>Lqf&(&|s2OK;^+#{Ry4oRc!PZ%F zkaF^(%|7#pW7CoA$l)UC^$ybOL50c6WlUrk;4U-3UHU`?PPWPhq}7s3oXsWHkxRS< zZp>&R3(m+x@#i9za1n-yipNY$=~-(HsW`5S#mQ2*37-l#q1iDBPVy9slOq>HNshHt zM5hovL^MG}V-Wp{=r2SQMYJ8!eMHHK0z~u>QK2CsDpW;8lQ`Bg5xs?|D5A+63sEgZ zZ$!vNOfi>ZEtAOd#zdBvM)bLe9wPbx(OZbV5K*(`BI<#tBBH4x8iVNHh)fYp<5-AB zBC3XHI>$mZ8Br}nUvjJ!rt-Xoh!>QZgnrKt^payCT8^k5qSRpXaK*3!lb|QCyQH|- z^-tZm7Ne7&exuU@j80YfN4S1e`c`JNrI7{saSCuygChTOYiohcP9}u+0qCR9px|!%ZuN@ z$O$-FV$xOCaO2n`GA8+$(e#-_*U!f%V*_UU-k5baW7ge_S$802-94Cf{YW#K^mkf! z`N>(G!Jhqb4#=2hRIHD|Lp%1?8CvY8?XUy^r=T;PYtHy80?Ng7`MIQ;o99i)h94mt zh8MM+d<+ikPK{$2D9$^L#CgY$Hp8}i1KaK~_$c9(rCFOa!hxf@jHBKIanXsyRcl@X z&X>o?tP|cjqw}SvkC!LvG<7I{+EWecS)q2B>_h{gMtXxm;=FTYDRKKR@bbJ*3z18fHPuh$L@1! zu%6&Fx1xNwAY9LTa27|N_4u{BFp{VFkBIG9oV1$ZcAZ8#)A(U>PdUeg;6|N`Nbvmh zrK-Z?&$E}*%l$Byk>Gu~)J$$s%8lw%gYl7q7<`1!Rbzsa8skl{g|U4L&RLCV-9Gg4 zJ`DOl@wE#fixqTxk8m}_1XN&>GCWE>7f~Cy*NkDwk=t;OY<~EVW9236;^lvs>v#fE;i<~C@PW_5j;u;TVH*+(`&zObR&2AmO~-9;ZR(0}Bkm%qt+&vz zRZuyPDW80(9645=ot$3ohen7V2kcuhmV4Cp$7+a3N5r=hwNr@+m2z?#M_03)0#^2m zeq&(3$|i-!I!D0DCIVLa6R@(Y7$2&+8FKp4VGAa{BRz71(V>9D$h8k|)KHBJJVMPG zGdM0OBvlVuwGQLwN}TaJ!}9&ELC9_(Ud6?};3Ukh1E>E_^Q0{N8_*l#SE zTcpLK{m9x3EUmY3^^;Qy!-TJ$if>c#6vh%6KU`zLviS1?%Gtyc`7%r7JuH#^SRyA` zF@jcOY#qSl`3=~H&lDLeOu_<3>t7+K)6Gu3aW?3#&PAHi{a7OTqv{qEZ&%;pWm#Su z3~zmFR_F#7vy13{rXj!c{e9Hy_$WpT8ERZ~Ya;*zHmclvbfsK|CJX!?#c{S1g5m9istJhRu%E38qD zvIMSVNY`FpzBR4jX{_l1k)o287#m@}+EoCB?Z4JTg?AEz(Q&?kG3}?BS92vdM zsFe>~U0kqpd#o9$uD-V7)rKdD2c{UVq_|>Cd9iE7m;IbkNm9V${8~S zm7h)&YtMGp$-`JDpJ$!CiFI;+-P;bT{uqOIJmlaH+41N{!i=5hMI+FQF0sG0iz#C` zFQ0a>MZSwNnM^pNu|%U8{i|`t;`H)@OA4an@PUK{zN2WojHpfK^TD2Cczr(TW8qj3 z!inP#M=er-^{%bh@xWf7UoA?ltP|6bU@TQchw}3Zv=f?Fg|8dUQlfU8o@LZT6GE9K zE!b1+MugH*M%31fsI3`M$E(=DZY++MvN&$7b8)QM}kmgG#( zkEOui9_ub4&IT7_)V_UA$uYDS&{xn>vIcsK(Z-V~@?JL-a?8+Srr7RuJAxq!(IZWz zL8-{Ct=LWKD-(*r#TDc=RKp>-l6HT zkQ1^*ekR8Ih!c;T?75Et{@FP^bq7CDN;K$g)Zpv2kdk>(E4D-sri;Gvz;dz==2C-pJ*aFYl{F3@cTt2dv75b% z9f;p~3jaUoCgRH&ZN%tu>9ewXCajaaStp-hoxFr~@)Fj`wnXy#HJ5fy zN@ZASEt9f%*l6qrvP6?qD_VP8nt7YyORbuXnIGbh?z9}uC9P_v{DC>yh0@g^ zbtU9CNq2}_U2&?)U^ox8Y&n*b63W5r9WolW3lxp5f-h z6ph>-%WxY<&KgQCkCk_OiOL<=g#MSsi|tYt=(eitn-TaO6N~1vh~@AOT6j2<_(dl1 zi%jA>qTbL);43=RJ2Vty7^cvs57InF0=gJi+x^sQz;T&A<3|zUxoUI zkEN|J87Ce^7a!|I(&m(VAE*4b|HaOLXN^*xCbZc*G5P7k%_#|27A8Myla!M3IIvnm zK+3j-pWJ`kZN|eeDVpBB(xzeaeksXk25*X$V%UWjQjGdpijU$&dbLfY$;OT|hkp?~ zV|&pjUoY$@g}sjVMmGN1w6#^Go!=h%;hO7{uYbB!tVZRP7k?EfR`KV(J8iW3?$8gn zot}K%=jWm|DsT7(d0ByFS()^AxPD|(<oTxS?b%y)htX#IvhAMsjBlQ*6$v=wy4y}#=o1JjB)t-$fRn{ z!>vC#RCiISUmEWB5e-Mw2ayZMLevV8L%nZnIQJ|e$C_98dE?TnUJGz&i>RB3qC!RV zbCigh*1K8u;(-?;yA~p{Xk_nD%}zvh5lui;6;US+HdjQBh~7lhUPQLdog*IDkSV2(3Nocyn7~rnTLMez(>%`VK)It~ zLR|=}R_)zg(QtU?1vr@0Yy4WcSW z0nyipHc<=FQ$*h)`ifeXBC28^bL#wt*m9oUvE z^_!y>s>h_&gMWwp3rt4`!E|WRnm~eV15MG8YqA$w#c3sa@>+;nZH*{L4wPZEsNB|i zGFHe~!6yy{nLXkXTX8+zxI}4{Ef0(!N{2lC^3B@^$`yyuk~1wzyOz0s@R!<5vIDaO zp>h{8)-vgyf%0VuUslMM7JKI&w7d`A&Rsxw#Vwv8$EpHlskqqBW zYQ;pX9T$C$88t1XwI$SRgNaHOtL(B^ZNz6=A4--M63@g z54_RNuJXRvsX7Y!6 zvKG=L<8Mxh_n3dGXv~rNYf5^Bx_ls%qzxfLNpk)0oFJFhM^G#+z@&|R1(@VE24K={ znz5}kV`t%^nF=P!0|ZlQ{cw2|tauexiRf)P0WUyZecUUfgQ?O{Sor{^$}`a_MCe#D z=ih#>ArHqMI#!-VQ=nsAFp!S*zM^9-fR42ZI@SQ_Slj` z1$Snre$wK!knd>rI?}9KbgW!(rgFiCGK?T)cr8C-KfwGmIgs*&A*$FL$t4AqZdrIK~UkXpIQf!fyYQ{(D#ob3*Y{Nh?nvVw=x5UNV zbM*}|QrW`CvJjW@Ka0dUcrK9$j^pLKH>v0^AzWR%361AAm0E$vqS7O&be&3<%lBwf zalBX&g1X6({tT2#t;Ila%0lcdPdmtwmWp59T`EnKN?T0 zNu?6qrBY!m8*Qc1Tlm!#mdGK`Wm2h(APFi?kxE@pO4@)5O=U~EsN>r3pbsRTd?=!- zh>DA-L^}}$A*ze$4Qe4;kH`{HNouth(T|9lA}UQSM7I&yA}UL*4k9W+O7sqh-ino4 z9hwYXUH_CgO*s%LUS32cI*O<(qF$-N<5BT#B!pbc<(-KCnLK{{tD9uB`rE|>NVtf8 zOOvn4JRE`{a%$6OLVQ?-AFe&7rUkg*TH%7*AD8=G#0E5!N0@D>y2d*y7qwoI50%RO zAQjCt$uXD(% zm0CFfkD|GlH0t0{)EO^>U_6Sdb4@y8GV)vWDzI2xxi<@J!mlXIV=gY0yNMq2Bd{f@ zJ|W;Pw892lI(lQ}-;9-iU^VG$d;G;REdE)p(Ko9|+j?VX#QN_<7uOlclv=qfgEt0e zEzIG^uf~T;d2JCo_DX`#&jkHRh{ro82=Oqum>S}tBEJ=%$-wm99b#K!9K5q2)$9FZ zX}!O2wzb6*+7D-*Bs`&SFn=B+4mg}R;3gKa0|gu9M;}k3kKfSQ$2DVms!x~BK;+Cx z41t181`1YL@xcr&#w!mkjlb5*ICa70!hh;VdxhvSw3r(!I@agHQp}_+-qd z$LH1yiOIkv#~;pxj^*;c%(AvPcrfK=@#AvymIjVFPC&3@#Dop5z3_^T!6Djv0HgbE zM)xta{2f~UoL0-*#fZDdZJnWPSW(yJ2)}wc$P|5cC@%B=*Fr6F5$ynW<~H}3DNLeE zjQC{iHaNP4$`C#tu~1ILCpx||4Xq$}gBafTF}zP;cz?$5{zy4>O$e6By10xIHaL$F zZ9(L!EKeKU&O;=`5TKT?DD1(gF%H^M74NVXEy~p#S($q82iDse`&16iUse&8RA!t9rcKC_r|4Aa?lp}S%gaJ7+Hi^#A7oEWs zouQ)9LEf>;;S-(G_tOoqT;2`h6y2h%m@}!R2D+?9Yu)F zvU2LJ{J(}VfuCmr-$Y~gX9C}KPP)18KWr@Neboqh>MTRh1;(yV>5wla(#gisiN$Kk za$0NGp>AwziCx#fRMvQ0rh>ExQ`9Wj=J5v2V}hoG&0|b44$0Rz-ccE8y_z%b<}R&h zw)D`80v5H6**r*csI$ei2il-tg7l^&D>Tyq44vQL>;4&Du73b`xZIG6@3&mu_teiB zQNc~{oz=Na@?BY8@|WveqA4wqsP_lVAFUWsjScV>`V++7ULGvY4K8LI{0*Zj8DfP+zWC`IQow3wI&ov4ijY0KW@9ZhJFrmxjTIqJyRI)kyb5@V}n zmzV&#tRQxsDzWQi$*z+d+lw(;IlVQm)v_6uyFeEniv+s#AcCW!3hpqtm}7v8Mq%1V z18BlsWXaCjE)%>LSLd8Tw*^uwKXJH26~4+pV`|u}ap0Opmn7j5WPAj@$QccJH9L)t z>@+T-&70HaAJOLVs?Bf7?uR(iuIk%Eg;}Jnlp~3*00_^FlM5}SfJ43Y9bT8R!6=(a z|0obqo`b5F5I5X|1REO6h9ub7eq87BNwycIazMri7hm{y33HfFmlNTVn&>+{$G1wv zP@2)bDs#Dw)?7}Pc{#1-|BiBEkOpH=C4=;gE)jc$Frc;PpwEIJ85KtAUnsAE?%;${ z6xk(4syh>_vWA9s!cr7jh1OM}$ORJMp(}KQ1&uLyS^t%AEH)j6vFUK0O@~eFDfb`8 zegnOi<#93jVwyU*3K^g!tE!?R-h@u{AJK_)FP*@)pL)u;-H^$ zn)BSXIlK8TdMWkd)k@&%=fg4nifoD#9B=3z&h+jAzoruT%|Jg>jdx|9*MH6!ZZa4a^Em$HG}TK`~PH}G zWIO5e4Em6usg!o&rO;G{7W3D1V69XVU$hg0i+MF2#1jXeZeRF25Z-N>=m+yvG`hjX zM+TaU1k>=mr#4+Qt9oS32*cD7 znH0uu^2VEA4DIMnYagPuXDhu(1sl`1nRN4uEoG1?1!K!Z$))GdJFOT3oHs?hn zCY6MQ834Tk+7XwhR4&$ZdH8Fp%R*R#&B+qz8{(C+*0pK0-i5LT=V247YO}rRtF|}$ z)2(;WtyNUHH`i2fT1q7jZ&Y4y`WXw@HlpwF=?X_3#kyjlyvv0)*npYn912V{{FHvQ z_fD<$PQ__q2`azjiM56PaXi(d>Kk^WX31_;4bFq%-}eOPnJx3!Hs+q+nN@Uodtu4T z&ss)h^=kWtnenO_(P$z`6oz)Zg%^c46wwn!?I6;Qes{*B0 zHIk*&-|)FF$GEypvzT}+uxhtGv4MrVJ#TE$)%Jd43)yq>>FDD6TVTMkz+&CThnH^% zC~NfCtDa6;TZ(Cxf8lgIT$N4goDQ++P%I56YvKkmudJ@$6gJVM<-klwDu)~!(@=}1F_jl%N36#?*a^wS?!A`M5K2QR;qg|2cZ{pe zr6X82dJXugyt0;GMz1lN1D6h$F&$1<4$7Ts6YJMYtekeSa`I)JoS?N%PScCT@m$=m zmgwA3mdK)L6H%F=-3 z=>gAbq&(c8d@VG_IFEsFXh>qAHJBeKcMf%ozI`G ziTxzyh0m7wr++N1~y|CjyNgU7tl+RF7ak>9ogdsSNG<9-qB zmFX{o>vt=*XW@a+x85B**7QyHt4_rZFWeehsEPR0aBZ*tLaILMPjpU-6hU+oy%;TKDfAizO}`8anxX^LUTff^Ri5J?uW% zvDgD45KV4ne#T=`uuoIdo9=}ji#=c1GIVkq^Vn;@1mCi@dE&mpq0EbgwL?E|V}3|P zK8o-T|l&*T9zWJjp%zso2k`6MBjH6 z(RxJds8vrygS!@bu`s0Pq&DU&D@d((iav2KjL09+ViDak7tsp44+4HNf7DxK3#eu$ zvUYY-tt-{$Qmu}Nu67ZTHKG~Rsx6`^h^mO_#+LA_QEfhHZn8%R3colOKUSnh%bLym zc#Up5^Q)+X?$zhlE7`K9SD&!aZ4&U#(vK|-|p1)|kBAzHNudv#5)S7pIojRbp@DA=pc zV6T=@$(Krky?S=5YRhF4pHD8cwsHsITLn1__UiLa#p7m-7wpwfOUtZ1Wj!#LWua7U0@COPNFz%?D_uU`)IZ z@1c`rW1dA3&XX<|c93DrtgL6~z>#u^z1kOYR=v_MgS|T10aO&MBL|wgJoqEMB9pxh zE?SPH2?61Bf?@YZ$rkoem8UH_XnpGK|2Vpb-<s4Do@`q$bJ|7R@jE+5`=ANcH9QIl??P@?=9d>SY5+T8gP>!?yg>f z-LebBov$G78a;mScW3qlS`$w5dhz_iY4LQ?^Ts9N7-o@Y6;(nctif5HGGe*A(Gl`h z^n8_B>Xqm?$9zu9pybAVxN;>0D0*(%HuXx>IT+>Qx!dNPb{1EXE_&Lkt^DKZ2lBaN zwzSU(ZLpwp;7stN1s!9{^@e;T{Kx}~8Gxa&0PoBu9T-stTjWIAkMK;`d84hm}&}M+;eR^fO>~lHg z^@0=8$zBEa%8C08<=%>fPn7$$he8ER^8QA8T0A{1hMwl#Svuwk*m7kU!Rhfe&jkBe zdQ&PdtshD6Z6~v?&NlBb=hmU7VM&T?D3xXH)931Zz-bNE$iXW!&UBPVFp8n4KSNIe zi&}6-Ss5K11^@06XEc`RPo@f6&RCX<5FqHmf)-73kj2xI>C$Vx+&Wd>cWi2;)$`_+ zOYFX9UAgP-d&8}IjsEpe|FyTizu14s&F^dYE?-r$hHs%S{TKZd;@L`wH&q36bghfv zZ%pLNOb|ya1aZ_vzVzomUFAQ8HauQ%;hK|_$_g1N9I>5zX(V6lJSG67TD{N1CfxH+ z`>;^A)%z(HcA)qz#d50n9mU$J_&r5yiu<8R0jxTwz*5>otDZuE8p!|b1&O5td!>G& za9OTW(_z7p64pn*2;W#U#vz8RFnm=|kjJD;UE6!g*A)51tvzY;7~H)+P= z(u_748Ax&hsUOR$uv|{iKu&OpHs=KZ^HU$pPmqv**3=gA&pPl!N)&;}91*pKQp;E( zA1qvx!H)QXc*L^5|{l(RLo30G2Yp&qCMuYFF2EMDa9?=78wW3xxYJod5mgsm}Ib#zLWu>?X6S)YZiDq)f zI-Ic!7XjPMK+%Wi+U)Oj*i^#2H%O3B#B~W0vZ`#md>Y2ZV`5zN5#!?UBrz^Vs%^^A z?aUV62jI{`%>LssFC11M*cjfSl-UAt^NXPORqCDP>|Za>=u04hh2{UfEanv^v z?9~{sS8q~jia18CS|*NB4RMSrCB9NFpNr@^qE?9BMD&G-%$AGD5m5z1Q$^&7XaJ&r zA)3aq5DiCE714B#g=hkznuxySSh!-%BAI#J2)T$rFF6*TP>T`0gD6Nut5Th#%wu1O zk>M^zhP2d_**mn0MM8`Wd-SKCwZ~~>0hT5!h0|)N><>88?~22L$A|s#)9jBIjQbR} zHCJQW9r|j{Sir#HaM!ydv_{0Iq4x=mj@3n)W5b)6@oJNt077PPvia&MjV z9Y4J8e#SoB0v9`@vz9 z!&KV#7$BT*KsZel2xlNvg*~`y*r+^)C+Oqh^zkOT`*>QAl6dSr?Wx@H5~j&Zp+zz5 z5u+TdG%i|#no_CE_mCUV@S^hUGTcQAHr523!E_{c7nYZDh#H7*l;OqnEbf{>ekIZl zONo{fYlrn`2`I;DqhJEcgOvZ&1;*pa(hf9F)_|3ktcb>7(I0j?QG6$N6WTq7(C#~o z?&lcYH`4NMw0w-#Y;LD~y0S^;E}bgJ@Q&R2Gv(P4O2-fL>>Ks+KODn|liP%P#N?#^ zu(NW|iWLjL?{~5g))^zF@xzq0m3VWtqWw;=JYLH1zK`L30>k?=hWAGd?}=|qL&xu= zqD8DYb=}q-eM&q)Fg|Gv*bljxRtAYkd3Op&o~AgnmF9;=6Jgb##TgCE3&^F)THCeh z%l|N!-cHJg>R-}pvtp3a+?+Mzs-41P>Ga+3K1Nd?LnpGNWJyW+e*HklK8V}MLE?-L z5{Y;aHz96Sl#J~wxN%W3&IXAll9$jAbcPJE8lp2~4&Nv^k?0=<8JwZ_@Opip6qU-J z*v|z#aVz~Ecq%FMwvBY~G)EoVY`KNILcD|*+?NS_S0(Aaz76pN>&pbboe8{vQN21S zxkeKiHBv)6>LWdrVvd*K$!04YZ$%kKZHesmYbp(qgx_PrDH>v>)~laIC;ihT(mu z%BVD&X>b7Jcx6WD0u~jGn2_8v`ld?fzL-XQANcZTz?c7^wJ+1!dxp{4Eoki#wD!-Z z-Z&d{SEt*h4rgkKHoSRR=Ms(acLc3lT$=GFLyJF3Z$XD~WH_TRovamVsy);xgNqZ< zNL1`VXNiA&hNhw|N)Ox4x<1xU1TL^A6}&N*;0?ozdC-Yo{I%*_xQ^fzAzGmvSpsly ztH8=gZ7zNgk?bxwDt4V>hA_RJV%KQ}i|LLTo!K>*P#Mqv>X{A0VTG5#urddD?-v-A z#ES%x*?g_aWNvUVMqjv!HYb<{&}c@|tBi)@H7vxO(fusFJx5g{=USm&La#fkf2I6) z#F8Mb)E<;0deI_0otv}M_z^pe@v6<)Y4koro3EzL9cgp5Cl;YI%$NZ#7ZDuWx#gG3 z6P{-+WjdFtt!x-elnYfNlfn@dFYM)~x}kzumQSgbOUmqeStj5lq7mD(u{@pmv`kTH z=&D_%p>29e=k{I8klq%k`w%skpJW=yY(aQgt>)!*j67>Kxl~S=9kL0<$lZ|)(=&)E z?2)K*M>%b`Ns~fBbRh{**NH&V#QEBI(xyMsrX8prp&D8R8LvkeN05UGDlZsbFXLG( zom-NF^d&inYie>3BZx|J#=PYD$cG>Den)eU>551QIQD2Z9s0BBuxkem^Sg|y2^X*d z5vVd-dZ#9SLDALE8I1Ur;ouyI?-5MimzcbFRpbl}Xys}0+_y2r4dbTm&7gR^z35MpQb;}+H^s^tb6oYYIAn3i;!>>w@{6V!vFc(6PK8Bg zu@^~jOONPx%tSHr;|E&fcrLUF!*q^Z)H14OqOJHC&0Z4fB^~Ro)+6u6)VY+Yvo%xa zct+H}m^zcz(bw9uL*?HW;b?@gL9;gpi|N2M`lcIovYHMuDL>JeK{ zZn6s{jdB#tI1J6$63y7HxiovsNAfOs$J5`pX4(fyu#Z-hST-?_vmuhUpPf0R|9_ju z%fhOPDEc|42~oA!4j9UIKox$Nr_3Rz6IY6R0h6sk49OnRYyD7q7SV{!*#{ZUKFCE{ zdk3xk5v?7sT6;LHZLg48*;^3uqM^K;(d6aym|Pk=GHEC*1@bJ)t(9bw*Zu%mTF%V4 zfU=MtY@@riAy~E7X_B|`V$p;VA)yab`4+5$?j0?J@k?vl(AvKA?F5xKV+(zoJI%8? zqW#07`KE5<@<=aX`*@jXbo~iJl*^MNk-m{IGHhUE_@=P~(;z9D^eD1Sk~Ni&frRgH zRojMc?Mt^#pj#iOTSuyfE?C878}`74yg2!wY~=D-=_-j1Ev0}(={ktYAn3}XIGV`r zenfWf#6&lO_P#`W@6u}Tx{8ri8!l|ND`h+;6^E#|{LAYzf!Fky;xpx(; z$QaIB+4+VU&s1W@;3f25*XVaJy(eLhO$bK=iox{mjp_XaruQXi!M13@emkgGH+JF% z*U?&J&@8=Mvr0;>tQ)>Vhf*4mwzgml%ZcWUugITEX+#c z*>b%8(R&AiZRY+KxYMS`FM(}tbO^L)eWM6|RBL}6YI{G}=F~5NjeJ-9P=0@GV3}@v zjs@zp7s-~EV6D7m=FUnb&1^4FCIpgK2z|FcAl~&VO^Ct8L~X-BPqEtQfL-bHq`HC; zPA9tJaFieW3cdxW**t}m#@|nS# zVx<^%;e`~VewN~+c#&Rh6KS%sETm&SX|P5c}-9+_0#d8qYQhdd%m-D^C{ z++>2ovLlmfID1>)I}{aO^?Bm~=EVaX<{kO2hO@`0dxx$q6j4L-H7T)gJv%D0e~YXx zvSc%7m;mq=g0@ek9$q3T;Y~PJ;{`+I4(#ftz^;OUT}=jdbyr|l(}7*BrP63B3GB-M@KldcZ5FpL9v9r^ zWTA&sh6wCxWY^+x!%hn9YHrzT-OD}`2G-a0t91|FcJi@p+=8vQCOz$2ONbD4!{b&8 z?8<+RFj0Pv5^BqP0-|zu5)f5XsDP+`M`Vkrn~1Ij4ZJw)Vz zs2ZX!>+Y8v?G;!z)UKZJulj<-62h9p>eX>|LysWxN3;yl+NM&ge(56~5nYAMu=cdT z8rF;G2%_DHzCyH-S`9>W0nyipHc<=FQ$*h)`ifeXBC28^bL#wt*m9r2#~F05xdI=} z{fBpz0jKp3@9H1km5@*rcda%(Mg}2w>9IbUm{w2rn|`yvBR=}m=k8*^=Ad%|AraMtjbZRkJpKK z&H1>9gImvxQ;4jN+gEQ%5Ae!pPXoHJ9~ z+-Ubf<$*Wa*;U>bJ2lAa`NERT28>-)vh;u_%_{fZeXnulNo#ioHgu~5eMgIu1S-n{ zWYU?U+mB2YkPft-a$oretaH2zlWCctdICkfgfDP=I-FZ@p>DY6ZQxku3Xb(u6%`z- z1Q;xH1;?tQiVBWZUlso&oUDfmOSMwqJjt-B^zpDb%R?<_)>FV(`(SJVusS+gv9A`w zzM7|s5frznVkE^lRa`>xfhsPOVs>Dxry5q)PEO3JE<@{r$dwH=%QFbzmB5gNeHEdK z3XZj26%`z7w<;<)){mz=Qayi5I<#4g=VQI~Vr8QZa@)0~H+O>`#m_VeJJNDG2+L{RHN$uoy=q<0qu2b?l zESAa;fqDT6st6mYqdL9;uQ~V z0}!;{H1;MMdjO674UPRNjh#x!qBL7t+8Qt#-TAnD34!!gM@V0{z>T$p^fgduDhA!to$etWVx zXtqQURI|JVRB_Ez2v2^U1p0(%F`}D@{6(}1Q8c1NMB_ws9noF@S5E|RRT03|HKAag z1(me|3f4oRVEx!yD*a5Q=Td1tl^#$DRMu50B~uAhRx*`d6Wd2cC|E@ZPzRM&8&pSZ5L0AS#OpI95d%S9XZXBLa@)g2)X~WkkTS z<|Fb!^fn^kSZ5LWA*z80I95gASb>P@MD%D<5jd6$B&=}YSQdydV$4Uh4pD;$yO{kh z4I(f~C1$h-lHxmShDtF?Y;bM*hd6yDrTO(N;fq#FhtSeyv~)?IN0MvJ9xsyxc$rvX zE9qZ_t@LedrR$AV$G(&ogw`v9W2rPCMor40&CAl|J#{+Ke*22OMBk5tWc3)-!d+6j zU((s$Vt17EX{~iTXo|(kJEMPQYULN$LF!<4?u^|z7`t_b`R} zF@+{&oI;Odmek6n7UH$J(e~pNMLYr@Uc9D@%S+)PUnF22*DFmnLvdfqB^yg|v=S8& zOpg=SUc8*NKo zE20v)bbrE(TR+Dirn+e5;KxOZZ#U8}#hAzLb7`<1YqT5I=$K9TasA9FyqlIEL(AXE z*z$tL6Qov4!qjwxw}>wn_ovrOD<9%KcnW!O$;y)(6*rU*Kg@^B<|+tr#6js=S*S^V zB*pqdM&fQVIQxkofV7i%1l%POycY9mEjs#gymXfn@UWcGeK}M4a;hkj>|_;%SVRsG zujOwdZLQwnJOoMS1*w(ikP_`5mS$qfZInqqLA>x|$_-^pd2@|Si+do(C3}XBG;DO= zQww!YrU&tWKZuvfK~_!&8PYo`_|``H^+yCd5!&LNNC^*Yd?a$|HO0;8AZZm$bU7}B zj zu@hbX;bY}*+HxI1=h~v&@v-VKD5rVBOY6!ayMv6bI*>`SQquCzR0#~LX+^g<6O`F~4dQp;xJyaF@GT_*ijCC1tR>S-_&gvHM=+k&l&enUr;bY{jUq zLf8J`W9eHk=LU+Ep{~-66r2m_V;22q=p&e2tx=%WJ4m4T&|N$&whJZ_yl2pvFSEpV8I#%;(ojWDs z(1#L>r5rasWH)P`&P|Uc+$Ur5sa%k)crg{$E}A#SWz$_b7(k%eWcl)Yn>cx8xf zXdA6BDJI9{pcgr)+L7qHyD$v;vSv%bvFf-ALg&uKyQ_dwkM!kjsl?&);+6GsKUB_D zFfxP|Xyo*V7r5=_-1e-d&qNtj^j=q1Nzp8w`k{>Oq`gNd$11J%Ry6h<1_M1rjlQS_ z^k{{uHI6mO-D_E{CsttW}0%6W_ ztdo*RSd`#~!W)C>-5agw1ddfpFb~=)_QPVvZ!JicZmlS_vQ8{`x;n!qgz>c!b;eiZ z&P8^`2WY;n7|IJK{ox!hnP-<|bhP-}BHM0b%#YT#_uZYYjlDYDslwQ+=Of>_f8bDL z&DeoLjdGi1@uIm!72ErsPTR&_6;#%*feUQjk{Q@rE3*b&+b-t30BUun70v8Om8fzK zqT7fnaviP2MQJ4l7j<|{Wup=)6@)~9&s=fkl0+Uc+9Cl{l~7s4YA@vu4*WNta?~W>aAdZwVI8u5mN6Pi|cNhBm z2Ku`z{e2_u0B)&{l(Hw*t29gUEW4b%#ueFYW}BfG9oj{oi1)u2+fQeyl@IAf3_n&g z&RCjD)sdF4fJJ$M?y5v2_9};JaDMiF36{>l@nPj#{=SzVJi3T z%~ZaLsl1xcBe5ZzXUN~g#5*A49w+0pUc*R^I!gr>5`{U;%W50BJko!^PnX(Is+Doi zA#2}C^Po$GWBsHbj@6jDN_RN#(oRl8whzfh#NK ztl1<0#CVww)6b}aNwhT(b3C3RRCrGdluwnK>=OOWMrT`x;C*E{AB)N?+WK2dkKT2S zGt^_z)|19InvP<0g(O`C(hdMoI*QRmb}?cMP^!seJQwd0^Kq#G4RM}^_?U*cOhfEd zI!vnlKuiM4Fl&(gU}fJ^OLT5|RA=rgE(7T)qbC?Kq8FF8o|3L6t8!+v^|FIS7MJ>} zaWe~(5e`2dd9CW1k=Ab>>JVA#aO0vDCcX~)j=Waw%n0l5hrU=;>ZitM%}qXY*m~r( z>Su;o&pC7;qSVdCtISQtIjlbNT8%S9tWO>)5>e_&<1ywY0S*zutvcf=+^P^@Cpij@ojvmdn-)5Cby{eZu#*yC;jwc_^CpTzYnPr z{MR}Mx08h$|7UBI$>8ap9g81$^JoNEtkT;{ZaJ`ZmC4{h&(6giMwA4m@@KG5O|xP( zV>)zgyZZBa6(&2pQLmm!c%_~_U$<@+6;;8*zl&Yt!xiR+jGE(9+pK6U=Z-(75gNK! zhd1phw2@i!>V^i^F*_19@u^U-YU~pxmbVbHo}LmE*2F&%fyqh`9@f(>h;Ad=O)W%o zOCGs45Jc9|8Un>?+f-Os@2xVq-FV38wyh3NFSE7=h%8^1mdhrdZg(ZA`=B3Jo7^5Y zl`Hq?*~U{qTV>q@h~OxIt1rM{T?d2JQkYj~fMp#(^bk>NM8L9&fWayX2CE$+U|Agy zRYcSY5wNT;=2h9>);mmYaUK|~RdI5QkgzYa}$XM$U zZA7#|L~nq>`VrAKMA6hjbQ{qgM4PDv8LNc7hz=my()8^KdoNgy1Y-82=*KY~o(Apo zu`E5|$i=2%)ArpMUd6uspa;!oty;d>f6>9yr$5{4=rVU8L!Eloo!*NBxAK@zbZHzkR-^UPdm*$fz0<7MgVu=*D}eguoFl1P&`GEvw|* zAWj+z;>6xw2r8#x%WPAk7q1;rD56znf~2?wlAulM6i4-Ra_NxSis*rvELWp>z@&3S_jgG*Jin(v2@P%%UY-+{2y#<*2n%`fz(EY2E2l zq;<YI06P{Xg=TbeC=g4JC`5o5FJ=^InZo2PoxgC9O+dD zt$CGZzLbcw<&s_XWw1xH>`+=C_e{Uz~tGhQR`T2GOxx_VR$GTGZtKW`V z9#hZ2i{?~dD;X8t!)ak{5rb}@O4L$(s(i;^-E*{0yjZK9Ki))GyD@{7|kekH845tLqF;c3c2_IU|#=t}E6R9l&YMtwT-2Vq{Gf=*`4> zf{Aqr6RRx~>)1~LQ;;GwJA)c1oEW}f@fi`l6J-lB=V_hkf7PoAC)|EP=aamWq#l<~j8TF^F zv|!_-*1PX{T3s9cYw)h_C#Nph)&2C;kA0V~C@K6a$I6#)v}<2^V(io~tMSK**1SD@ zuzgrjVd%tzw$e$!8MRy}NDYL7RAl4jK|@2|my#`nEI3yd@@0>FsXO=KDgicyKMlF= z5q6}Jo0C`g3yN>NOR;dM6zx>87{x$UEJ5)IMTNO~0Y)hR;!{?rmH#^VUnAjJ-Qg^I zwJK>?S9hRLSr0I8aM-fE*VZY=tUW1)s^V}Z^+q~INmX%zk`57RI@qcPXHfty4eLsY zqB${Gt(?eL;e$ix%iT72lgHsjF;EqUQaqxHBPhPnf(oNlU5d%;zrJq$#U%G+<{yuZqM>bUC!nOOCq>*wTCfB8>owwMHsKInu$pQleMGx>9tlSH!wf zbgleiT>*(I={2F(As;QoSarZuaIQk79R|vmKUYgTl!bEj?Z)8S?+tK*Xf*|*l^MeN zps!S852LZq)7YD6>;W|Phvzzvi5!s;Z#IhV+(eqauEDG;MZ_vdsFgm3)+=INDY{mk zSXV%@3LSg;tWm{L)5OACU(yzOk+$%tB&q!Orm^iB`bs|c2r=hhw7vI5l~gLu;_i0d zU$b2~OH9Hzwd+n>h!5T&9J6MZUfg}8itSEKTc{O3Awk}OP^^9vid98eS1wSj!Vx7P zf^{_?(KXEN-0zVYE=}dRiTb@B*<5WIh%Q6)s+ucjjML{tS4_^TffjX_i$5%{a3 zm^!8+s*UJNFF6)qtNDPf%!PGz7W~yzM5_?hM-=3xJhX1;ba~7g=o=M(MXU@uJvTHh zy(>LGM?2-Ar3?_Our}FaZCZe}$qH*zf4R*3ccJ>PaE>yX;ekh}OdUGBp%yC-Eu9HE zbhfuR3rNh%34`5hrE(jwZX_MXx-l0&yp{Ojb;b{`tdabsjO`qS7lZPkD)8(ax>;8; zyfoO|g-kmGi2mDCLdI6V`Lx1%TET@@*Z>lxH_Cd;rlp)=y$@C z$X|)|*PYM(f7m%Hd*3Ucj(*d`Nok%pPD%zB(^*$4@WIdshB(Q2Cus&H_Igjo88qBm zTDi#yoHPdF#l8nGc0Xp&BxcYXQSnE&t+4%=|6j(aY^&3#>_qP-1TiZ9j{V;O{h575 zGO(_ci&m59cN!73@+XPS4KLe1sWW_U5LQ7c(kS1NWxW>!N}{V^)%%(_yw z6pw0XM&6hvBybO29XQn9A=>vG{e7byDGYA|#yJP;Y$NUjZnzV~;7;KEGcDgTW6Mjp zifi=R*)%)6LalULECBSfuJB^Whq#Tru&z`V^-AKru~sDm2#~ONQ`GixdVd()N>uUf&W%MIaIwO))mhtH>@kXE$R>;IHW40GZQKP8Gc}g zbeuq9&1L4*B(u9Ly)lVNS~+GZ3h)+IPAZrCTI<)A#u>k@GPB=S!%E z{>0|orCwx}c8oZ%ou-D1VmZ8asJGEXQ{+;!O>Q0)zgYmiteh6Ga0CZ#12Y) zx2v?Q0m*0k+rKlak3yIf`D_KlX#oS-A#JU>O#xNTZ!IM3c_(d3-* z6-AS)`1N#`D3xJwC2OY6teJvYGgU7w4Pi?-m>=O_NrZ#NFcs6&QW;h{u?-2+q}P8& zk7lODn_l^U9ny+cQP_rgtj9GdDs3kwQP-mjLVbCanhBGp(O6e3$ac4l*}Px=5a;Q~ z3OVUGy=ed|PN*(82@C*m*M>tp~;$R*B|JXb8xGJmdac4MOhx8^6VGgANiKvOFp@^C|AgDQ^ z5NcNu6sMbL<`mkXp*evf;H-#>qA3nx4h^K?jG%>@buDKyOTZEMt!EPl4jkYdgv0&b zpZ}cCe%IOOec$u0cMof?wVq9Yb(AG5Rtftk{(-U^aH_1_G?ltfGEfQ)MnkbOz}R_# zAC{7VLiU8g1`6TePya)4Z|Je9`Pn3ChQN3=Q>VIO@_LgFW{PE$)BcrpEwNt;b|Ba( z{?RdpaYw3$(wo~26y5qpAWUFv-vZvdWGock6r-6V+H@@g_*4bjF}$vZo{Ro3k{>qZ z78#unE}I&wo86aUw<$^*S*iTF-sX@#1pQXl5WYnUH9Fh8C_ zkNR+cw6%L%=ux|X$eM;7{7~7!6$|XlRm$NF-JEZhX>*!DGB0k$6xpT=Q)Io1>ENbX zz?RwwTS_1D)y%E(lb<0}X>Xb#j434%U?tkwZS6OQ{U*!pK*L<$lB} z8abN`_gV%OvpBy6nMA;V!BL4Lr(g%daU2LiI1sF587h9>v0a$PBQcGSV;Tox8e3x; zyS*oGMU>WPF3VhE7U^8%6a}dq{;d5`MEgCNGiX>>YP%3UJt6$C*f$lygHfCmD+A7@ zJQziGeW)M4deT9R5-p!iTb3Ky-@-&1xRy1n;8mdvsCyYu$NGvo6KkQ)X41&L-=-tq zOJ?^td`cIAwCq)@Vr_ITgwT8LVO%oQ(kT(ULqAAXQLPhJZk{F=-B81#T4>rs*^BH0 z{pgXWKI$#Tjf7pD&+9?xLeD;zp1mqPdtEhG9>DUJ+8w0}s-BCgtHR@{3y%jELLL5b zd0JeNSy$?Z>RfdC-8h$oJQ)vvCDB&yeT&T-pc&i-vD}UR^vb~Tp zP82D0lg>aJO<+~#27-|?+!8~#st~&<(96#+Wb!Gx@s*XOaoa6tw!EGBxCfIqiR_BZ z+{F-$NU&G&qOXjWL(T)P#ocFLkw4^$$oSD+*`ZuLq6D6^7vKAMeD9ZhLG6AJ2@w8X}eN5uZUS|0VcK(QI_(+g)C>3p|DQcnUg# zy^33O11v{7R8bI{s$^;z$4`>&mKmKYsrbp5L9JM3@@ARoG|Nn@S!S|lnQ7{I(ZW4; zAiAE2StP2JjC?blW-vW90kWqgKz6bO$TCNh%DP8wjgewh`fe^8h$WAo80(E6-BmK2 ztL#uNkm)y^XjNIH?Z3lnV%lxB{?@ePHOGaPm#;a_w*26vfAu~yPEQf^I6qY<~f(7aq33HPNi`&QFaYWlpT2o(%!ey-d$<$+pMI$yPcEv9_7PY z@;Taj1RcY`Om2t#Xf}{v++WL`;@q3DDBtBGFtfmocKl zJ}EhoE_35-(x5%-qgitB#SXoW9ePS}fC;e4!vU6s#jWmf_Bm%x`I|+Vm7g$aGpBEM zrW0RIC*B-omrQO+wn3t?QH*bpXs&pHn^4Ig**1!?M3P&w*>$%vOxyn-E?APvi{nB@v z-4V*w*uCjOxr%NBWg#g?}aTTjPn~bk)^Au1h;gvG#TX*A3Lj#=_H%4jwGzC@5SW)Ft%UBDO_g!|xcB*eW#%Ar& zrJ+@lT83Dd%y8Kd+o^%+D4So7CWKUZ(sDF7tL1{AGKG3o1L~C>qWQ5m{d{B6MK&N< zWEGM5Q4Q+VQV>^(z^i-_LA^=R|BA4IU(wUsJ~FDmV&r4 zgL>6PKvkwtuMz@9bQ5+}TSUDoJ^HrI&ch;$M%EM=)T;qdulx};Km_$_DTpgKM5c(K zUL`CRQO6ZcdOtGpZuONwG0I(@^p(rqbtc0<8riKv%s-rc?5}OI8QHl)OqJsSRX?p4 zRI}bcyI7AAB*Wk~3C&}w9}g0WLQuVWuSYi%q>kgUj^VSHzBKDZ^(JLPs`l$w*2X+6 ztcs_552shZPgoq#Z}H7n&A)r4zhlp1ox}Z?*7(?^W|L~dYzP);N5fdpvpt+_LfQ!R z%3|SCfmhvxXZ1jMR%;Fl&#F7rt5`&L5q&A5qad!fAi9Alnpz^7E=!?rweVYOa;r?7 zaIUT_t-AT>+PE?)uQU+ORZ^b{38x3%ob|}5^32m+W;R(-b@Pszf{btsa7tVHiBPXR zg|^aGNL8jFu9kwhx(VW{Jt7cS35Xsd>WB!$RSghV6+v8eK?LGz03tI)-4XTkdGh=! z{$f86S3!cfvItLT9JmGQ)kH+A5p5Px6A)Jcz^lTARAmuiE42{qLbM&xHW4)eadj5a zUPRleh3GFthY)>EEvQ%3pMmU>VZk)ObkqrFi4DtxB^a*4b{4P zedlohGJXx32E7Cj#5kNQ4OVL!H>0RmN4?vAYM$Cyh%AL8uC#0QNv`{1F2vZ&f;_o| zE;@@YOy$6ygRXKgVOqllnIx3CkWi{ZLaAFxwEM=Hz}t|mq9I#7c<0rfF|$`&L$g{` zOBg+Cy%qfGTLr(mso+=dEBMtR1;2U+_!TUlqEN5$LtJT7uU=d;%`)hXr$=0AWqS4`6&2R8wJ05dAxwNs#P5{!8w|j0T|A8UV&4*0xK)?3M_|h6~4T& z(6@e|IR3`0!B;Mw6*^k<29s+iJIwyOF`wWC%#V8YS&OLG6%b4Z;wqP@*b!H>;B11{ z*KM1HC?zSxl{WQi8-KxQ)T=9Fo;#^t9#`6XF2t3#=*G-h;XB7Bzu75%@ZN=@p7A{N zRM>$zmH)0lD*ao@o8WQdoe&d_v(Tn3h5yDmH+C#6s=~VmB z$xr4re-d1|^^o^hRDNN|gVwd(_up+|KK!LRBgoTCatH?lh`R2`s4mK=ak z`a}>r+Xb;x{qt#lTYB9AwgW21U&O090F~o-9!%B9Th2j&ZWf0xaqP7NLu112jItJ!y;2E%1 zVM02p8Jx1UUGIVM9Ipd&rFYY7Jezf zE#lV!`B1M~gKR1t>Q($=xvx^9UNz%y7Z>#^IHhmBO+$F}-Q>|v0cHkt%ux>dZ~*yg zg(%GdJ)1;1MEp9*4$M_0FjvbEZUu8S2xV_a*+WqFmni!^l>MPwgLCih*U7gFIMJ`( zrbc>GuPX8uK!7TUPE`VxHd%6uvDW9_RSc@t+_kYp<$+ffiF)<=?LQ6=_};AH>bJH^ zZg=Qa$?a}l+kV}gXu+qPklpD<-+BMdareX_xKb@rPI}XP)qk{BDT8q~sod@nIGc{* zY+8u3sqPs35N#&C`Q56WWHF3jOW~tA1BE27&>VQx0^n7@3D0UE)T@z*Rw2592p@th2*T=^gH-y7N>8NHGAbog=>w^B zg-U5u0)~}FrRO9Oq$ZrJvTT7qODZ*lb5%|p566IE)q5>{!jU^82Tj~IWb56?wHf8V z_b?mNwfu*3PG28A{laR84-92%EQ~-Huy*ul}R`Tdit-_`FYe z&ohz+QNvcE5Xwp7#k|gv8t#LrE}{w|s`RFa<{@f~s3NrxMIf?9RGC^`M05<1Eut5w zh3FO{dqmZ!fXr<1utae?1=W`Y z>8iN;vz(Ab%4%)tuJT?oD;Mme@=(D&%132>@&nmeJP6NJB#Y_pM04!{5HN;Z^g$&N z_@vk7jwMma_`ZtlE9wZKQkxQ{5(IsRAm~d3K}SzP6@QSalI7=DA$uHT*3XLUX;tvf zS}LFMF}|-wL}1q^bkDw$Tw&@`xxzhTg;*Ioo+`^N(vIh?lBA8FlRjU?TrHy|Z6!N& z5ZR$S$POJ!Lel}VL#OUR3%6);=fn#oAp;U$@IzLTBEenSNDscrirdSqJcuseQkgYC+`tP)6bdxS{Pvr`klmcA7RGLK|H_`oY-xgIm1@!mCy1^d5(UtXD1gaC0gO>ht^K69OeV$UHog0KdiQNA#Rbhr-O1Uz zi)&hTF;uSUoZe`9ch!9rx@~$fx>8(-&>}QCiP=*k@dr`FA9xQV{@@Vt2Q!I3cuf33stV;2Nj7pn{ ztiHvAnZ`7$zFwlIOPYAP&BnP^ndcih+d^H@(CDEaQ4%T{ulIN=dw(xw81cg z6_{*cE(5mf?!D6ZGPA)i&}kARxe#lJDG>*nkm#^P$X7WhPkCFmCRKHb?c=TPeNQlM zv*)z8HKlEowowwZvv~MtI>PJ55yfLvG*GCW@+a=uFA^ z=*i4jB?r^GuE#OBZeXFJI|~(yw0csNKiG)SOs%Yc;40&J7jmYhN*07rWj#c!NpNvt zy5@palnd#_+pTktJ4iQ>CoPpQHI-XZ(wQCw zSSABJ6`Tr&ul~jS=&{)oX1x<1B=>zH#zDjGq`~W5RA!N3*kIXO<9vwDL9`Za%^J#v zTMed7uhE@$4ozzlx%oB1-`#AHjzSuT!L&XLgjbiDGLXAWD&7Y|;c8CX{!aRNt%m-L zk(E#GM|RppG3;@!)|4i*{`j)A%}WIvMRUkN+#HKi`_uZvF^YO&6s^E0YJ*WU7Vtyj zB(#5%sguHLsf8_8wiPlw%P68Px2C7oZ?AMiGsii7(X&Iiuk0(9Vir1?4@INmszgKw zy@ylbvH1N*`rMaAPY$9#-|y+Y7qjNIjy10?ta;64&8sSFUUe0O>jkW$x+J*RCDV+_ zX#(!R%&HC}Qh7$CqF6YkWR-{mB6k|Lp@s^7+k(Gclpl%%Ll0YnJjB#^}4}X)s z^Ij9$T7UY^O{^&PVMVb4>rHX-N{9*7CyOqrl9}?%lvI}DYMpBy;3#u?Ph`nHWF2rS zGsUUWx0p&M_Vg{{IME-J#hU)(yqV#WiG8B4WLF=nOH#JpMFk3e8g_7^x}U9r_%axe zl}Xi_2^mZemyuHxWZx;$*G{G5#hA%rIBO7hKn@!Al9uCQghCgHB&cjn?ry5<>@lXbtIP?AS%ZEZbPk{7kFL< zaCDy&PL?cOy^d!nPZzsgG@{H@iN>0Ihpv3BtXRFE!m&7F9lEWw!5Q@Cx}&jHy%jl% zW##KX@TR8n9i))BUitumdOgyAo>UPN!LK%fSIE6KYfY zY?8R0a_56vNz0B-z%nXfuS#*790r|~#iNVM!k^aYA|r2xLJ=rxk4i?`9rJ|@cJ zN&deyEvH=+;5AG(CDA!>=1u-rYhM?&z~CL|#;4PbPhkWrZVXnoA@W|{(`zh+Qm{?v zQOvm|<7A^R@$!>2cRcU*EIdplZt)%ty6bL?kx|T(y_qMU#wuFP8k4;f+Z3+SnkJF( zuRE?Pv$9SCUUq&ve|iZ0it%At#wTNGu9(wU$S?Xz+oUk8)?zQ=+O5_xDSmTX)G-_T zKS%Wb?fom`de?aW$_~4}SNs>*bq+l!FsNO1`aEf4S;zj*k-c}ne`S$f+<*L++r{a0 z1qXQTXpxOW(;BpM&yF*JvKumOf~!RUW$8r=R+SXOHy@KoSxJg`WjH8H+a%JT7Od`P zhr}+Vg2#INw_UVMJp*MT>0Ky&W7b(=CQi=Da6wH$nWaJj=Yf%o2Twz;h zlh}2T=9Ob_bR2Ziy8T5eo+?Q16a)#r3IcYxod5t2VxyyLp=*B*nE(Yb2=mEeMU}Q`6l9gm!CAil+B8`&=|pk zm^<@L*6LO!P)m0-bm@3ZlpR#!Ff8p*F3sg`;K6QJ;*OJ1T{9kbOh28GemMP)pP#Hb zoPOVTN5_mu)iP2$rr-8^yf5Rg9Y1H>Ou7BT4!^XH8Ap+)Y~I*yz3`1G1uDEGIY)JnFcz%J(hHS(^B|9EyFeUi^5Qw~l_iqRNjg&smsEaoH97T>bbl zHj9tOgjTuHa-)UGbeHhh=NiP1vN?0KY-p7SEhk%;__>4%t12EmmLqtquAs0MA{svN z(a&{v9u`?mWFH~}j}-$R>nfD1_Yi@{DvM|jA|FKHu^ho;eS&BxBJfxrgU1?(s2`&K zoC`dbIe4sYLbQqpk5v{?3XrRIhYKg;IYagYAvD@BU*juQ_lRAz4{KSn}Fa67D!BKmw{z(i%h6~Rj@ZvNW91oA$F0O8}*sY=YEAgFs z&g&HZ@zSNUT`D(eQZ}SczkZc$I)sJ2h(foX z0kJVl0zCUIIwZ`iuWJW5bx0Kg*4&{zEK(aFbg#H%;nvu>69mn`=KjQzqr}j`iMJwDoM6lpc8qSsjka z2`ab=IHH#@u0Do@brlj;J7HYK!^?_6l!C|s5xlIjkg&=@!g>=CyevmVH4$|~1TX93 zrF9N>@(vO*&Qc*^g>Ot~9Ow@m%Lh2tN<^DPRMARA^I%+s3F9h!i>=fGjunAu8=|cu zst5_|7^2;XBB_Pw7NP@)c2EmARwdwAF^G2BzC82b1?zV=2`uA5xd~B@kLD>VR;;38 zT@xx+mto05#ag#x8dR()ii&j{DpvA1foQou+Ar0|brqD(#ZW<+zGJS#iRvaoYFPLKb5)@zB}`6OeB<}Nxq&ph?PjBSI5_u=9IVUoGHp`5Cs{?Gw~1E;kcsPLCF~g@YBg4_?;U+wih(rU@_W zv*Ztjm(>j@iGI8*?OGQ6&>zAU5SI`jF1kcBZm$}A#Zk0m!z<##Gt0%1DuSpwS2K`{ z_MoS0CfZFyIy3MD+-H7-DHr}AZ_^3wTGf)bj};J|=(e}0vn6E08Nt>|zvQ8vl5MGwovImsmec+LhDKg=W_*n2>ex!I&AHeNha(jI-MeY?)w0i9Oa-72QsufKKjHx zesG&7{sPCU=eNOCI)(-cjx|huu2G*qtIq}z0?o3NKbRhQm#b)(#VEQ;4`)ZK ztNJ8u(#{wokg>8aSsew^$vE-O(dA@gtms(+xUUkZWXI#|&Eqsx#4DLo4Zb3Cs+}=W z%&ENL)tv@Ay1E|RtZeS2H1`i(I)?9D$v}IGS7DuKA0nE9W^Isz_Htm)djU1=mH0)Y zt*`Y`*c$qUg8cKiL<3=FBIDuf6G9+u_>t z|4eDK)BN}}Xjm|KmIywlx3H3II0%u0=75tn3ImI8o_GDD#h%zzQmRiKI6Z-KFjNi# zzJJtDP*pB7V<*}i|82RoWt7l+rC2tY;%thIRq-Q=j;iJt zF|>Z>CyHPdDU_*@=7BXmgDSRi>+BU`L(xeU+fejZ#dZ{9RnbA!wUxSQ+=05dz^6h| z6s}8K1c~c1mwFp`*H)=MVULr|ZLX=oW2I2ZWoK+p`L`>!Nim9|qbly9=&6ePD1NMp z(G!TXmplxZ~(1m z0nrj?E8x{i_*dlsW%UGlCDA&~WubBo3zgSoq0&}@F84~% zW$VnK%XaGmPQ9;{vT_U`gW8993vuoJiEH0PjCF5PR#w(&x9-X*<$~Bkphy3lQMVFG zX}(%K6AQd0*73KHw*-?VK8KNrRw259Xqt#NB8o(mglM{mt|B^UxmGY)Wx-^LpXN7H ziI$up*&OTpNT_*AMKD?7o%o4LPo&Z^DkW3t1F3X{N@-N;D3#Kv^jtYGSyHKN4XHFs zDm8pdDwPvI$FWXQsorZ+sjO65wpRQEO>je04(;2j=0{!$F6R*0A*zPxV-eL{Cn6_A zrieZf(Lh9Qh-xF6Bcf%9Mk9I|(Ok}jXey!xh(6_9q_F!VY9yH(HT}g6F_7)`LPkk6 zlqDi|+*^id3!eOE2RJ+J{#Dpb=iqCv=1Q zl_kK=Lz=Xro8=!gkO{}a*;F5AlRep{Q^_{HN4BZaHtsMtUR;z`7?yE%>5#^e9T7$2 zknQ9oB1+{BHf3|GLGT85kgPJarfA^+*}YR+qXi$daE>Oom4M5zL_wo$*E?H<$~vNi zolE-7fZhtDANxz_{nxj)Cerk_SoPq|FGMSy9ZUk=l)|D^h}C?;h71jhLSaw;!^u3H zr;Bjvu41m5@#yma6!OHhH&$@0`l881Z!}3Pf%h7DomcL z*zr-055lslge6M-w@5@g!wYbRz`QdII;Sw>o3nf{pn#5^=;8C$$H@-le1%?eF;4%cONY){8 z;HWe)Os{F#6Zr%>6`@k8S|+sPPvkwG#Gf-t`o^f#6z4tbZ==a6Oq2d#nsk}I^nkNG z{HcRb`F7g#Pqeu&iD#bD-BOGgJ)>*KPkM9D`ss87dB$v_(Du_}jbnxg7=iVgoQ99& zaDR_wG7rl{|6=x3SQ#bS8+|KLq-13rgwk8sTv^h&e^bP*g=BW?T~ua~1IB^6I7Uao z_L0nE)5KuWiBPbnt+|oUAN3j&;J$RMAKE@1=iaw3d4N%)kj5ch&(dPooJ)(EY*Pu5 zPw#izgGM}0+IAyZ2hlY2+z8;DySsN)2^&k*L(sQaRFg;|YyXE6%GH|EEuHxbQ^_!? zEXJwED0)G`s{-lA!&y%5g;BHuqo@r=(bzijP9*L|`!~^kJX5E$Nzzw%=>+=ImJML? z7AIQQ&~q`o-eOQG1}3k8=Q04Cn+vb2fa^2$9!|UOS)Zi3{XuMJ1dzUeM`Xx%<+gUS)HxvMmv{I;Cj5 zW9dZ4vM7;6DJf_B(x}@hO0425dhM@Blr>>TpON730o}x z73PWYb2uDXoLZ{vlS(Xh2r&MdaQRbQP~0;u|dE-EhkYL zuu?(ZgnUxGC8yg)p?H09An098(qR)R3fES#RMe&PvXDse7U-ATTA*L$3@WDTy){a@ zm@Sv+kMrL#!-gJqBt5LNq#%kW6v|;2-lLItkB)?MrqMu zvw%Fk6Ec(dv#3|nXDh^&wvkdemWs~4WNOjsBA6ExJI|_6f>s?mo2R2*y?W9?64SMu zHU+ulp<@wSagkjV_Ohxxwz8-*QQ^(lZ_N8`=1+T>KaHcgzpWry7jrs{G*JH{`(0T3 zDF*k6j-2sAMICVd6vgfF^glG%z!;T!eYsE9ZwsNV%WxZwdOqsC+10kO9OboyN3ia7 zly$F#tb5gE-OJ9EWviV;+l=6iI7+n5LYO>tS@%*Fk%2Cf{G2lX_4WzPuuvn$ph~$A zSGgP`qf=#K8_hzaFW`jhTHpk7c(ryC6vy9ISKIFBnIXI2G=7iFSS?z%2h+A_Rva=T8-X}uRK&4UH&J4AB6p1(XZM?Dj@WzhE z8+(a~ax_d7-`hFuBFWkoFIPEHtsPCc;57bBI+hmR>^|N29h7~E5lq{+aiL^I*{&1g z+a|{0Txt9-VhZ(*e6541@7@Vok^+N9F;Dhpo_v~l@@nSE_5@l?-AhH86Uh!ITGOPJ zvT~ds%}?BfhCwySs9PH5G!}fi7W>8_U083L zR$V$>ds=1=p4`q;R>$wgEV5hjtN%W`zQ6b%zUJs}>2R$q`vz`4=41co#g(J(#t7!> zihsvzj&m)CUUSUHZE#S$0k!GBS)?jG?vmK zd^h=+L`i_K#9d^C=P2TNgNnI4M|v4Sno5W9_Y9K=hNQpkqJivRI8be6sCTgtyT~c( z4~bsW(<9$h5!$U-RUXKy@>W)rU0GG$#wv&#k(5zHQhKXM%81NJNZH1Fih+m z&92b+tCFcjvnwU))gJzKk*HUSqCQS8 zp45Zw1NSpgevgTAk`}y@$@0?~HBWD1B+xUb@c0Zom%+9P!-D~VTLt-6@-rK9fv`rW z3ME$es&bxHMzsJ{N779SV0`;#XPfv#fVW-7^elq$eE@I37Hr`D*ua*|lF1qw1xGuS zr3j0s7D@g`L{0tNCk9y_g$8{UyE8<8$BH|Tu9mjV(IZL%q?*yZJXlhW#v$vAL-zVv zor?|uUVa0cy6e41D3yts%#m^8jz?h+v-IN5D~Zz}uCznQN-AipFl#1mj&$OsM7{c5 zZ3ozak#jmD=Y2-bJB*x{#-NY3=y?KRH_p8>C)0k56`ubu&~ zo&m3(0k56`ubct#RD^>w8x9U|rn2B#bU>}10k56`ujD;>2D~Z?7Au=R^$d9R40sg{ z39MwWSkHi0&wy9YfLCr2zb1GF-Fl;Si149$2_LF|V2O&d@l!8wMQtKg35%WquY~-x z$x_HqMq^+-176{6z~A%?c=Zf;Rosq=l8SvQG}I~^KSeOjI6RX^6Fmc7iMOpfk#D#y z|F_f1p8>B##X0l7b)RgSvPfL8^lsA!_IG_S2>7S&wy8N zMm_^x6)n2z>4KZ;F%UfiUKtoSRZJNexk9P9i9$u%iQc`Kx)mt;{}XtXHsQ#fk%J~~ z8?yCo0187Ij2*Tr(Rg?ko-lNPD$nWRr|6_1)ovL5n=OowA*p3@6~^_ z|KCqVH$Ryk;kuhpc;DZN=Bh*Rd!G2{9JI+{=jNTy85@1dL|`5kgz)7ddn~biyw$z$ z3BqoziP*HJw2jg>N+p!&p^P2lnlRc%(?X)TbXYY;5Y?mkSD@eM96D2W*6S%DTvG># za_?;>ge#7ax(y^Wbtj=|5nPQddXg|zHn_*NB+k}MG}^pC+M$fik_h2JR2MKx_850D z=8jz zc`87YN=DbamEogfPBbv7pnR<0gtL*CQ-Z5{D-f7n^@F_yke>Lt6VB+sFMP zH^-vX{v3xB8r_Qo#uX$mwjqIWED4N>lhA%e>71pTmYNdz8HR3ih1Zo-RinWln{MC0m7}BIyIHtwa*w;zZHFJ?Yp3u?%(7{X^T4LK-WH# zuKh7xdn#Rf5?y;DU3-)zS&Iq#C@MyHgPgNA8cdNhOwkhVlM@~YNE4CT}f_YPHd8dzxRtAb)jIWhaJlHMcLjUxZ*q*v!h{p_`>wK z4%6clOpldJb&7$DrJV{=oQdUzo{K+JN~kPev|Je<3d*in3p>dw+R03LC(3E5Q`?PC z9vawmp59OokXj%d_K^)fUS)%;)PI%Gl%1VUQbft2vW%L0uASPhb{a3GboA<@QzeV= z7=x!32B;M!lE}OxDEUxQ`JuNcRmvPYC7JvMI_#`WmprXI$F}Z3xO8PFN1ZahRie4# zeiFG#36)joE+FH1(Tky$QL)g=-9L|;RSQOYvWfy&aPd@~tOEzC$dEYo)IVC*k4pq4>J1MtC*og;m9 zVw?{!%+kXir-u!qhqZQ!IxLzPNyNr+GK7OjVYF5oZLsJSr67pRkTr{5VtA$XyA1>) zuWg(gA3UI`6(g87Dl4MoAXs>a3p{0Tr z?5LA?4Rto7`+l4G(_ZFJQi^dr1c$uhPL;Sd0dw;yXsB%-7Geu-Gi8U8GiC;VWBRRvd?f>Uy|cGZq}iQAR9x;8{m-SJkE3L26~(4d+a4r?*GinQ#o%alke6*o5lcb z`hi(`iEP2H1C{mvWs*vumvpbG^rd&`OD{QNstiKUJ1~YWGjbker!DtOOYgH|*x?V-Zf87f>y?py`bkE{%;85LcJy<1`QpL# zKJ!z8GMa!Wh+VzQp9u~R zEYsTJhUcsWTkOpKJ)&Rl^1lQx44nOj#TCy^3!A)Q7ChpwUgd8DzZW>Woy8^3uNH1; zWA?>}fL`VA1`iFKZEtbjv(us`t<8QMVbiPpgWzs~vmGqXcz(5LODnSnBhI>1O%HA! z_)$lTW54~fsELi;gAo%E)e4Nyxb|t<)n68Ed0k}Hk);PnwL?^EA);N*BD#j?3lVK; zCZc|bP9fSwEo%||)l)=!5pAQEm52fmtwt1HLuxfC_h5ug&ob%3bNbEdXt7pATP#I% z)=5O;5rx)Bo;z;1pU5U6b49k4YK=uy9gzc~g`BLBh<5c5kp-epsr9Oe>aS?h`;m!v ztFPu)4K8J(vA@PJG)H!3e?Exu*M-SFE??rFzwzmz^TKd zH*L057}mog<;TjgVfClI8j{ecMdQF}zkK4^Z_$^FU2grWwp6-Br6E!&m`W304Y}0k z`k68*zgC;n>EJ7&RW}b>dA3YS9ou$mhyK>3Lc+J{lR9|zmNE42{qLbM&xHW4*xDx$N9_9EI&Eku7II)vzRYFUe@y0eIm zoE@8-;u96Ks%o(LmD&eRR=?Twa`;Z$Wb+B}gX=sB-8b6$g_&^|ZG+| zZ5C|Y*kbyMBWKUTM5my$m$IV%8!^7kN@=&u_Pq_s56d?Ga-Ad#z%QL7) zmS_^9derKUXo=J^ipZgU)1a5`J{-I=Mh6awdn%Nf^c0oO2Fl+|<^&xMec9Q1r=@_J zZo&)MD)-}p^b`tEBWvN}!J-fF?fwf8H99I^Rj{wFcjD@==8Jlfjip!@f>L9;J6^Q?2c zQ;XU*Qe|IdsdDD_CoUt*Zlt{#zOzd5hp)yDF3%nFtVTkcGV39KLO)SAeh6@Ar1SzK z%=q`ZL^E!$8hnMf#fBH?GoD!^d0UP@oru@Wg>#v5E=NvZsOaMzo~@m^*AV`s1-I|d z?Kd<`RHd`I~>sFQ<+8VzhOu zgEp7soR`hU*E#Oe;)S*gMuzX3v*L(N{FrZhjR?7U@IT=@Pb6RYcgmP1ZRIpGPi`elDPSk1wDIY_R&N3Qe0bkA`A z_UYXs2Vd#kvEP_F$9o@EpB?+Fvij^efHJp6&y>WiwdZb&Q`A{bKM@FB-3O0v4)?FX z`LktQvgAaKQ6SAcfH$@}3Z&UOaa9_zIT|T}N)vf|R&o`~?~_N=Iqr5AK-PL`cHX_D z*`1yv&2DuwX>j)KrNO;lUbOpTyy$ecsPRLWj`CYmX|XG5_-{%J937yKY@&zmuN?HJ@>!+$*=n4R;PIw|{M$#Q1W1VrMts+-u>a&f_Mo zuj~`pYRFqFJZ^k=;kTZ(6D%6ZLD_AWhxr7ymy*4RJ*i_U2M6S!@sgB{ZJfM99tB+W z42o^x*4ry2onpn;DLx-4MJH7(Ptji$D^ZN4nAUeiB&DB- zhWZ40o_8J>aAMjP`L4wtC!5<`<)BujL+9it6Zr0JscAFBqUrb6re3=~JYh4EVxTIH zQ&MlFla*8zXDaC^kv`%MKH$6!I8%2yQ!Y^?7v@s?xI0&=ewn-Dn$xz*-KjgEQpoVY zW%6&^xJl8AqQ5HoP>fZ@@f0hzrNTs2mtxvLIi&-qR2S!As9V_}r<}=+E#kV|=HHd7 zpLq1xd7Mq0s4Y;`HdNI1SGcI8+K|^*Y_r+_P8+wYlfE9i%j(95iJk+`mWzt5bmGz0 zcD)D2OEF?yWv{@2&b3ciY+cwqxR)z>Pet!*i(bFIpG?6Qw;?K3>uj(m! z=lmbTtbVH^&Ze#6Yzn<9ISkDQ*{_>pCV@KFBv8jz0(JI^2cordHuY(@F5uL^^Kn7! zWJ{J21Y8~^;Bp}Wmvvumx9-ZRA6X4o@$@5du7*pNSM}2pS#_kwGiz>)ErS2YIPCOSww9RRizf9zYsYf`X{v< zMO2;mt8Tm3dRbL(Cbb+Z%YDUt7`ml5q8cKy>MEjsh+KCs_Bt%PYdl|ISe7Q z#NTvM`5@SRWtj@+a!0Xy2+JBnSk@0j;cX`h&!a^0J4EHVGdFMrmsCiU=5lRVgwGC; zVqM;7A|2sRmM0HMl++kJ5pD5AWbe|^A!k^YCVfF-1*Cp$Vg-oZDL9E=?PB;l(Y5wA za)qhH;N5!-z4t}g#&SiJI1VeHT|I7;=HBLKlf-j0h_I|3gk=pi7cCsHLJQ~60?8`Z z&!L5_coqkJC7wl|WSbdWRXDcY(C6Nu?7YRs7LV#F*)k zSuP11t4Y|nsuDKzE~XBWRPk(7mIFD)$|h8{#dxZFQQ+jG=fF50KtFmGs_wr1xG^fm-&oac{K~kG;+|u89ySL8N zV#kxR&tZ;C1_6JyU2ji?rW#hvmBO#d z>Mv|t_x_QaY2LX~Hww+Is3dU{n+>g{HYW5bI9=s7LG9-WYTu^9t#0AYKTpu@HhOnA zdiSXDX#OYs{_S#VUV<%MBR8+s8Fb6wTWG#VF{Eu2d294qJW)0U_Tg6D8D5Pgy2a?- zjw@E>CP=?DRJ73cao@zEQTNI85>2HT}&GmW?zvIyaoJiu^99~ zYBf>;T6Ixu9&EyPdHSuGKD{8SxFZMBmCL4tx&cW2iNM=L)JSilMphDmXO{`!qEGMr z0z!}tc9TWnzNDR^Swn-M^4sOmfLJE&jPR%bp{^|ipDGul7EM*Z?D7IPHzw+&$8<~Q+{s(^l8$h#;VY*#tIP*MLS{|*pc^-%k84P@ zVF`e*j7IAvCUhK4Df^0aD!(IYPwO%&{Ys&(W;117On}xx2G05noc2EQ#HZ4i-UEYk zU14w<= zRQ~+QLm!BG)u!&JFi=*p?C>RPOjB56`hzv5%d9aSP@B5LM7ei|gup2@)I1TFb|fK{ zlfGNikuT^i@4+AP9^`G=ywoa3L=PiEKU2fdTH!ToDx+ix_KE(*j@Tmkp{~@towNi^ zra}SWE3pgasf6SidU8(eqV$IbUox0JzZ$15TKcik{xylE~Sz-;8 z+5`irKL$|v5o!IsNc3Mp+G!ioPRFvosaCjr7}E1*r}0D$Nbpb@7)4Iqc&Z;x=2lBC zX}rMGcajdi64y5ne5IDG{`HOYxUEDF9tGM&l0qi?2Wz?L2)RlJ$> zKfN&$%FH`EQ$$DJhOtEdWf|q8QzPB`Di$xPzTRW$VUs9T(Wz~SwzNza{2G5X6d@y4Q zvEsvrk2-uXUkYi*N9Nf1f$Tm~a59=E$5f>zZX{tXPcqs)9cF{EM9t|hN`c8M@7N7i zQ1;W&jOQkbfoqlDxy~jDKx1Z3=li`_`p!W5&P|M-eHcC0FnT&Ldd}zpA*&A^>YAzu zbtZOeU`I}&2M0Et)=-A=OAO-+MafyIXz*CI94f+kQXpP0R`2yLCMw!gVH0ER*|S>H zhs~QOuiHj}czwz1*1MQ1uUkXEDhT|m!${g8P%LpCxvhovRnDMdY7TFZHuzWDWh84# z>HThBV$M8UG$8>Rx9vI5;+@&h!;Ykfbv~Q4Lp0%rcW@UD`H?u}kK>RJV)|sw^vO+Y z(JR2q?{GppOD4^^ZDTQCoO$H^1dfc)NZxL3)Rl6fSnm0B0P^rX?YVppBS>bZ!&XfOVvv8*#DlI|N7$+-PCeZXGkPvdCrZ^Lx& z`?54+4c$y*7!}z>d8(}N0*#MC8CeDzCA?nv5^6BncwYLhzC|=|47Dz*g{D0eOSdEI zjae?60#+G2TZ;2Zcgud2mfeMxJ(sytRpw50tsu0&g{s$~>Mp2yEo4*&daoWk)Z?GTOrE-Vb%_=l>{jtpXh_!~`JRc2*;!5VFA;;MM9)vURcP*)7rrG&aN zhU275=t0>}Q5Sc4=P9e>cViaWE&0`dpIzTy{10Dq^tW`lR(5o%P2}cdKK6fJTsi7) z%yPT9EB*q-nrk`qnxjsCkyt}A^VJzNnR|8|r7RY_E@Bfb+aNZmg%vSf5yW)qUwn*JlD+w$;q>3cVfZ}$wu=U?=NXvu4D>D*Vi!3@ z{UJUa=2YWpj|In7HC1a+R$x*Ff=Stmd)T$6H1%z)g1EJ2-mIwK=Wr`n$#gAq*~*7k zp^=zcE3tq-6T6ESz(7~bIof`)x=)zF5}!GM`ALDN$6uMiT6Sx0!T`6&)BkV}S8T?u z8tOs`OO&wJ-*r-u^30t?PvS#J#o>?@y6U|gB{oOfL(uk@X!||1orJa%mk>@hS@{rH z^hzuzDoxCyelyXX%$*n6@A7}eHYq056}}cd1GPG_pj1ci`~yMM&8a61JpXBOT|l9B z@Sc4egK}S>tRez!?BG`VvY35cC7TpG>WY=jP|V5vVy@WtthnO0beyZ$ogw-Me!1(2 z-|9g$RWl|}9(CmLNAKqG-{kRE*SY8*YfX}hQVVNHpA-Zt*XO)mocAPwJnncD_ApB? z?#A(9u`5_~9LdMl$hcn`D|FC0N#v{M<1&N0Da8z+Zp#Zedn=4@K%F;9!rHrzf)n&f8@LLZxg?DkNL6ugD(bO z{6~Y@zAJ=eHKElEk1FG5FPi^dq=2uYMZDsoh$poNa5XFA*r(^rrTR}58`R$VCE%;J z$ff$Zk+bG+u{XOryn3H*Uw!(Yk)1yCZ*TU>h-1CWp9tO-SjIN|re~)G72BD;Gs35L z`Afk|1IxS-{;TIJ3;o|PTRfst@AB7zX9SjM7ygsy+JzO{nteVZqF4Dl!JdI-?8ATX zd}Wb;YqK*WdiE-x8tf8S#vwe;bM2yvwq|!n+;S%R;ZfVg)lC+=H8g)EzH`rc zox(p}x^%WneuE1zWNdH)qbhenM&8Fb=$C({PhpH8%%FyTs}QhyRGxXd%giP#s&3v< zQy3wRa)M)!vjDU75@OZIaILPwwQ48Cs(9#EF^EzSIUs_5RTi#QIk;ADB7%P9h^Qu_ zZit{?eY~{J;ZEM*QI-nVDtu!?<3N8 z+YoIPQAM~`#}MsC6iF>aw-6mbw1Zlpt}21Lib1r~_T`xeFJzLB9+aC9<@jixVqC>4 z#?>`pTy+_iER3slJEp<7nxYt2$6;J0j}s)8`=k9*eOy=3`NdG7W$b+c^3~fybNKPS zNnhDtt|6GK;eAAn732+g<7}4(Uj8UF50pb;VRE6a0FBJA_DYC39FX0Og-1~es4H$_ z?xLgf%*)SkaJ6p96Dtc3#dzSWWd3;v?qks(du(im#u{m z(rHI6K@hE-q8L}l731o6#kiUV<7(Prg~WOXBo?S515sDydD?}euBi3m&(kb}-r#Nd zjAvF1s4LFp!nq7UT`3^ef10|TRJMIP*>8cj0l-NZO~q~EAXbe)868w z_nI;63%7;`UssH)mtb7&r~>0^ieg+jE5=o%Vq9HNNURA8iS>p@n)|U{a+(IB_Afj^ zD#Z%J?n=Ki(xYz-6F^Sov>pMYt)1!YmjmKy4v5F2UAuQah_)22jw63NKh%{%THQTr z4N5R40!s(#N{OgdGN>zs&H8hBQ0ATJxQ70?D&S`RyedVdWBuvb~y}LokR_&#-J^eD6D@!>z z0F5&3%}7CNr8^4gYT@C&O@qFOUz8v?t@s`4^R)W>Lw!~|CvvDnC4;&Gn>CSswk}Vz zLiz{$2VXH3>PlU*B$-wL1t7Fm@_#K+enp$K;3E@*q}lzs4d9$xyfnKgxK!RCL{Bf2 z2Dci_RVq3KUG_@+qS4mZfmvlk&gA=U(hGbcy@0}5)|bjH=@J&-JZc+s5ADl*E)!|D z45VFCkak8zU3u`AO9^!aTmWxcAR?ig;dbxG0edxp|E1N%Q zS-aByyEe6Z?!P;(`G86PIqI?b<~J8TM&0;knD4rcl^gh$`E=Tf9|K0}#2x+SB5n){fA`StCuCP=FAL!NdaBmZ&^3UmuUO!0Xa zieFKzu8Ln%Y^aLgP_&__C|4a}Jt@RfUZzz+;42O4>Jbnsm*ugQY>s~%vh9^9mk^3! zsK2H)0zjqBv?>UE75<~AdC16sUas;u5-F}%#S0X7sp3V7 z->Bjxif1YM!P3gjv=Zu8zTm5}Q4*oG!UfD#m{6!{LmmT=)CG#wXHcvlAZ>$ydh)!XEbD2sS@i345$Xihp% zS4vb$s4L)FrG&ataINA(UBQT|C3;^N-;Krx*=m&#s_KiPb;He)zS_3v)*C~51GM@O zpp`k~D=WxXO4(yj_75m~JIWq{vfnx1ee%ljIq7Da=I*37>Pi8zN|b3;079#jP*)1B zRV37vVq^uUJYHVO?ptv-S;>|gUeU5_dAw$y&Hw6Vzb;6eO|4Ig2V$IfAQq@Voxt9k z!&-UZ;3riSC{7L+gf+|Eg9*6YNxAm@jR)iAx5>J2qrJSqb;zx`Th*iX& zpKT7A2kOcSh}8*1_e4|)u2oM&35Zgtg~$idB}DgySXBwG)jWt*zX`D_;-QGijL zI3UYOfYiLst>nHC)kRc6M3vxL%|p}}QAKJYia=zIs4}(SS{*}Vi|7SvA-aXg9#J)F zfx4;$>dFz(i_N4Ks4FYDRxX0NiZB&XB~VvA5e-08vzgkEFsR_LEDwpHRdkfh$_4wI zJk-W?%HL$JHY6nA(wBhC>+S@T>>&zo3{iN4Si3InFslE8y#S4st&t7a(h(8m#D;{a zgk{}PVOekEiI{>as!7w#o1BzcUn|!)3)*lG2ftPle^}yj*{y@<+C_wA)h8^=o*2BT z#Ngc{a8%n@P%=9PR>yH}yj*h46Rp zKiu*9W~mEq$y?!;$lcJtm^M&?gR(cZQ|aY;XE6+w9D^3(_nk__MFr9AH8aue31Ar^ zwMDnBT9AA;ln{;sr1#npsP)=u+IR?Uyp`@YE`#@Z25-@E%Et51D)XkK6!Rjj5=pp#(_jU(7G7pR|~QGFS4Tu83lY zpieLM)Qx!xM|A-`r^3>pbEWv6_j0tsH`d~{_9l&2R1!z@}u2hp9bc(0{wTzfeWyJi9gKy=ay&PmlTxrdn zvLf)VFQxl#LexlqqDD3mHPSmQQSv3W(5LrjdbJ5;LvOWHI3Z!h8BnEvEK?}+k?f4{ zr~jb=c&Z|&XXN)odKGv6kgoI$$p`f5s%(=V$PiM9&{XuPbMBP6#o&UR`nJb()j4-E zQ!K6Tz_J`6Iq3-MKEk~12;F!$Y#|LhH*f02)0j1-8XHCHGCt}`T~VQ~XyWx$fYt^E z&h8AHi+JMo=}Ya&R+&19>9Q6EClg^smf1>1=Yq5NRj%PttsGO;wwE$Vmqh_%=5H7$ zHcF?BvY$cTxJl)mqIL`uI4=X|0hS%6UPqJ7F?@!w#`Gm?OjB56`h%q2%Z!`{+LI7i zFXtLl0Uh}UQ?YpH$@8>qm8e31c`~n9so;1=ckQYY%0019^ez^Nx>A%_l^CHr(>-pD^&vETF*e*m4S3V z18FS=Qfr;D)nXFeU!G4x&x5)m89xnU&ZVhUPyYFO!-{%kt*A;0I;PfzNuEYLUmHVY0G^L$mZa=7d>?Yh3Uxo_+566P)k4V%mwm8`xb@0 zTV!aj_797i6u#KYPYe>h2U9VHKGE8meI`J=$LKm0T_-uC>p|#x2fFS<%Hn3l`u>@& zKt)w&8AXhTo59!IV$L^>CtKezQ5}Z0^8Apbl~Js18ckFp85wnW5^BC#(CI_@+ZOz7 z9f=j$q8?GQ65OBZapCYt>0>v#$L(fK%S3Eea)GCk*r26sUzB|vWuFR5lpNz|W^KOA z+O9KeJH@PRCCeRlEJljoLwDXemYTRiTycdITr0yXY3O_AM=$KD^mC<06K0)Qw$s(~ zl~E6D$Mv}we|^NFm!FFn|L@12x1Y3jPPZLBBOXNDi>NAd_5;!Hu@z^n z;4}};>(`U1R1#BadSto;wM6BfCof!M zK{M~lv8nsat**Q6IeGT3DtlN4AHy982H^Wb?_*?t(*+NNYhMooObz`Lcn z;*D2W(`pANYibSA!M)c|a9{ddfdxmM+Q4k9yYdP#+p16EsbXK%%jz4HX{_4^fwL*I zas_7Fydqi_)&F0H4KI>1rAiQu#e154dMB_~_q86mB`eQ;Sb1Kj{`)qnn2u(MO37-kd(yWJS`4;KKbNY9L52ZN1A#i;4FZ!`j zM`2zD?L9d1Ne!1=@MDVOdjguR-o+>l8tbW3!y$yt7KhV-S_&4XZ&6=}uxy0!*g1Qd zQmd2IIGuu6i?+t; zVmST2*6c60kI9HG7yZav#lk@7i%ahXzOj%TABs(wyM%)YgR|G%`uBw)0hp-p)V18 zN{5N1Lu8cfR2`cbOy)TmkUw7`lalpARt~yp{vv65VcZC|Ol?&aicxQy}7dV#*bMz8%>Ew5MX6dDowOXKy zsYhssUEStbesIFSZl41u z{h#miq_t&F`#)P+$}-sKt^;e`jhWypK8In~96z#54>oPK`uz}7#?SXqIrt?LX{^kN zWgjfrKBG6Cdd~fHR5(`d*|FMxkZ2~c2?j32Cb())u~0si#vP$e3r^Ar5RM=YETR%# z550@I0K&?t;VSNv%h0+#M_MaRc|x1**k{uBdlob^30yc7?Qkgi{)3Ord~=58T_Rqf(%QLs zl(rkAAcs)4v!j@5>2fZq04#AQN%$Kp4x3nU=*{ZlN}a2V64@?04vwaM=RZx>;6=j{ zhlw#nIQ1!3wpOyTWk)!*Z*#P(pS$SkYc*ryCRsS{acaYP`YEG{=E*p-n~o`xn=lp> zOkHuDS~zM(oW|S4Y3yS$aXgEOm!9XtN3;I=*+X0w=`za6s$pG(Smb1O^lTcQv(@!#_f(zE@nK~k@5S_>BkR$kg-WPS%=e8GM>B~<(J`|o{{0O^VcT= zzq0UnB4Dg(#|4aKcBiAC``9)dd)!u_tb2g6#$^D?`ZE)h^|gSqrUA-&PC!}Cci-K) z??s2^<=cLJ^t&rw555S#^t^zw-u{n(vR)P-*7&)Avg%2#{iY7hU8hK`TjRlInFu!P z_;a=UPqq2wyT+?OoAu(i$7j7{I>n~bk)^Au1h;gvG#TX*A3Lj#=_H%4jwGzC@5SW)Ft%UBDO_g!|xcB*eW z#%Ar&rJ+@lT83Dd%y8Kd+o^%+D4So7CWKUZ(sHy#1wTpn{NJLu@c_VV;WQe9BdK-}|=UOHr zCq#V^^{*u7TKfExmS!8D^KhLWo#NLd2?eP>5JdAY$DWpw-bKg3bCIY}RBdfz3KWrRc>j zcQ*OnnDyw-3hmYo{b#QV2~B(7oHgx*I)csmYn{ohfBCgrTYu0-lUqw_Jz72YQNK3z z-Wt|4OlT5vf~A~bmrxZ}2qo#`K%pc}tlq;Su=n$^o)?^i{9|9Sao`q9;Q&2sES1(s zrLs$<(uY)fODfgrDU}?l^qN#MGnYymIMdQu!`8Nf1J+Z%8{I^{Ysq)v^4)KoV6~jU zbby>-9^kAnz*$=opkxU+D+19rL|a8vv8jlTA=-^7l3IvvAv%C)2eqt4RLNOHF^G01 zG*y%=@G04ptkyH3WQ87rlGRI5vceT5>x`mg-GGv1t0-A@6eX({l&lqKeFdnjHVT#H z-tL|H6Xpq-V<+eCAUuw`H`Y~)igC=r@X>%=K+9|di8C6ENF5kEa}a%9VR0tGMu~zD zLADv~B(>bBWem}GM@M{Dy^%wMra>=pT_`pv?CGF5dY`Ese{&)K{M#vQKQ(_3riY=p zum#EWUyO?J7jDWaxGL*JAx%XgmjsVpLm%>==d*y*6$XD!c`Ey z%ZaNQNY0sIzST{=CJp5^Dar}ZxqfJ{>{{(XWNDCe!Jv;0wYX%xWGHZ~9ut6Lg$)9Z zb+*00vCM966gbvr$>#-*)ot21fnzl~*j89tONQ3n{z0>=;qr=96Ya0G0grYSPL>tG zo&k^#{Xb|d_t%8JeM`8Ib^3!;+Z0qac-S3(dB4;x@y|nO%(^&XPg+*a1Zfq@5A)(l z7zzucZRz>LCmYQ(??lHn3Z#7T*J^Qd#Z~KxS*ILuF~#rVf9ODWxjyR9Nxpd0Sw7DP zNju%XM4GKo38jUK+DxQnyU@%TxiXoA%e$VeUK?T(ZG3@Lz9ZlN30}!kDrZx&nkq`x z97V~BQ;P8 zWUR2TVVF}9CC4Q>j~vDr+YHTFVVSYnhOn7Mi0XGeU#+|Dx~sd??fd(DzyG`+ulu@R z_xt_6-`D$fxL((FJzp0TB}>t|Xc^ULnq8%7?k-Fb{lk4u-%3%kAZP8)ka5YP6P4oh z2IX>PTv28?yV7V`Cm)ThdJ6dHu_%F$&huW!0Vv%$pmb}1(zUK9%DWHmte1?b9U^MQ z3_7cGbe*tKG_8e2OslMVd)@>9Tm!qx$#;gy$%paa4NA+p#uZ-?ElaVh7*-5M%QCVR z)~H`i=~!2KnhkwwTV>+GzfKHkaOay-LmI??v;RQv3$tta);T|0N-?vK-0Ik=O50n- z-+0_&m-(r>!brL=3?z?U!aypO4#7$XCfUabt7o>bdWyR~Xu3Cgp_Kjv&je=25iOS+(!^sDIlQ~GHb=v z`XP_|iYPZemZs8I5T-P=EZdyOWgsLLPi8Fmw(&BO^RL==c(doiqWb#j$-MSRG6shQcNBochDAC7+kKL z`B<7t6;CHUchc6vZ#_kSwIE}8g2VbgUIp5UHdZjg?Xa<`aTpvU>fg6s)IHWoNLoMAsJ{lRHCAU^SCp(kH#s9* zrzU9932;^pqRu?+?oz>oXJ41=Dk((QB(73}Yj(>Y+w0|i*oG_i z;)+4?=M*?gPf;2rYq~5(FBiu|RM=l1U;SNn!}+)Dh7)|?rckoP12I;dO$!r9m#|#j z+i}woT+Hcol}s*(-Z&c8lljnzxRJTUjm!;&lGTg_(ormsz9B22nrKT!$&!`ihsHvE zYAumfjm}AA)oD8sC5Wg@8xi$D6pQFFwGfR)bPdsy`mxR>)=IMK&7j_P%clwICbXAC z2R(9(4B66F;-=y(#XI?2D$SwzQW@W<+2anai1|RI%9xuSO*Zkm^uxbi|1Bk^)^7Q7IAKMKlXhT|}j+)lozn z5H&(nmRg9uL1c@l9JM-$=q4fuL=~uosQ3jDbwuQ#Ly*^z0gXe+XtF1x$+tX*9q9KO z?|^ntQ-PzQw14PMEY~XvkSc84m#*xLjQA^-#5GsEsv|o?r4jCSb>%eu&KIoMd)x07)*qF(Sf)y!?+@3XK~FH ztJq?Z^tzk|-+4F*uZY5DoDbwc4GN4%B-X9q1tjQ9lOJ1X{W8 z#rvLen=PrNGDd4=9!2fJ>EK)>3)w!cy$dJ{WY$^XU25;5*I8}yowki3I}qA!Z_t!Y z1pj6eLH&!*`FGk$DVlh!oHjMoB!u7KVQF&21y8nus3*>{f+m<+T%bA>?fkD_x*n*9*+odifvbnyAhwtYBKX))GXhRI{YL zrHAWiI@omVh9(G8LSiFbW82br+2hO($f#Xq4#6B;IS`j+_8y0792}#hlO91pK(@?N zUfu%iq@3Tx4Z{aV=@&wk&sybV!knL!jkG8#e-xXwS3PSceW^9WXnL@v!eo`xo%or7 z(&9S39m@7ph%7}|nAgifl(mw%A z_9qSOPq>5E=t~dmMEYu~8y)da~p+_+#&^ra`qL5N`^Bcn=7~yG|h9A+mZ8F?jkh zLrxeM|MBQ9Q*;iV+2in*yT~T+zxPB5GFE@o`*tt=Al{k{?929njzZip~7Rr{MSWvg@jivgE(*gd%!NA=HqnA%s- z$~4m^KYC`uUMs7FZk4z|_ZroJiExL|!!j{K%hWYf4bHHJ zUf#s0%F`{0VVTc!KC`yC6e?a1BHJMIh6h)mv z!z-Xp?m)Ri8Ogt7B%jPkK3OeT9YooaQTBbUkb3%P2OhRI^D7^sd~&r44CK=B!>SA? zCAs?|$5kDL|0y2WiSMK2?|f) zWEU}rS7#8f&LD2zLS71A%-pJIw=2)52y-_$z4&*Eazl4@`u|~BkWa3Q&^gZZU* zF?R=1hM{!vz67`BvHax5qH@$}j3Q~7&9_HdIbjd6tQ=*`VH;n?(G%QG8TP5 zaZ*m=v-JBe^Z@Cp{aIZ_|IOBkEU5I!%Uz-|h6?2H(DsysHj}i!{=G6k?jcO1fay+= z4%v^@XA{xLFsUMguT*Y_E~A+%2QgQUP=G7u%Bz?ww_vW^f>p0EwDq_pUb1Wz%7i@I zDklp^u~=yNO;BIJ59tN=vc{!@N>y~CE_CUvQCFgGt&6$}=m^Q*nPOSS&X4b8RN`%! z1`pNK8Q*Gk@9mMT=xwtQJA`1xRQWzr<+v(nzA3GE_=VDv6V53991lVwIsErk4nMwM zrC3(MAETd_f?gSxaAm}LriQ5{K~{S==w+W2Zl&DaA1Xp>7Y>AxI1oXk>v)bGkYQr;m z4Hdwp!}=*t%hpczE^3jAjXHsKdyaYX8s^EZ%gW>T3zo;9u#G9Q83#88)hOC`+8ULe z-jS2C`lTYPvN`@W9-5)_$FB%_^|#j0JoziN6yTv+G|>fNx3yoN4o6!;HIYwRF<@ikWFY3STV0OZlHuOruxwa6_71@Z$F1?FcIKbMD zpuEDWGD6`L`AYt{a+wUkd!m0ace_aD!6`Y#wQ0O|<3*9r7&X(jDg2&k(*QniA*OBs zF?Cy+Ky76L<;nzV8@nmF5jiVe^;XyZkC~NcTLz&C=VQMTy^VJ&vwDioKh? zt8s8r0a%RXQH&Y7|mjm!8H2t4Wbsu@~7^oNlMD zCo9zY-Ime}HLA|$7`(lNNpT&50E{^ID15=URkWmRDk;e)tYvp%v@gX}qp;m7uY$s> ztf4~ke-y-*63P_af~T2bhIEfQBEem(IJmIl5XOpw{a&WC^QG_9#HVU>orbWYeV?Uo zP2Y3!8isHBG+9FlO^dy%$tj77_C1S=hoD`xsfuhDukRiyF9p5Y!wN|g`aHu!uMA4K z+RlH>xZ+Y4j`k7UG_Hi`_F4~7#DM`QqAZ84XyY>4*v?|&U=|YjuT_|3jryMQxlG)?o55&GWGV()Z}aT z9vn&e_DJ&L)TA3Je;j#n?@54va?;~_!&A>4v3dR^;8tqt1Cv%~Az6L%olvf}?SFB* z*Q#Gq1a;;0t$aScH|2J(1shwWzVNZRm?)^LL^G*-vt3w?ZCyUyK6mkgz2*LzV6*@A zT2-c26S~!ZOr{O78aHS0g6Jj!w>n_j*1GF{;8v5L?)-GnPsN08)kC0?c(c{Ukv1JHjm9{iiJnm{ zXrk?FCnkj%AG3MW(rBXd*U?9-2aUIFe`3!n<5-(tEQ}^Q?~OiMBWR56j1!MSjeoP* zWntv+ygB-4%^)A!qbHh$8b7j`X<_uC^XllMwSv3^Lp2G^RUeR6O9ev}G*U!+R)(dt z>~_DY$YvvZM`Vw{Ts?$V<%ejfh?*h#8qrup?wkzF)lx+7A{xlaz+AnHXaJ)AoNJkg zY`|PO3YjXXkC3UFLB1-6s0|_)5lw=8bs>CRyD=uu8;i_IWP89|t%qr4PPOhLdIaWb z0wOa+T{sz{4v5N$DB%a^2^VXo;=8PQhVcF#=vp5Z65lGc`)cBtHBQMOdJe-V_AT+QA3;8Ld^RXx2+K#{x6Rn z-5t$N?pYGpamnU7<{N9rbm}p`L&PV`mVG41t%m;!Y1CH(=BOX!D3~jctKA)KL*5qh z)!hrwt)4=+8YXnB^U$sQgl=U70_z%ZsxJkB)rU%Vs5C?>Eh!uQ+lLNw%SYA`kxe~giap-jQPH+GcXN{y)GizC zaS*!I+okIVHH2;z58Z0Dz^RUb!19M~)l1-1NmOc2CFoYAAy}=KN}VBC&8JcyspJ3x zt9$9EB^&^qg!5f6bgO>y-DtjZkrTv&!0NyWB4gzlfVm04^|!T8?)k2&ykzs z-xIJ^?4vH@V+M^*+Oprrs@(J|!oiyJ)qUY$b-Iz*V&TU1JEyKXez89aFU?_d{ER^( zVj$r}Y&5#{FrvGVI9kcMe~1y%%FLQc*-$J(T0TJdwzU|7^L z80IPitTnB*tCh{ogk2-%f$}j2N+Jqt288Xnx^u-gDk22d#(F{yiU+UbFm1|5gGO|d zi(Z5+GYLqDe&nm4x<7c+#wiTEm9sqT+|f5TdyWscahfJ{qY-N_h$7o=5*o_%4njkj z>hHT+5LJf<3goKhaI5;F)l~{?bxDD(#woDX0l-#=hbj(MQ^mom0tc&#asDw^8W>jY zm@D`+3WoLb;0MPlmO?YR0j$h;mL>JC)ma{RAit?dbJ2@n_07QDq3SiM&t(d50(E!5Yr%=K|1bmauSK%zm0@|C6pRLnZ^*KQt^&wL%n41b$SVD`s%03?;JU56KMY_{3Sx z?F4;AYir$Dn%D;=Ib4=@_HYc`xj0BzcHqkvNjs;}zv+==v+(yUptFBQ*Mag{d~rc4 zua?R+HI)IK-Rvo^O)XCD$;rRxb?U+mpo<|q1w)XpWL|Q7B04lY`O09Js|>JK?HHLw z-3Bt|7JOlLQ{Ot9$_AXCJDhtS(^i!=9s1O!O7Wo|tSZ}l=+pPCn@##lA%d@m~}-tD>!-sMe1QX;ds~At9R_{Wx>ZedwJ``hAae|U6)Rmu-s^Uy3 zZc}%lNK-kGudail;!^%wES zygZyg{F(gW>HJ~!Fu0YR5m;YuJ8~q87OsoR{swL|psT=*wuZs7Dj_JOZ9RZs&2$SG zaAI?DK9A;ebI?emfnu2oPsyX3=ya;+)c(Baw6o$O9oh10e-qJu7`&y9A{r>)9}wP> zBcP-CK%VMmBVSoA5f0GnRA>(gsfg%SrJ)_ogsG&toZ&H7nk)M7FRSvO3xRxf6du)? z%#S;IwKTDsC^uZ%V-?ZJAv6N8Z1BJDedge@N@1x7_mVOsYFQ1g8mHpX??9aI@kd|kGv^oo< znYY}C|9E~Y<${Dj0!0K;dT78em0nvFxk3`f1%#}N$9}p!{ z3z0wIs=owW)d;#(G~lXd0t9rYY1J1rRb`2iYE*KeP_YnAL{t;ezeLms zrd1#!3q)n8g=jY-YedG>f@yUTQ42)nsfFloL~RkhL9NarstEb2D@?13J*8G>$u74g zyW9m)B@s31BBH)&3Fm1+R9e|Vr9^|eaX2bIE3`%K&ZaP&P4+mO>{RqurcK@PAZOay zU9Vs#9q~`Oii$XIJlE6nhYXrZ?yk9_jl=Ub0~vbjH|T$Mw|`hoa%5qzHU?gpV1HpxxZ!&xVLC^;RYvlHrjldS70F`I8btjVL=zZ9Z!w6Tc9KCfWT3nR zb`>~S5~%gNACCM4M$ubZqo|R*16o^j*FQ5%a=XilI9m{X*4*y=qplPdD@u{30A}Sx zx6(>jQI&3JVXmfc6)+g0{G+ZE7Ap(pO5Kkli{-H;p>*UKm@5tWsuAwSJk!7PTPtmg z!Q4kx?~{b&ke%jTn;i+ukP>K2+^sPI1#<|?nnQb^gW~684zm`}olq*5(3G=f8WX`& zfy(BQt(@@xDa4PS%?sDLleIXuKn7<|9e} z90{{yBi@tl_MjIq8wwJ5n~%Iq8THNE>U=#G^zD^$8Jbo?|*d0Za9;!;!FshGab4!t=d_g zyb|qw3+)|jrT1t`gb5MsP&ffqVkx*|DHI04D!=Cc zy#gRD(ixZqI3rB@Qwe#O9SQw%56rqQr$`_`zO1Tkj$!0PvtB{!gf(6G5O^#@ia4o5 zV<{M(e5J!SF_?(It#T?>lMc9N1qRDbX3RA?3{zGM+L=mv(vvLXro>#W(K&AJARsR@ zp;BIjKHEoWA-?_CWi&x0lp6|jRf8s_z*?Fl3Yj^L?qUecmF9{=xuRjyHrB;m5iG_I zut(SFQ4f&-=tlxzf;EwMLs^n&Mfly944zXMWFG{>up$94TLMG&q~0OGv7YEmGgZ-N z%yj%|zy`!zX|5=#+;#JZx>8uIEE{#JBm!;nmEM`%V(a7+b)~RaX*A%x(Z3nS(Z%~u z#3s^-VfJ2%lIzmFcA#-$BDo;BEBQoS z$paHCRsnNY3~8IlN@m`K-v&&R@-idztF**x_!iUIY~-A+i_MB?>B%Io{Zv25l zPxGMD)0M!%Bg>N0QP?6c{?IE*EvGkf=MQD1me*me$z7QzqovUu02k@&gElJaRJUW) z_)GJH^-fv2A-N(Iuzl<}IfQTDCeng$yVHUVWv5)_FSp>i8_X!tTrmU3tFcoIC35Hv zEq#&V@v`>N8jq}Bf6+n0zc@sq56F5Yz+W8^YXxgBdtBfmRCLH8%kK-nakbHIVzAQOS*LvhIaBeFG&L&n7 zd$Fjv76wjR7LePjMW;%(`a(|(<(D9TE$$s1#{&w zYOcIYI`k;ucHY44y!$B<7Hz#8%T|%P;dV^@%E|IcIs}Aa3^;pZSxGhuV>8yG@XVoLo6hIa(;i#Q5ihJK+ z6#t4*d^)2z`q48J9rfq7cZe?E2&d26gYwd~`q23Gvro8Io<@w`m2&lUq!Fx?17V*$ zf8S5@av+EwX@Z^(1e3JA3DI>wbiD~(yWl_wV}>4<)fP!6jMef$3NpBWoxQCg_t`QrDCv1p?k+TMjDk3RcUjjKwOHEr9YQdrJ`I zKlpD&Z+}F;Y6q*?n>EODtU<0}4YD;XwAL&{`dt=PB#dG1ofcAcUsUUzZb50lcW3b@ zrFR4L8S);8^GSpBK-(JB13??A6F01rg$^>~imztB!=Jc`3iymOTNs5bV#(=_Bdv(_er$f-oV3j&C?&lA|D=GVSnN0dF^g> zUSK)wR_D3WZZ*3rq_bjW4Q%@6j7_l+kK+YkRXQ?mg%}Kp7(P;GgV%6G*g|5(ECG!* zyEUNs})O6`5f4kvoMl@irPkz3>`9AVZXm+H)=6e6pE`onB~SgD7) zE09^UEAniXWv-fs4dod1Knxok`da3b3V+T97fsu0a0#<#wP~~3bTDndL8jHLm}J^? z@J?EUz;^dOZ|U?Q>l1sG;WR1qs58B6r?ed&S+U62=i}w0y7F(6R;!i5atX?trhh}$!W`>H{_NaCelQ6!X#y?QCyQ?pz*4`i6m?et9;%(Gyk z!sB+1?&8Fv)C$(4tXYp50%`ETB+*_}y5Cl_3gs9zTpSMR3z3RGT255`CrvpWMyTPT zsgs{#f#eDcBs*9j8B&&$2cuw|su>9tMdyAfs0Wn+qYDei1&Hg!oOzXwjzRH!!=hSu7jgqihXZq(eppX?Ga)~Fg;`YzOqM;O1<~;VzQRBe~+ZMZyi0lBe#>jd|wffc z1F*7tqmjk__l3!@^zX$!warV`j_TZ_eZ)u0D$R5*-LRoiNaenL|7F`eJiL;Je|JZl zla-bRPF&(s*StiXeqFx*NN^4o!gdf4Q8Qs;MJ!xaKWLs{vchXl7Zlb%eQn8I);%E4mt6HOX z)4$gn-F-Jez*qw}8r@x5Icd$@q`oa`^d8j#y#G>!K7-ccwL zlllrpVzr3oA-aob8ltt-Y9OLAJw)^|qV?25)Cke1h(4oML(>muo&^EbaHBwRoHoP9 zY7`h9yKKIPtv#Y%i294D((+IbTgQz8jOn-8(ZXcF=)mayh};kjMC2->Wr%zb4MsFj zM6rnc5DiB(NJN!_MKll5$jvR2{P()ubP-I(!?M@C<~=f1IIKXyVKtwAMnDdsU)>QL zR?p#&!C^h{7aZ346^DC{^ttn+(6gF7dS9xCwilhRnlJpE7R`m|F{Y~UHh$PM>1gZg zu~0eIh#Jeo?FpaT_H;!{7%t$lW{Y@-h;0P(p?Fhs1pbl+!h%era9Jg5wNK;M_#k=( zY%HKOm1`|Fb-Mr8vq8I#E#ek4h*f-R2$3a>EC@dSijmbza3UAMi97;eqQOYzDoS>S zku?M)N)OR>y&C^^y2b|-UqMu|k`IpZp{acMAf}p68aCx^57l1zjTbJK=ejFpLyp^?e=Zm;vpXd^ zMeH)>j*Y;;D5MqO8T~|`^22)k5GX^ZA_Lqm@FqSSu4O~Sp)7FqA*!*jij-E5zAZR1G(qo z#bODk+SHKO3t(KXjHwa`M-bJKQlo@W)$U(%ybLU9`)4v#wUNhOorVmiOuM6fbZUdwyrt6R zj-w~uB$Z1^Wq3*t8RV+Shw$N%%@=xpyEf9)>Dt4Vqra;-C26U9%%I6h%hfSN9apR4 zdXDsds{wY=J;kAz!W5O~^dHITe?NMoR~4t$3;-E2!AFj?FEWuiP4;Erc8=%{JX}7{ z6vY3f;n;VGs1-BlY@jr@H8VMwg35XikW~vs$)ZP&%RIWK0kXo-z7_iiQ%^ zuxihTZDuSmmoTv)fns@bv8Y z)`!l_4z+#}TDIKKrz^|0kNxpju+=?bUU~Eq{!uCTNHDJeWSs?&wO)WcjRnZ_DPWz? z{R1}l{1Z-3Iz(#?AAo3ez6`_4^R82HkekI35Bm_$Bvm|0v5Yg)uPIhl#cwD!QpInj zsIXW`z@d_1Lg|2Dsy#ZZcSR56TVtSYXd_(&Dk zN%3B8Y^)C_KVNaxgNJVkF$r#2Ptjp5fgzdMa+t`W3d67T zQYR-4T4=1LqIws!eL87C4NEI2P24EgKs=5Qo8&`wIF*Kl)hHKqmJXU$p^7YkbwvxR zYBV>Yp;s9~R9J8<1=>=~D-#e{T}7c&0MVsG%X;xa2xZZ$L?3NIUX_SyyXDtC_HeMu zikjns5tiey{f@BD1}k(H(6q7W`bRi;v)pQ3ns9Zdlop{;EeIYsCno`$#RLlGEQ5rV zlW3{bn#Ajn0gy73sEvj^RbXUQL4Rlml+BpGZ6r5wmX}{o(G0hM)Qug_{#$$u-<$P{ zbhG}T;~x{hGa0>7{1Bev;q8fscU7r1y?=$nkq~auDBd`eds()}V_A9;%hJ_ZmbO>R z((Fd+yN!j+K{2IGryOUMbP=nh)wTAh6av)4Ph~~DwZtdYJts@V-`j~OK}2^EbwqR# z(PL`05zz=lR}np-RvYmL%sM9_4ma(D6ZOnlYPA*721IueJr~hkMBgC#8&NW~+KK2U zq9jDA)IwDJyoid!oGONcqrHggA}WK(NJMuLbwpHA90`p|oRL}`?Bu@Ai`SqkqEaHd zi)a?2x`;|stD}fEAZmoDEVU4QgUA+9Icjwh(M?1Sh$>JEQE{9S9TB}rtcSR$UCQ=JgM?`%QnTkmK6h4Xj#WRuF&8H(xl%$BXKzULd(ziBKdj(s{a`Yh_ z!3!lMpcYOCcA)h=LkLih&}50%R#^|tSrgyOn)rLHiC;n6JGg<2y(U=O-Tu;|mx^#I zpa)_;cU=v?&>V@R*#iY&tU*QitN!4Mt+n5Eg9 zBaM=!*`rctV3sCSCs3W7z^vA6Ug-CmoIIfcZMhE)5JPRB@hZY33AnuTD)T(l9)<%6 z%-Ts{)-Zg!hX|BB)Cg5vLKUzzZeKzbTgm1RkCT*`9b`K!k`CH88@NR)PQ)>)-4@fK z|rMY4oUhkp~k0eZPAL^e7uHwSdnOGUISqhUSk6wjF z4I>mv|Dtw;Rx;`MN<<<}Zn-Y~8#f{_s0S|2iqhC4Y3yZq`^YHGh+N7AEu~+jC0;U^ z&dxo8V;kM88$7(IG@KUMY;GkuunSX^BI#UWY~4b*&VbD0cp4yUw9eMff7(J+Os-Hb zgN8(Drw|`0B zKAFD#K7IRr`t~^b_9&GLE@|Ns+4a88R?gd7peQMR_==*Wa!b~(%6pn;N_W9)@wdCu z+VxAgUfOKxR@Y|b8AzEDlROqiPdZCFPxdv_>Q>b@hE=JfNoUe*N!k!)_e0s6P__%o z4(lEz)A4=;3T+}#$b~LFj6flKlugR#s6tBPenr{X^eOIWG$R{3pQ#rw_rqM{pH$e@ zWo4USi4M`SM6=DEq~UILzrbGL*@w|=xxsdlLbJv6I}#O-qweEmPaG#hQ6cciz9}lx zWt8E!71vx*lSMJg;5&_H%GFKdq-rqAdQ@aftHl6E&23MsrDT*>mN+v|wryt53DI=2t zE4Zjd0>~08cPNJFA!1$qh{Q{<#`+nG^^?ZNLfcc&_5-wiy@_NI-uaVJIPZKF-_K08 znEs@5!9)Fd%#&Bb?Ny{;pDtbINTxu44>AMvF6PLNC6htTlU0KEc5>A7$ZHV0pf1T8 zjZ|`m-o^U^u`col$ReLX_c&UYakLBL=mI*{%8a8{vMFuP#*O9!0;t>^0lU(=?O_5% z0z-DyODcFkL6TQCkh{@HEn z+%+A-0Pb4X4}B6hy7w{FZzzqjIP;a5FIdBFSi@1k@Vsl#ecer7Tr;|+*58_nfGUT?UJTeKJ&(#^TUE9oa^}EUe5K3a?mwE+xNMNd}M~FA*}Sy z{e*Y*W#$FtI5vKcI){#jGkSjo;9)wjkLk>lr>X_9>8SfT>Q2;3pm=$k=KmwpL_Y&Y zzgnzw=51=s1AEm>w;h_k+N979U^m1V5&+d?*0rDpv)Ytxn(TX)!8?pxv=DXf6{39K z@*H;X%@Dph0OLVi9=YdXoZ&sqXDxAzh=YS4W=Y^MfT*xNAs6Q32hhu_q67UP5N_A) z4P52H+mR+@*Mh@74wH4RIw(ZeO`S$?Hf^V^Og*JBH(~G|%;3GB!FwEo_chGJ7FgsN z8RtbJG8B{QD!q`lCFH;#D$jp3l(Qt`ik(?JS~gLJ&yX@4SW^sPmB|@*ku%dJXVx8@ zv5TD3M$ZogN?|19s3t=xTkB>&_p_{K270yIV!Bah>;6AL78?H_0LWt9A&rui6_8b4 zG?<8)dsOUM97AD@#p$`GYCX%JZC9=#mW{C-DoB4$KB}^ZGN-TqF9&2{ zd(z7FFY0R=$&!-TEPsl&63~`TpPhFI4kBCVD&{_k@45GJ3zkkiis*|dqA$GN7*TgK zqIyC|JEipkgvUKtq0Pn8jOLjW`N{47FE&p2Z+V+Anp)cC0!sv0EQq{CieEL1CN^K1 zn3jJwy}fC;!78C}3!xWrpxL9MnJM>UaE)N5+>@DdPiD%iSW#|4&pxJmlt2u7X7(0o zqCONoy>I)mlg` zmaSjGW*ZV)HB@++Vmoy&|F zaaBva0=ByDA=JjVAzJN=R?WHAMpihB*kJjeWu0Kd7C8qiQ#6+%vJa+#?Puz=pLNA? zOq8#&u6STCO1UT9wPsyWI%P4wdeX?#wLL^uw^S5eHKtE2bperOO*1X_${NEsJ>cU{ z0zR&>#C1SNa97caCSe5Epm~>~d26!14IwH#o}FH2ng@@nk3Y>x&6DhyCwW7mJBNR6 z4Ro_LSVgS~qVvNDPDtBuP`4GF%_>TxV`*u-HL9O2s>do+OqExJ?Zq`^5NvM_Mo%ee z#CMo!_%oOm`W7Q|SwDJIpH>AlKhutbBUaZr_1Ce*_Dg@Ax8J_c&+~@+Za8LA%Xb!0 zRF!s@>Gfi)OY8?XPlb*8>sT${4d0nG_1!@K+(w#eb>?IQM_S5x#Txo5)U+>_y>S8E~1Bp_XF44D;ocG|(nCsFWK zYS%%6R=pcAV}=fH*PjCuC%a}G_HcmEBHTJz4Kvm`XQLSxXY#L?BPJhqM6M1KE||}A zU7}0Rhod8JGliSbuU3JbCY@BI6Nv?S4WzP8HCk&R-N!&WhJiG$vS>4^3A(O^)(2x4 z2P>Y|SU&&Ad}?3jhOUg-1v1x+WfiqR&KGo;Ux!J7JuTWlEF>20W8Rv4o~s!%h;sZe zS7T!dxb-<&3l7;ni~Tdrc>u%8h{+Q(U)D0RO_MV@ z4hoiZ5`=2C@;?uS zYIU!PP_4YaNPXe6EAFmfuWq@g3ihh+Dyi_6&vU8p{JwCpZng_+v#ragV`nU0uy^5K z6KwXEZfl*`;@cD7{ajfvR@chZsuHw7=vD{HwYBcLU&MFIKi&E1prNxCFSxWC>Qz~& zSIBEh^`RxdSowWWv8EOeJzoFxtzjjPt^6XWm~F&;kE5SPJD9Z}8R}9pcICRDVl5(W zc^qBnXm2)Sq=QSzn=3yFDrO(?v&TD&qFb7+8+o;7$-6866I85K#8r=<7dcAK@ksxk zCI4PID5zMQh**zz7DqQT`*~#5o+Xo3wht=SF5;}m&x;-H?4OQ2=v+Q!WrLuP+C`lF z?dQeOHX?F&c1c}TFL8y)z7d(@zeSehB-NerJ&ls?`@!Qg;!(jp$QOR#!x!h-xF6BO<>s5pTy=2s`tdfN&~*5L3+V z>$&AWDHm*3ds8@G{N45BnP_Je}z4}wA zS976WMN(-Jm7rdoob55O-Re%IVi&hNU+nR$Q9`|%(4$oBd*|=W@LyV?M(+yGV~Rcg zqEU_Bi}##=(mHm6hkB0O9RHp$tzsW_Q3$Lpg1{;_{fZ#4 z=6rQu5LlgVB!a-&IaLr?uZzxq=r62{U7H2OF(L+*L&Qd-TMr`^31TG?#L7D1YSe4< z=-uGAp>%|Z*c$Oh5rbg?VAKpsNICAQ6GSIqNX?$U7U))2Bcj$GYBfRRL@h&zo_?@x z(1^L`PRuu-%*AVP@orokF3KbWh%%T~zkXTmSjDL@I@SoIV`ByhD^HQP|Kd;FZgv#> z$w1NdTk!%$=_(&k{0HYnC7tC%FFv53RoA^<=V+K{EBzHVh{)C<) zFfeA0^24tDFeh5ovHjQQnJ+>mdBd^vuT>CImGjdcu4y1Qz&D=K*7MEGQa=Rz62kxX z;(v#5uG~bo)?8mcHu!BcO1pBAM)u~7D&vB?H#LT7)pE|N1c;nZtnCcT`pv-R#LgO=xD?S`Cus@4xzB*j@t#XmC||ppqq=1^l2=N zq{XqJ$9Ko!6Zg!CKXOeNr zq7xN>RRzc{5N%bITXUkhJ96{+J5v}xvE;v%R!FK~_*2Flwn39~i;=b#wO-nqx0AHB zb6TTo?U=@$=7Op4pu2}9{}E#Xz&TMSpKZ@#Ek3PrUYT-4T{ zfo>6}JW7Oke&g)A#4X}9#fz$VhT=_CJWKI!RXj(rcu%RT?m%5!aknDnOxmKum-M7w zS@j#UJMgq^v_)h2x2kx7V!yFSKXl0>FaGbj>KA+$ir_98>x%1k;V%S>Dl=bQPE2-aDa8xn~%LO%HcJycMcBnv$zOrtbE+3#-=mzz^%~rzHs1H>o@>6`!UpdWzT)(;9(6GUB^w9-wDesa#2iq zU{|zXUZF5vp^kDzcwz4F!h%ott+B~m6fM-woJEVMRZnWggX(hNhXxaIU;bQi4L4!Q zO&CfvQ?BS;Tdruv-!92b=qD<6I_Y^+(}{B=pmM<34?3QiD2ek|;A^$T} zLUn$WMEYCV>q3GWUm-Vr&${vM1amN0`W!?q@|L5PlUQeexV}jeaBGe zhs;DCS=F28E$)e5&HC7x`iXmDz#3U-4ncGqk-vzRBifAU9-^rtx`gNeq6Z8I&nNS93{Spvf_&{{m4tsg~%RJ1wL?oIoN3p=I-2l}@e%>>4DB{2hv7YP7zSRvFCMMSgpLSq zM-F(MhA94$@;VjCRviBu_ubHuxglF|$QFY;3FR3^Nb_O*LsJQ9exlREDB1fP-7kDa zCX%Vdypy1$@j_(VQYUTy!T?Ub6hB8j;)J>pC$t!4*Tf@ZfMBUtwmB%C@K=>vzSJu~ z;*>~N@iP^dQ$i!UOjA@b099sP5Cya!yxSPMdB-_iC!5v<9Hv zMhvrCh;kl4G{IJ)30#RL*rqj(2SU^uKtydABX;I!0u{=WXS~!a3XUR#DpvoU$eT0T z6jDaHI#(fNl&hq_y#%!nkw>pP%vm#Ya*Pru|5dnllL^?lPv0I#-yYRi`gZRswCaJp z2RrE7htjvVQbesCI$Jq!Z)`yVt#aD}ydYsuvBYKT_rtt{qx1`*Do8CTr_BhGS;&i& zcM69}5u8Ai%{e+Ny<3&kUO~RDWDcEepHUZ-9fq>)QMRud$UBD~9?&>cC9GURsL++M zH2Tdbn>#dN^6~O1A7?mMKJ&qwq0vJ4p+I+C_n@mL+(Z$lYG|K+J6FspdqW7lTU_@j z+hi=$s;ikT(d_9-X?(2Q*|68?-t>9U=Afk`(}+f5UW;Hrpqe| zj#BjBqRq|NliTStERZFNU!_bF?9iInp{+;DWA`JjIbjsKzK~hhV&KS(S?@4giRh}K zh4}7AAfAHR(OL~?rxb1^l!Q*^BdSW4J{lh+cfp!TyCJeTil6x^MRxI42`j4^AzLw1 znt~zv0Bv7K+t<$I;4+ zqgITgZk0s8Q7V0*Lum3?_db34BZy=cb%8mvB(De?OQ-6k#Xoo2?yHkg+WCy+wPYm$ zE2OXdX$9l$Lk5TbMeP)o-11noY$AE#v^l&A&8vU1g<;xLQMlP1;uzVU<``ijqbrqz zD;7;H{*WuD&lSpBB(-$x^bsB>2}ZkEWZK2D!!B%?U5uZ*bgnu`hWA$2N;;E2HEW9+ zZL5{3?^y8|$KZX9!TW$Rf?4snZK!QS{@@+Y*dru2TcXfw88nSN!xEyeGFOX7%NRcU zGb`%P@Kn%UU*fOG18NLv$gKC{>YTYQ@LW37X>iq_k=`368(6K@nW2=no@IhPlzpoV>Ao^&t&2%whjn7B ztP{P9g}PP7a%G)_V4dh+Ea+Al+NKdUj&O)QXM!ZIoUfw3rjfL?WU*P$R?gYor`T;Q z*j^NDCF@lJ-`dTH>dA=e$%uN25jB_>z>2+6+_Xpz_0N1Lpkb2xv$glEDgC1T|5oFK zsX(qfgJ>H%+FN(%XH;aVz{!A!X)Gv!sxlv^-U z9s|m73@gfUu~a^$MRL@Vm8{9bCLZ!%1|N;t|;MFdLVfVy_UpQ<(yfr0-kQ+ zk3EY&HZ0E_Gh~jf{0iA1NE+{;#tfd_?D^om8_ZeZbYg{b1uLA^tZ-VZxT+#HSc=5% z(9hD*VV%&|@X8e_^{NH0nS$=t1F?RU26lkmrVb2{p44|Mw#sGt-R;;#gEOxyN~bK1 ze5}shrn0j_RqWN|%mE+11bp090UtVoyNXz3&|LEJJY>xk4ZVk<+6(X^o#Z*@No$xV zwJs|v_QOAy02eet?aJzgxfF#FEK7;q_HKyMX$5DWC8_l+Ei$ZT1)H_0NsM-{$SP5G zkRhy+9E_eeG~y!M!%(dsS<UTBsM`MwMoblOq1Ewi7)#N8=(&Shm=uPixw8E zpnGH_vTup@wiy!9)qqg8j#ws@%3z}PCcW1I!;UB;<6ES*Y4LI*rY`w#bY!tfm;e-5RB)$>TCDQYdmt54$T#yq8g&MHXBEBo zJ~TWQU(t{Fihjgbv@bkPEUmE&06#KI-lx^j`O5`%n5Z9?M~7_x^$M80+`T`eYkrx$ zFaJaREQ^_H@4(zwoHWtsinU%fkL@x}GizFjveWh@WDxhww6!|lsFmzO@{%lM2+KGZ zON@FtPWWNo?iKxOy`o4i*<@X3B-awQ_iLi;lF>|CBjj(nDd zCP_o7ECcI-bi!GB44t<7Aoa`-tAFbexc5ENHD!`4+aE98?!>omHruvi!QnGw245Ii ze8v~$A}Z|fRBD9JW8007nzq{ccc0@E?T(}^V#~bkG5vZS)=BDMNhwtHdRD}EW%b*s zmNoPew5tN_d5eXt_D3&r<3&4|>{W(<1rdFf$U4QJtW#Wb;)NK<3$c?I;yM=8VMf}i zbEO-8!n>h19882?>B3v0#SCT;=9_VR!`i3XaIlSzd7ez=8JD#!3@|#SBc# za^cm?N7xpxq)bcyf$!@3!;f4atxf$k^~HnKd#NdBQlH%mX!j)f-tg34Zls(DNFJY> zI6UR?y>^FFp50y>klZfy`28EHA*rcHdfk6J_4%gnK3;GnzuT^DhtDle9j(A@{TCP(>e%D&aSU;5$`P83(9r3=|&m$W3DtTz- zv7k5qJ>mniH%8ucDS2|`?x13J7WX_}Tj=9p)_deEmy$oM3=JyQ(&BfI*A~UUZT88? zx-KPuTRAIeroF`tj~R=6TAD?U{HABg`zuEW&1_{6=keO&_~vFOM~>)O^3lq^K{MM} z#CXhD?9yXHvSuN=ifAvjtVC27(Km>8QVUMjH$btrAlgi=h9VjP6f00T zRu-QL$I1szR&hlBh*paz-a>C5wg2gkn(7Jlf-CcSqaJ z-G&PS>t_&HQw4$52~O5;!pW)tCu;(ntoy>r>INrk9hH2kB%G}0@zovHefVN#`N%4r z1&B4jpK!81>RKvxfiNQce^^^S^2C7n8UEq3zq-Btt7Sb)#a<~R%#pfs0#7-?M?!gt zw-BtPf%6yhlPdp>C+K)b{$)K-AeAE`_9Tj@Cly+ zF6-hca9QzxQ00-o;Ig{<9}!$uy~FPaE-NRtRh|Sa{XkQtZ}?jVzYW>Nndeg=wpI2Y zox`+QQ{Hxj5-xB^+$DQD^)=v>!*6#C8g3EHdvt4jmR*$XWd zpHAWVcsJF*QI+6xb>^Dgxh9RZa4J3Yel6{NQEaiUa`N50$7A@j)p++ZM31J=@IMxkB?QI$5@KTm?u~(e^jgbyb49f$I1bX^@;f! z=2X=gM``OFB5K79I;%yVocVuztUOs;MGeEEL&<{Q(#6MWk%^BbXsi=MBICdL5j0jU z-}M{I*77a(iT|n}0zKOZA*cEsA>_d1u@nrCJxre2g5lXA5FOj|@_}!PZGE!h>TfPm zsvvbj_<^H*Xeu8ZJ*IDlPW6?Cy}+lOf`i;5j!-P_Oz|kiimLcE#k#8a4MkguM}SY= zfCM!jO4LT7L>-0_wL%|Smio!yv4N+PTm{_Zydt`c?WvDLw$+Yu4xt#XimNCdQ^nO3 ze^bS^6kiXOx*u{mMW0eED#%pYB7fjp>QbP%a-(HM{NQ08;u+Y}RUSti#SN->mEvwy z{E^}}s(6j!MT!A>VzD&rtknUxo7R;-e@U#wwiQXrd5WU~;fp7qN--@!YpzIwednn5O5@pX)KUpdz7cP<+g;$^d z(T)EB>TDAKqegBbSY(f=)rMNV_@SXhMsmfo?d6JgXu+79FqjA>f65i>aTDFS3H?N~ z+>WI5spB0c9^&66YR_t5>-Ce(1c>D&>)Rm`+Y@u`;m22R$p&X{gJWnN|8Wn8U$t^v z8nPm-5=J)>x#vRUUKl}p_GxM0cRrrqsvq>8P38GoE7_ut-SQ74BC7csiFH~Ers{XW zR4w-t(ff$jBZ^1lPuvuuU5NfbG*v{8*9bJ~Yj5!mJ`9m_P4kj-trgJ)M2`_o7t#BO zenIpM(T5`1i|8SuWJCcXdW@(T0IFibq*^|MbAh~i6Hy67GdUNcI*3XOlWO@a@+{U# zQiTnv7v&IrB%;TNIv{!z(Z?cczFtIq5Sb#HEu!}ky^F{U(Hzc&Xab@dh~{!GL^Bc9 zLG%gdBF|#!C`qX@cbEH`=PKtyv>s7IL}}R=%bPuyw3Vx*trU}GXHA@>79ERdX}r%8 zk}H)D=APq{;eHSX$VPF;6K5ZZpHihNvPq@)C}eu);+4Tsq?ZT7z zoNyqmPTUX}Ea@|K?NaEEqbYOtMNw@dm^Im5qK8_O;PJgm@X)(>UqulCiF*DS5lZA& zD-qPDJYZQqiAmkIClC?RQq(Yw-f|5A&#iIj`Vr8RKxphOyw9h}`wt27YAXDwL#W*k zwI^irKQnS`2uW!h8P=1NXAjjJov4ZCBEU<6rTmDaT2>`r#W)o$#hG4uCqq%dA!4Y$ zcOsHY@8W&+?6WhnR9b&7v0TzwnS-<->Zw01ZaMvzDWW`iQu(d5Q~|66E_$yuIlX8+ zTP&BGx3ul3vy7HKNkQztg3mj6DTWg5aS(t1`^=o~F>|`CHFI(#4(zVZ2Cx1fW5y-^ zUrr>f0`KGZ@;}_mef|HNZlU6?equZK^r;ghS>2mHOT?{&bv>c$)|m^g(!d$ZqZ9$} z2KkI@)J}#EXx5oSHdXJ=YnyA1Mh+ybW<{6joo7CHMvxJApC#_7h(-AgYw}5yeY~sk z=(8pLmy}V~jBnD@2US>CsP6I9p81$BVVbuwiq0ydNNs%R3-|7J<~$3rl%B|-P51(K zMb0T2Vjk$ZAD~za{~L3`bBk({P1pN3E<n_m`+4FXHvm!{4(tZ9l%D2T<9JC$y%@%b2jK z6m$cJN$DHkBztieEHEnPA0A|mZq0ja2sRdh;|JSE?SvLw6D2ZHN?@XNdnhC6mzbhc z(DnngeI0EdA_LfO%A}5aH+-364!DZQ)hN5GrJR3?yayU>Yw}Y0r^+OfRhJ^#)I6&- zB3H~TikUwjbZ_KI@*VUpW&y@(v#}IbR`1LQF%PB|7R+5FlcFaN`w z><0aI3C~hXQLk!bo;+o1a~fcDR2?!FM=O+UC6w9_3#lKyZUlM3J;``jMaDx52J$if zqF3qDg&eDLXtJeS5FeV49FBqjrd}@5LUYAekZ3`_?m%x>;6w|tR<^tMX~(iLeC{1G zWwK-R)Coj$3{7_39!W^MX7XguI-{>zXY5Vqt|Hny(Yep1g_l>WVsrjU1D8~B)NRiN z2&Be(C`bD+V(~6dOGHPl|DTK#{^QHjb9?f<^vt>NNtC7IKQqssG@WX;bw)9V#CFj+ zo@&~*Z!{~`fvj%KZZ=hxv6rFz%?SG<+{luL6H6Xdcqt3rj46_BJH-2<2lz^_6uTm* zq$6dcy8>RZyl4h{&Wx#(St|}xGdC_5tRM0hR0iP$oomYJ@H_dSJL zgHh{t($@x)zSfdwrSj6rEW1kg)1pX3-8em6|71>I#98Osr+-CB8ziDPSn4H~=td?? z5m=%TtR_cbiAKTmBWH8NA)n_mm{Fp` z4B}SD@s1U-3uP4rEk)R(R!>$Lodnh(#4b0Ky_+|{lQ-ZL?LC+^FDtrtw?umM^h|Ks5o_9J z(_<#CNP8AnX6~!DWoeLb;`pa=Zp+O~2b6cWiwVy#{Uql&e^P{ve=wbIwy zArV=I@tkyz8ZN2fJo6zA^2`rBl4q{zPs6ZkKb5|^icF$O1s9OgiqT!1P^=z|th89I zP^Qa!nJ&M_bomNXw;e#ihwx1Fvos1)OaCY=y+XD0uS9p$1yvW3gQQOmY3ms_h~l^J zW1>8cu#0Od>AyJ!%zLajUuNNHd*&tOwEYHK=)2-UwAN5scpAY+u3*QzbDJv|+)BAa zT%H5dSi@T>22Lig=#wbWxkn6&cFdE!nJ1mYDq4d#wl%JIzspRX$1r)0W9lT%wen5wD~j;_97Kd#aQlrg|U2x)>w{qUXG+& zwDw1?=8X=2hQUN=I`3GnK&bA=bB|foIAzneCqzBz3s2dtqD?5<1!aeIj}ioJKc>l> zm?pb0O%AInZ-D(?=2ps*V5Vci^son4$-?mYFnWkqVO9uJ@vc7}1y6W@8QtpTnZZ9OiCwn5dWJ0pu3!^)j3* zP3DRw0mQ)e$yhpZgGO>?Tv3us#Bbt@7OT*RnqmSCquV@;?|mx1_a`_I{>1lw4S$h} zr@ERB7R@sU0iYIYhR4pFQcd>X(${m=RHrZ?tQ2>*@VE8pt^%(5@%36& zd{_PQ>xl7XrwuV4H+%7d?@B!VV&#yJ7cV$7_OA&x2Wx=2IvU`4>~2NjWBn=eOGAZ^ zb+DSqpBxqZmF>~*`mZtmz-FFhy?2iNWn26BvDL;)Y&0(hTzU@8%+!jA)36UPrVS(P%_&oGe&Gvk?tL z>U)Y#$d@aDaYr~_pVtSX6b0K;hE+Pj+Jw?gBJM)5 zpdSHpbbofD*^-JzOWf+3*N*AXV}ARHkC!c*>0Gv9!`DNq_U&87woQ2WTORYfJKCRY zwlr|olFfC0PY3Y`ainTPL5p2C2P#(q-!5(~H83krR9`CnyDRrl;ViJ`NK6)bHU!q;h~rQ}~UWZ#%0&Z1DM7>4S8IdWXu88_@u4Pq^wD*RcvP?i&5gP@BHLsz7utvki z3PZF>M5P;vXnv1Qwjtpcg`u#ynbc}jF4|)YqHTz_il}sB5q*zn52EeVLUb3=Aw)Z= zWhJ6AP9i#nXjijp(+^*@ngF5ZX^HVsos;GZ$Ew`)XobDHrLb3zz+UYHdv$S&!d{(H z*sHM$dv#E%kL?2MDiqdLIapVNg^}~al3c8Iw~R0B~rYJq~8L@h&z<}N-l-#qc@ zv~7b%^y1fv`C zN6f2t*bR==uqI%y9#jT`_Iw&V1RS1t?+Vsc}?OMkN?haM2?rHvHesNj6W9o-x zd0-vof$iocu;N^~ii{ua7!!4DsVLEfCI|TF=~w@W>g@ln;#k>$y&7f)_UeJcUae5r ztHBC;wO3)Ut}E=-gfEizE|dP=T>5)qUELAZRcH*Xt98=9zvn0oeqhql`Z0qp)9iQ9 z?1#|ozmR7CVq&je@_O+&Tv5Pso)9!UH*L{(wW9tF>o2Q3d)2}rTjj*aO1T)A)&XUw zX%z+8iieTj8En5e-s2WL#thM&C$IG!8F!~tF*!Q$&>y2}@R0R{ zf)oY?$ypRoh4xL8ZhypTwCZMWb`|jyS~`6|XZg^J4>GiOPMYm5*Lg9|eb=!X0iU_b zh)`>D^M#(9hO6URb-baDwYG>H@?RYPWHPt5n!7DT(eG%&o_}8cMe?Lw$3BwtXOeNr zq7zl5SEmbcq_G(ee`U|(bm705cqG{@{9Wc$gKo;4YS*zS=2YJB2hRmdYg+^4to2mU zoCb0>%eh^|t}r_YXIWX26F!soqLqBp8qnbe`A|D%v5(bl1vZp(JcVG__%pe}Ko_|} zQ*K}Z&znbZ03BEtt!NylU&R&aMGx>43?_mk=*NGo$xY1VCW=^8EJP+xtt*HIPw)QJ zdRjLLnNx%F!B=XKTix2dUnZ5tO`SY{e-RkI6rR}ZaZ#-_X%lwo- zj4QBKIte%)>jbmIH^p5aG)?0j)r5lu{3uAo!{kHY$)vvErlv!xukweV)l?t+l>%k$2aN@aD#SX-)FZgGom&U5 z5L=3ls@Q_!JXLg{7_EwJRo!M%HyMUgJCIw8In!ryrYs_8TGy!nTPrvGmGiFu$KHF# zMRk1t|0AI;R|hVg|xk9nAjw|nUJX*U|ki1b+tsX zuCRM=jJ*?M_s7`ZVeD}jyP*1)8d6#bJIh6mTOOd<`9jj<=sWx9kFtG``je%DDh(5QY^k~vPysRx6QiAUPtHrWR6x7?D~ceL$_&b>+HZW-s5; zVefh`E7KiP3#lbicO)~BeA?6<`c(F=+n08QFY`oxiQ|#VW3ygwQae?)B6P$=Rqsle zh}xvGD~pTg2roH@W`N}g?R_wew;W->w2W-CKD1LQ#<9?|%KnvPA?;!%Lf3{HrC2y7 z$c`9kU^pr9Sx0n+Zj_cL9r8c|^#WuGqJGNig~Vqym)85}1Ytmnu<8Z^@Y=DmSegsa zZ1HEfz^U3q*IIBg61#TaQstNhkwlKWK+5;Lq|!;GE)q= zo;PO{;?qosPu`07q;D}Lr8|{+rDq0%N^_7Xss-ti7Muvi^P@+7#DeZEg7KmV#tVUi zV^=GBK$zK0Kg|9Jv)|Ggo~6k(4YHp&d5bpZ>`hKuhAajFX{n6@>yx*kcQITgYU`D( zqN${v+pS4m0l7s$)Z(Se0Qwf=)VvjtUTDpuYI^I+8;ENq!bN1;|&8TLmI!tP0Chf_vyMP zGfsZRIQc2#kOTakgn2HL9(vvjJoBqjprv%;7Qg$OMM8@1Qm#u zQNbbvq#I3Y%cU}0Gup1=sb|b-)RW2)v}dgJh8LQ75T5k4+g$B+zfXNJ_HB%PMma?o z+aZYPuUllEo+&9$z{-AziaLK_|&dCD89;`nA8>ruiQSrD>Uo{z_t7`0Ak*=2j#9hfY_Xg9X0>~{-bI!4kWKc2HWyfMRFc~5f*mp>ea<1; zwHzI*waQ$8j}l%jdWz&zl*RPcG;}u_dN>W;TdSdKTw-y2#VL}B&5S6X^iENDeX_kt z_>gtVY^7s2jF*zt;eB|ORKQ8d)|JS<*7*dP zT6APsRZ@n{_jR^84FbBAqF2Fj2#4d~tvC*0Wbt<*ym|%U)r|$A2j;vGZ)4T83 ztZ<|mK&5n+ImqXDM<8C6F7kger(ER~PRV*>-!};iDxt8OKPg2OIw!P9<0fvLPmnz@ zuBIJ5X*yMRrj655pT!*#-$nQP^iA8o9mwp41%s#J3Z@0j?sj*?jZArTWXfYHQyw-3 zaZrrvjmUyb8vmyd)-%AWNVbeD9%=2RlSK+jMXs-1BR=-?F^-SSQdPuny^+?|nNxse zwL$oIlNhiCW7c}ux*sV211hH+vl=6rLkA?+SW;zvqe1oo8H4Md)#1BUkDk)AZU+WT zE_k9Yc%m+5e9)P?Fzw(%U+Th)qRW4m5ad5d=+&eqy&*PaO!akU>Z`j>e7~RZof6F% zjpmf-@Og}uRSt{&&JlXud9ql?o-{9DMLs%77uti_!%cvIyTFQE!z5EPl|Z!R${rNrxz3VdKcsJbgvBCc9Pg_<;z|f zdKc3rb}R4{^s4Ok%7_Djn_7tl2=Ncx){1|yq)?8EPxaUq#YZX$j_UP>OS)+a*BC!D zrR>Qp<7s9YgG1x03Vdr1Pk<*+z-gX^}PdcEl9a*zm~m%EA>D}($Zzfqh0n*(1Wv($6(aD~}svaQ(mN9Jevd&FP|v zLh=%;@Q#qYIb7`63`Zt6t0X%9F~_SU=MtVZ7YeVQFVxbG>-xqlOdEmWht{%a<80?_}ua{skw*qJ~>mDT@=Gtt(-GN_0m$n7jtZU#0pWi@XMIH5<-A`KlE+ z`XZM70te<2fowa7&*+zSN?F!)Wj1TL-ZLH&t@T~nVOs?IH~5~VIUCC*`IF|W_9jW) zDFn%=UW&2fxy~mD5aTW{MQ_GQXBj80#w&7SHP+8ntng?%R)}Np9L_jdyjOu_h3g$K zDV2S722Ao;t88}T?h--+O+8~KI}9FVM!>*~UPEtSs3xX@bi6me8SCmcv(}WTfJ$8s zMF$k<^14B-4o-hJsMS7vsnDoge-9AW)mOESLClQxML%rf2s69fg)IHF*n9ZJ%Le)s#puOK%=Iim{DbZJKnc-$8 ztvuXHTDf;GrlYnp%h-#-^fqQ0T~%Ne4}hFNwj9(QNlAOj!2(S7%OQEWw4!ya>{+{c z9?M0SQ-O=n?Awu3?;=tgNR zSbHbduB^hTF7qzm$-BJ2*1Mc5f4i8lJajg6_#atHg}Hj8#&V^eQNQI9MNyxZb||6w<#l!{n7dhz%KA`S4aZi0=~3s43UZ#oPVk zJBsIG&RLh^Au~?Gq{0>5i7V=kD;l9(QQf3%6(rTSx4x4e;zaK#Eypc^!Am&s!Pu>!c3p9Xk^Dt}g6IpwI#@hRR z77(sB!Q5=rsp6^jE|5~@YlE8gqMD%I|I`AyYt{z;f8?6bZ__^+Cz8v2@A~A|Rg-V~ zCl5@1HZtk#z~omEe_c<0SvvV?^Q3$JuMQ+X+%+)y?i1l%y}p3zF0m)4Rxll7 zd+etRD@%OapiV85|8Y5fvPC7+QMT2Nmt9#Rs=*6OlQAyeoorFrbcF3^$9t|Qakaro zOOr2McAacd#qdXBbMmggZ)B2aJ(r1A6wRM%P_Gt)xQYW_<%H>(XElA!-P_N1&`62Z~f_l{x z>XkE67o;9SrCJQ)${gxdD*;uRLcO{WB+^~jRgIB46?^$ZquobEi$JT32KA~Z)T;ob zsz^|;7K6BQLo!8zdUau;NDHFN)=HcfZvLA95($%K=l#=)j;7~U4e5oK{!`6>I>)UH#k?{3Fqo_I9Ksh>Mxa+QEBu?Ay>QH z7P8gvrG;}Fk%7{Exou z0r{o~Xb!+D0aacKk42t^8!bidE%JvzI6?)&0b8UVq>*>7cO@z=5TJu*Oi!7>KKM zP_1TF>IPr={n7400medHX+yP6w}23(s8`SL7v3GIAL2^8*322#Y7F`>|3+>;WSpz8 zQ98?)(qf5ad~ud9_2tW#u@#3#m8lBm$_w666zr8gkWm(0bN7a9WhR81$nwPlEapG< zQZ%c5(5w#kQ}8PrpjIQxOO?>e3V!uU!LJIn$`Rs98-(S8?X#y|J-^gscVw3ED)1&b z1z|~RP0zE+Rx%%W(nmeIwisQ}PyPlzF zRzE44m8XJV*(vx{1>jdBOE#Y8x$d%pUrki-s~`Upf4TbzIgA40Gz5tA1wfq3(*ayr z0Jyr_E>K`qH2ZI9_M>R_H-468f4XT?dAzbkS(*7qeNW%6lZK^Dy`lk>!Ey!YBQk=i z3c{<&ZKdZOJEn9%I*3@{cXZIHpta>O4C|ZbCPUQoqDW!s5Lf*4RB6L?6Z?6d8>$wR z&wHTAE@^WGr9ahXA0_VDoYKu!q}kH}zhOx_@dftL-SR%kjR!y5Q`h0r&R)-5&-t5p z?3}x=y2+OvwmG?($IcFukJtgUe)`_=FzRMgzX;od^Vh{ z>)q-KK(C{ZV7Ttq+ZVPw;qh{TXpNiDWyetKCWkj)%6l+YI>=Tk1nWWK-9Z6G!=22Y9Z>x3U@!$%l-OfYES`Q(s6NIdp5VGn) z$Z8@D^-BnoSKd4=DVQu%c_y@9$~+Sp&}g5ARgLX)M&S@;NcQ(S2w83A47*m!83u3x z<+ULK3L!K!oE}}FSVPMI`Rt8&sRm6hJJk9$* zw=F;V;Dh7tweNg?+P(JO?+-+DjhRu^cU@TVk-qEJ759&x5o|Lls!+A~;e$E`7ZO5F zT&$3HrU`jxJ~*WH!dtQvh>klD9Y9GnVC!tZHqa-iiIki~_MlEJ`Ep3U)LisrBao_> zfj2#ZPu6$q>=lwkvFOJX3j|5gSrrRY3{b^l6i-r2>?RB<#fkC<5499h71XT(V5zc$ zW*xaG|1uJw762>T{+4x5Sett7nI2{9Nij$jhbz?^b*xfVak5f}i29N%n8L{wsj8hE zDV+p^>oBKMM6N8LSs{ahmdLMd`CvjD}C09R9B>bFj-k6w{p+Kg0qy4 zuVqL~7RH|LR`uejgF2gg&5(_bo!fbBnIF5zP3T)5!SSC|&O$N;PE~*kpsI>e9dK2x zh4Rk@`DHESP==_~g-Z;QvpnXUO}PSNNhLU=iJb8aKhBPys;BhXrN0JR{ZT@QI@^S( zv;3wkQ`yKw_Dm9vZb|OH{dlK!`(-_{;TeVUcU%{E=6|$uT%wpuT}F`JZW0&=ljCxn z9GCfoWml@`xbDW8D@?WSW`$}n`G{}UOeChO%vqTv{>e_TP7fuQc&n4dblD=EL3%8b zRa23=BV9szN-d<(NY{X6J$I2>%_M*;5PsGzq?aOXMcRXOAL%u5NoXBr8(iyCb>om6)zxb^8{OuxBFZG|{mcqq*3^QgRiga@JT6-)M}jb}p1n3}s8S zz8H2NbLi=}2Vr4Z*Ipt_51Ro@$jt`rVsh8A8IwK?zJ6ic+;f(lQ_rYl=UUs~a`kK^-tfTes+QHSXYzupf={|uX~A#u=6oS%lIGyS98Xu*xJ~H zEY2v24y#E*zp3)k^)5c`%?5qjh!5%|@j=aqm?G6ej~%}ylQ6OSy+dhZCPRpsv?FHH zdjQdThe&krBhldzE6}$><4*5g??fB-R&Cr#XB!8Hr(#T;!!IxG>rJ|OhPZp#P>{X* zR3110E4v-Fa|XytfoZ)`$@U!St%JLA49H61YU$Y5T}jymcNsGi{d|H%Q2OYMpge@F z2-Lbq*25(N0Jb}aOT@(PpTTkYwRu}swuS^r(Be_Vj=OL^QJ966Wc%Ryp z+~!SZ$e*B zcCbCyU6PA1nv~OA5fTxHRKl<{qgoQs<3P@ez=Km58)-2QDU2*d4$hGApc5RN64XVX z-kGSPl_Xm@j1`0X7W=PdhvZS(d|qyop2K7HWms5_p_5U!EmUXB(ywq1KPq8Y#P_(X z_#OavaXQn;+{OM9E#G_J`i5!k{fOa~&asoXWHfGdElWO=d2v1n!Z)wW2i>^2Aw8DV zWDjzghSR!?Cef+<$r)Apg;5heQnNc2dV#Ux#aV?HrxT%)e)Oe}hTs;(@ZzkI?!_r^ zB%nOLT6r!yhfFG{t8#f6L~CB!s%`gRkZvkHo7&vZIL?ak9g@^D(lH&RY1`1Wi{mI6 zSSk>GWQuqsxq)QSP~XfkWzmuU1IdcMhU=o808ZM&;gp0Ay~$WHFYjvt?HJcY{IbNjJyhz=~NRtnLPg-@x6es8K z>yp*-hJUE#8>LNiNzHu0nX}umxi)DYvsIdh-o=Sq#;*5L9u^tqhqLgKu5+UfkZ8j# z-{RVn!O9Z4)6`sa`t)8%#?M99&J4fEMdV%@`gCL8Zk2I+GR4Vis7c`;FVQE86tz2(z z{`UVkmW!y&OXcnMDd(xl>9KMfR<5S3J_nnk1#H&o6Um@T$fH`z2jORBPRn}@%LhkT zKA6n%!7G*zp0a$9pk}O|FltL+)D~AH?Wm0g^MrerYp2F&j))G|C#Sv%ZWI&X#!G-# z7%O~}j9sd?*dc;Z6|CsC@~jg5Jl8liu1FRSxtAu2ohR-p*(mq z%E+PTv7BMHS62U+)xPHjc3E7xt}Oi%uHGQEYV)AA;ryw~CyHc6g0S~6+TSor36vm+ zX0*1NoVuaOV9T-}mlSfD_x{>WJA-N|08ko|X)!`it zyEKyJ;afA^w3wG?NHIPbF@;$1;loD-J{T{BIP#J5?wlf&EE9Q)R>H6uAd|H22$p;+ zt5rgon%by)SNC_ha>CB`+u_b^!Y zWUzdi!E!KzWow$bCKy1b#Kh-$vzbzAhO%@6>HQ)ZWTko~8b`(WUPyY1LqQs>*8kw$K|D9MABlU%2xzYDr3Z}FVsxrzwePH@dt^;<%CwANHS z7@c#tGezOvRO=hTWv?T4pX-RfH;fQA`F|F#r}5NqHwIX zyj6|AyGb5#fGxTDoF0pxotY02qC%do5`PiF$ksROc}5jbwOpqotXUk?x6` zFfH4LmhH~CEuts>(H6{Y-~{=12oFx@nb0RQkTf_rYj5g$3A0l%uGn=4p=|v~2R}eM z_y{H*t};@NC?o?U&2o{7ks7Y^#hGz}%Q;+7Y5TQ+XcOtipJD9#yupmRe3BJoH^#7e z>PB2EDZ_JAoqcf@R}u61c}Yup6h%vNQ$#FcY`lrFIm?2 z){44boqfEQcz$`~_{tN1NB*+1_JhcQzUw1RtNKp2pD64o&xWg?5ASUM<&D!Thx{E` z)pz|5ruBWRr(GV@Y%p3gdO)sL4RQv^f+5mh zty^d+4P<8#d?FPYCo3m817vXz%48Qk7aI4h{yr7m)L5EW1S|Klb8{x^MrLY)YYC3= zRvhDAIL6y>j9qbzw=)gmwvTahJhNVADJ%X$cW=m}KsYqPHk$QeUPxPcmi0qrWgB|6 zm0^ZqY8eiKmF=#Ix$!AdfLdxN!Et&oA_xF@V%lkt@Y5J^Dc0VJwfkf3@38hbwTO_i zt07MCIGo@Ft%!I`;YhFb|GaOKhcque(ZSWCuSvvL*0W9#EZ7lkr4U&^WR1v50}c)Z zk@XW^(R?#8Y9%6V92zlTW;XkF9<7u}rb(Jrmrjh_XP>M^V7OAphRPNXk=MqhfLzVvEE?7@a~ zzJFnlDk*QyZaaqPIpvXp)FQGnBPTjFsEg%NqdF=^+=pGV$Wpg`k1@`shv#M|J@S9O zCOOeR@%qsh&HWSqx_xAzHYMx2P_ph_-sPXzJo%@D>&YR>$w#{+e3E>-%bcR+lV1KUN9%3 zlK`*|m^ZU2eBjveA8)um|8|+X$kD?EoOQ4=T&!dMo{{lor22i)FZPF*RZ;Y3Qa#@G z*pEF|m-wHt)Iu=*r!Fm&~X^ks?Y&z-A)GMEb#N==AePD$JFSh7~$tn)(>fwT+)hr5E z3vb<_Mc7x1%T9ACTBnXlNV)Fa-?MEP8d}z4LVM>1C(14g9KCR8b&EnD^=NbID`C7? z3fDn6N%q|Z2QhDP&7go97AHfefXS+QM0i-ropQeA^+#O? zo(eOG|6+!sbaij;DI~7aZbHE5B&e&e0b<<*h~+4#t5~pEkw{OFnjwMBDhLp(5J0S! zNMN&CBbgz!MFN}k_2LRgTX^#m7Yh(8Y~uy_i7>K!U}UXC+9Xm@E0Jb{x(XH4RoE7L zsRbizE7EqPZ6Xx~h;<5SFVYTbA;lvdLfSk04Uh+_h7J}FKPoH!&uV^aEq?3YaV2xf z>auIvF4B6`I=Sn0<*v`g1RLZ_6Zzrv^A!eC0?JrfP zRjDrskrrnmX00t!;tlJI+h77*Bo+Uatpp8bF157jS?Q!3J^qR;(+(3U{1T)lb7^RO z+P;;PE9};!n%ltNRX7bh#};sm3zwfg=}WtobO5`fko040`F1&bs!_*E7_q&;k7`Np z`OVqljXQ=G5d@ZPtf?TdLhddSVpi1SC?RHfO&B7?EW4%+g_spmrJ@kCT+Tww3M(>e z+kuT&{rEcf+YExGweV(znHN$5QcFsnUe1Ylm7_JpBGS``{fA%=)dB<_nul%krPV zLz*Fd@6N|w-NGYzAR5a9@h$S3ck7q%3xOY*d{NfRGigsuVQ~JQyROZLa?|ir3@xH^J8f87BpJp z;jeDeTRG5dIxoC?+&(y5(4zs~yjaijVqMLP)rlADm*b?l{ar#D=WbrwCSvx2Ayedk zY3->tm%lf_xbwug_i4#IBLVUyg^pF8&K@9ED>=iixv;JrEz`a7Gy%4URCDG>bFRH~H}!t8ftpmWp`DFzTU`Sg^rq+k+20ZT=YZp9K+J z&&^mG(e?Zc!Cb8`-uza}PUWxNYT2rM((>Z<`afS*yv2oIB7?1q3+rglCIK6n2-v97 zU140c7RHsgV6Y<22?lG45OUhem!f?RAH85XUP^w*)ak;Pm_qxUtKS1mW&6b9^hxWW zfqPa)*(Opn{fuHEOH@@XNzwFkR5PVge7QkrQmNFd`p~Q3XC2lDe>Hhqr$D#skfK0Q zc^-6eUFc>R4;K}@8b#ee)+2F61J$bfN z8$0$#CoxIYgP%2W^BnWs+DmlUqZJdj**(fYsJ8DfVhrKFV@iu+6eg zu9f?LykdI+v3mk`Zy^V0CpLA!rXSzi75~Y_mLl~Q$(+Bpl`lL1&I0=B0T8Jt>>o2| zLv7wj7mykvbwYwkWHhOjoG}&vkv$htl8Z2ww3jp1|PhU_l^;}@5I>sG4^*D zdmP42z}N-Dn+eQHXLEOkQZ-+gRhw!E!RjtNE5|G(!;`Ht0cow~5^HgZC*=|+aEZo} z%(*FrIU{T@Z!SDcz`M|++ymwYoLE zp*<_r;_{f57OVcl%9MuXzl^}F1_WjeCNS%G`Xz`lEq`3Ko4~BW1ZEvio5n9e0T!zz zplY7CtSJ5=dBMH>B*w}UX%*5PqzNKzMB0IrfHYC0n@ESfWo`dKNLRaFlPu*}Yb3lW z8tF08WRX0PenonYG)1J1NPi-|M)DWwCQ>3&zU3lK6Eiz81-1ok*RK$|B7W$rGtR(uYVhITq4zq)JG$ zI2O`mq-sdta4gb5<_(c$&6<7XA_62&!;{qVRY< z{p}>40$uqVM7OXgZKxHB;rtMz<&mdGVzD@-BagiE^2vfTyUeP?NLC%L5vz5W7`%x( zWAJ3hE2&=})Bh-@Wj%icUv$z~Qs`K0I_;-6oj$?xVK<_LHehUHElT`9z5=n;Y!%Ox zApiQNu6guNp;r+IH-MA(chQ%oFsumB(kop>0<;d6 zk;>D{Kc(ol+id&G^bxGi` z;5(!gH+uK*5d`x5O7DIU%a2WKdC4A@0IjA3{+LULZj-im=jEGiGDx~a@61v&w9~=! zs8&7R*l(X9zK=dMr^m`oI(WJSbhXdmfwcL)5!iu@z$#(~JHD98mjUucR`@0LWFnS4 zp+2N1_XZ&8U7ONoN~AD&51}-KQZ;ryET%I~h!;k;oF}Jexwl|WlR9!3I8~Tvvj5dv z7cz9LpfWsEPT?mygC5-_8b_Ozq3BqEa~{FU(SqV^f@IejlHJN;(wZHXFjlKh_*Wb=`ZSWtaK4lMv$^}H6)T< zfW8E^r)*uQI~nXvBEO_<@A7H$g-!@k#<5d-Az$vOO<0y)IX;5m(@+HpFK!z$zlmI*hg*#vt92i_nT+GH6PN4v)cT5@Vz>bWHte z$K~m(3@jB|J~^@bjyn^uTnja=4(ke~l@6arXVR zb4(ed*Hb%k$sW9OjUdZu;z*Icq-oi_3{mM0CDrjy^e^fd z6l+Tpw}}U!lE~kXt1>CWKR;SKpb?Iy6IDaqaM z>3)ySp{9=+g5 zPQNC)`b|TZL=Dituh^13l?F@#y8QBP>-pstIVwKYYjbyXI&PFEo!^)&Ub?Mf@?dY4 zxy(!xIr20g<9tHLed`?wZI>zK?2`CfF=xIJ~{ zwK-S52>w@Gmp`SH#qz;QjO~E2?G#MQhIh6*Vgz&!U+5gSNlZGEH_nJXRE$)|#=u$Q zSsi`{KPXH8#2^bMoKcsbp`cWK$ZEL4+^^b@<_dQBP^Yy6nVkAjZ#;)geEkicqaS(Q z2N)@jU^@FM)7cRWB8PJ~47{FV)GYEp`9Yd9jxl<^M(P;@m~N_lQ~F9fGd`Gkuy|$MVJNr}#n6Ob@W%ge0Vt8{PuMD`~I>TGiv_0o9m+bCan{!f( zQ*0?nQ*WK&Eza4V7C2|c@zeA!CS;Ad(l|-dEE6|om)Pw|4||#(Hdrzc#S(j1qxED# z{xl2n!6YMEGkkIzC+$6)5wd3ZB$)OoTeLH~HNNrYIJKDxY%;ZGlmW%d>#7$Id@6#9 zp516tZa`IegvM&f&we}TmAE*<^ev~$Bh8q`9|+QYIa5#jSuYyKdQn_C%vq1sf`0S? z`x!qCXZ-XF&3(UOWHr(Wa$xwFE8m7R%y;CX6kr^a^JR}*YzUp*2} zcM9{3ppI5%JT2-}-f!x)r9Lg{e!?vsa>L zSAGGPp9fye+xr-84eXq7`0QPn9M&QlK|-xA>V#gMPmqDF;_==FA9+US0-a_~S^96; zJVnJ@{UA?66Q&m#T=V{}C0`ElXv~xO2|{fmQuZc$7Es;M;%JT0yu^H-43FJi_REhNOB5#){-hJtNJvHlqX!nx(-PPQ(=wG>Te4 z2%#m}F;4booP3sX@@mG(PHF+6k=Xf>;$%pxmBk^gVNxX~5_L{+rBuF}=?a1xHNPVa zFB3ZlHOm;r5AHI+l1SP>u~|$vJ+3JOsPx=~L92QN|0kfTZ}sD*BYoE&Gxd)SDAQ$9 zRMGPZo_)J5x%lOc0}e621=ROl|D&mYR6waNhoS;>t`~_nBqLv~u$mFHc!DO=kB(JD z6`@Gt2w1ffpJ40g92FDvW&rCTTxm>TQ? zb`IUj@^CMPYbo(sJPH{cV|JO#a;+pC2a9Hxr^_dFmle1O#wS~|I=p^s9EPdIb@k;^ zbGlyQ94-#d&rB+1m{!(IJZZ*Gp>eW?@F!RtP3Wo(M(mHZzr)(&uyz90j#JjIK{!=> zU%oTx6<$286U;#O?VK8ovrr7bkU*!mc02SsQjUES9-th?Ze_NxqF*@IH2aC$TV$xL4f@9mS{)u87+iFssRIm29F7s+xyo@<3wj(urdkAA0rn zky+^$L-Yq|?bQ*|wNOPRY95;1` z^?k%ff59ldH+_r|pjQU>L3FLm@Y~)|IG4g~IfqO4I+4Eg8GY$}`qHa)v2&*RCTgx} zvVKz@vIGoIi&uDnbm8?Gz`Y5qszS>$zE{E-4H~zVmA9j!J`KKb@@d_dXOsW-PkNU8 z#6S5~^6Mu@*Stzfy6pe_K=R)MlYcpyxYR!}smrc`N2es-OMcPVD>>=x>*VCggN_Ru ztFOzq&jo7rBv_zUc31tA_Ffs5C}b<&;YmWh+VZDVn7j9tRG2(d{`S1Icj+%a7+mqU z-vf1uiY|0(@{`il7RG;KNY{XX!=EVF7+{z@WZVlI^QhjVK zpjT4;;;-mM1bVeJzfIUfk7IM3oy_ysn7K561Izm!Q|H!cV*c^qJ)H}mTNW0SzoF$F zkE!#vIGF#>;O?CZ|F&#?(6mo1Z+NtrU*{9^WrH7fDtu?zxS(l{mRCKF&EL|<{M*5S zoeDo#HXvx4ljS9k77OY$G`}*~wo~Ef%i0D_Yi4=QxtLB!c z{`hS{9b1RzgGVEk3yMv?^-bc<-xh57ShO-|Nr6)B2-WI~w5Ov;w~)RSX-hqkx+9%I z+CwdCksfvsX+P3-YFUXCh_o6htgO_kQ|S3%+Yb4Ymd)%wwYlY5k+#$l>AbT@BaoJt zeLQRUAb-(Dqq(9jrdmyr${;mEn$N*%h_t7@NR~+7Q0pU+rZnoY@^O(fUQ>mSP+a&3 zA-@S9q3~(pBYY5i;mfElo~Ndl`o=uiqVoGqtm`^fo7v}*r1I|`wz>Z|7Qyv|pJ3g@ z@w3qi$FbPo#iUMyd?6Oy3)of;4Smm}LwjfQ6MGj1wp_U7Ba4mIVq0~X{b|@Yix+?8 zVp^xpdm&cctAK2X$sgW2@MP$sKo8sDp@M{{RL9x!No@H*=fnpyJi0fZC?Ki@1KL|Y z2}1e}X*^PYk$NDVL-Iv(Z*Tc5zLMkG0ZA>2TrgRGcj|=5Is(1=bc0F!r_IK+NW8M9 z)aEtY&gXv;RPN>KSueXcs@!#8-B5u<2rR1({HzngV;La`D$A7@Y6jJ*B?zkX&O)Uc zhqPLxEl3ZMrXa1QR&9~Wz^wn+1lLN7coL@5 ziqsXUXNAC%HJ8lvu=2Zhhz*?lFG)C z{&RNlk7Z1fnz>px0LN31O9a+b224g)sH!}v^qAk;l;67G?1=X}CUBP~a0#g(tZbz< zcO9yyBaBs)yM7ho$){ohQ~Bb=mp1Zc+;Qa~uP0HKrugi@)Pm{{;u_rP04fVX=7 z*+;u0r>(XY@=c2c#ibTeW?goM-&0;GYD8>SI=ru zl79TE57tbm75oV-q`BO)EZJE4*K*-lIR#byr-oa!f<9UDBXfn!;vYk}VK87qFtJy* z(!>d_``vD|5F@sOenam$X~4H`)ti0{(rWdGAgvaZ0BPl|2w1HY0c(pQU|mrJtPzTU z^@;o8dN+a6l@{B(+d{Sa1FBUWC}`bj-ZKUSisielLGyI%2o!66sb!6y6_ith zaMH!DO2t_niTYlV>^!AUN)N-*mb4L6I;d1{Cz)Lr3 zJZ}{tO10%C(%lWymSSGz6FAkK8B^simBm0;3rO=#p!ue?d}N69y*Bi{8ynAAZqXLj zl{^rUt3-bDZjB6*F9W2`qHA5hsBn7buFYm0ul`*b>eb=UOZLI5u5}l=^R6uo=Xq{= zrU+PbAYkz{j^k-u#RCeAFE1qrdIyEHGP%CSCiqJpno8V)R1lWIq>eD2oH?11p;xuA zxU*P%bPAD5##9}hc(H!Ti}mkew7fW4UO0#|@3e@s>L(r#u5j7`A9%cMFz@Ce1vZp^qAF+bcCwBhY5jisEMd zpEoG)bMQf<@)Zs~xa>aU?)S&t^R2&Tx!=PLmQGVxS9gSI)LxiIwO}5_3T|hH5O#J7 zVaHb3JI=@A6E`-BK>kW(OR3`rl4p*5DdRR!KvBV4>brIJ3V9uP(xqAuG7fP*(<~&Xo>t< zRUATbiz*JIcvltwhhm+^)Ey(mO9QzFFt+rCUj2K!MLK@#_Sae0i&@Qm9Lgh<&`Em%W!?J4f@x2X>otMS} zxLOO~%2~wkW&^mw*a;XrP8s_i#x5_$uDR?TK?iy2b$SstmlV9q=y5W|>JK zpWX%Z>M@ttluPWwC4yBmmUO0toY4-fS_v+~L@q*4DW6wj(#Do&K9&gAQ^HMflLg*C zN6VD-GNIyl$^vgE7I;?_S>5$_7n!Vn6l!X9w}e(|_i<9v=97|EsW__-!D{t^7!egu zzk8jj)&03-Csk^~pNXrEV}_Gxq4i!?f6tX!PA6H5sD4)VM@dE(LvTC ztW4`kEu@x6-I4yAajuwDx)&fc>0rIZAm$RXA^Z#pr}oszKsrQ72N8CcG4@W3?d}{d zIS@OT4tH16;g_)caP0mw`Dq4Ok1!O^D!WYv-|3DUtbnB3PF$rA9wrcOB35}u+~a-X z9?%d+jXRj99TXgF0GbZ1Aou}RZ zVN2Ki3qEYv<*lb;gA}EScVGr4 z7Fpn}qni;x^xsMXv65&Xt<}L>1WiT}G#OG}tZY|bR-C;Du;P4(j=^E*Q`;T2&ywm8 zLZ+zQUn#vpns6Rsd(!Ydo@`X_fs8wpb_=i127a2naN&cg6puq>d+1+G;)b# z+sk@Z(}AA23{fLA_8e^Zmo6NN9xyX$w*4#D9h-l~ zRv91+n)n_^n(K{|$uJlfFX};BL zEbr3>B+qZ@;*I6`u}9o|6h^*|C9lCf{Gh^Sw#lcr3fqm)?+IDIMKT* zWG^?tPWnYQ8KxEn%XQks+x;W&^sJM?c^*=0wGWqEh*#M%d_c>m7VK5fQlz$7UI zK>9(_nR$|TA|By1X*oswQsuQ6*&j*ufCSH^e3C`DC;AsN8yIWG%7aPS zd(bS|@3SkB2!8^Mt=`3O5+$<9c+hr~WW(5;QnHd7?buwK5M4Jybi)-|GzN!hJ(FI{ zcxY0aQl>wWlDcQ&5vO;F6e^3mD7p7-0!YJOoTH-t41ibcs($1RDoc7%jYE>^qh!mn z%FO%7gMXxV_n|A#){)4*mUDRhi?ibyRK3BIWt?}qMoR>)QgZ0ijeWZX(cHsm?wx4v zD`@VGXzs)4+~ern!|yVRj+KTj12IWX_DVZW)+8|E;`wCjkT6D3wfgdtbDHPzRt`z( z8Q)x;f0Xr<|D6P1gAuYaOGID9 z=`3cg)6?O>XAJ(_kun)U&j z_6V$GU_zEUypHWfj3rg(Hx}U$o+eFf43C|$q;A#83G9F`>VhvS`w+0fPlw-NEXinYi4I2y(!sA-Jll1S zx2y%0{mv0)o8HhhUZ{<1PSSVwpzqwo{BalNkJm7N+)RPBHqoJWVPBOsI%gC$Bc+;P z+?(p$L`N-yrJ)5&DzvTQ_p1Fx^e!eSKSXbk>;M){l(PcTH$ysj2>jk93gxSJF8``07y*Yc zR1UO%)o{mVYu>1CuKbC-QSUgOiak64o;(1jwH|=bxWATWvSOH)8O(Cgf0s&9Jrm`u zWJTFEpl8BhK6{@dFZ~zoV`+Sa3XGz1wSq#jV7GAW`eytTk)BMKcApJ_DUmc9PSU9N z3e3G9&uBQF(Jy#L`;}+JL`WR(@^A~-@%!lAE74!1oz7O%%(>a2q_Vuwx~1DM#8?u2 z>=XLfrkrtsyj3q4OUkKNG1bdIsr!y0AL6IbXqkb?5Tld2HhWIE?lW~ZZeJSr?PXYd zH`X4EwU5u1Su6WXVq@Q7{8<4`cQYk9m}xH_)VEtN(SUd}h3E3nr>>XK7%lT!%GNW{ z%YDgtr7RatETfZzdo@BiDhzBRbWS#DOfBU?W5WEv;m>Xu>jWU!JKfmsZ}Y*8hS?Fg1C!gP~JDhE4|< zI*nkUe3fa32+$h7_tH)~q+qf@%<8p-An{bgwIVH_u{L-gV_)Uw8g&iDz+qci9-c`G zBW{1#8st@NwSu6!QZ-Hrrz`cQD?Q7Lb2TqcC$)mWi}R7-9As5Mw-=njD@v(+Khq@y zwSJ-ltZOXkE&UA~*jz`28F=NS74t_EbZz*!`;67;2ayXL7X2P@z@gi30Rw&4N19gk zoo+u-2JD^!^Sq#t_G?_MrD#P9yOYlm1 zDX&EDVs7`=&|X9M@5Y0htw0xVEx_W9-oqBtwe@K@xON_U)jTvbZ&)hRrnUU)!T>D+tKxo@L$ccpXRPUr5X zxJmJHw3KNpwc^iGpw^Nhvluzx|K<^m_afun93JZeb4_`G@ul_V^jJCFu8_OBkKb5N z?K)TyM-XOkm1AY;vn@Vu4*T7RsD&pYH~h779Dot z1oy`Y{!YsY<^tZ%voWeSqV50Wdf6in{!!95TdWmGE|%Tgv*SyK z-8}=Ly8onevq_DyS7K}jjQ!tj2bthpNsP1uG19&&M*0FzfI)nebSoq|cQJAaReJ}K zT$)H?ZnvbhIL3%{T-h0cR}%O#QlCpfnBwjIQmn$CM1DHETv8D!VevQA9|Pt`iXPI z9?u{}-%nXT;9vA!KY+red;P$e>m=z`W{e!lr8(UyUO%Z}Rt8!wDZJxO^W@{nFRmwF zPEK5r{OEG>l>4u44@~~g^`ztei6fJr4orIT%zr}Slgk5>U-~D_i#wWZmz?as=E|rf z0b-fj0K__cv$_AzC7!KmUawKVBz+H_5%kh-nMv{J2ASSrPA5Ex+Oyk;gQFi#0X*)HfF`o`2it*P>O+ zZ~G2jR%3Lje$jL4oGnh~4+fR#()QRl|M6@wH=v1mwZW%47mixCJt)6@*jT{sbK$GY76;}3B@$(f|28!m6wuEXHQq78L zt&tW`4MNr_2wB!h0o1B4k`K~xuh~IK$Kpyn5Vp~@#+5%dopfjFmCr(A@;CTCu)+er zo?+H^rY`&3P3R3j>{)Lz=o`;Y0!ukP^XD0T1}UV&o((3J2cCf8c(`C_HH*U4!drJ} z5%$&MveR6O)~RC>Qm%XV_iP)6hL-i1(B8ShiL#3VM=u;&-J;M(J=&c5N+1uGDZ~}~ z?m{q`x433dKn;tNp;aae_UfzpHG?K32n4J2;e{^oiv)?)^g&D8Eyn?5{Y$7;RmM`u zMk+;7DPp0^{Y}1iroQ~Uh>)`0?^NVM-OfVFDp{d&*ZL3FnZ$qY@3^)~?~Nw$i!wm6 zCM@OvFke<&s2Nlg7}hCZSYrfp6}C#G0Hk=NNl0s`1q`bgFs!eU)=>+|3TZCV25Qx5 zIAz)yU@>)oVRaN3mMMI!3-GZVkh&oC6satjD`zlQJp^-Q3LmQ{k{eQQB=}g1k%l7m zLxPWW0m%<(AQF76vhcA2kOmKJ^m4*Jw;P>>m+^P;YhD45%@i0bP=T?ch3GKz$Q=P= zwHo*YFxFoa0Ano$jCJ=H;b`rBJXWgzJX=^w`x^??V^~FDZd}<9DeccYQ~eHY0ncF~ zc#cXSTw0f&yv(97^qyGZdCU;&?vw|k!FdHjON+*G7D!587%b(gwy;eFXgMOy2cT6$ zuKX@26=O)HsxC0=nDFs5bC(}7fvbM2e@w%bnl%2aJ~v=**@E;a0p-I4 z%15@+4=#Uw&_EkZb`?+xhA%B9S;iM<`BGoLd>LDDXbL~&6EE0EQSejxoD)LJqHFHn z6;8MR%S_lfk>!gASj>OyB_yo26ZQ!StH$AeLc&@!z(y{p{mAlCCG;}jtn;q`XWcE- z>MiJ1dZMbHUuv>DGS^J1O#ab=d!0ix+JhzAQ|N9`z;bf{p6=|aSUg~TjVoPz-AJU{Y3;jJfp4*KeF14vl|%pqm{rAS#z6)CHqB4zDUq^xU-lr`$xm-`m4 zkoGC`KB{~{6eo(6P@2cS`XuNc~j;he|+&JLd!LTx8ZT&b_OyZf7k8 zy<$ui87^b00B^=rXJ<-VTMc>CsR>}KRP>}Y_ktl)Tn0PvqFu?O&{C}5Tde;fU)su- z@pS4u3a#bKr(soN`<$60*1v}JAvX1HD`(iXQqC}d3or&8OT*r}${CFc$4Wh;(coD8 zMup=tv6aD-Ulp<7GEejV&uz<(KKS6cd+j^lpLVZ(_xl48U1Mfc^<5WMe5CKXb;Xa~ zYT2=Tvs(q;f6{2T#pwyakX;)`)^+~nz|S>9p6n3DRESNGnMZI@JGW20LTo8It70RH0jlUo@uVs?Q+4g7 zZX#EpPOe~G(5li&aJckBWx4D=*+G8oitTbc!YQ^^#eEb#RPg}CuT?REVkpHa!uZ;* zP7bH589z!`G72Di|*NyJrGU+BO$9mIFYnVgRw00K_T~K1HZkK74P;cb~h$ zOu85&aHXwam`uQ=L0)PtI4r)%3I3sE=}+9sH4;n5KN^yfbs5T;0&6vX!$T`f`+oz) z%ONG}-GHhT8Y@?zs$3JUwEwXNXsq_ovbbM!p=IeQEqn58pw%C9g-)&#p%J<6;igeTh-Os`%v1bTL(`jMOj_E-IGb`Evzo~V0Cd5 ztBajWuIf6<+lN12AWmpY+BhMZ>nj7T>L+Mb4~15>)k*RCd7*=#JTW=~%hyx`)wMuMmAQ)!A+Iz^?IRBA4j z{-#orRJuu}Bq~jnO2xWLr2?#Mw2(?4u*pjSNf7Z|E0sz~f{594snh|MRapU7Z3UGz z8!na)QY9o%S;c^0%|@z;1S)Gb(pDsEBv4t!fMA_MvPS}yH5(}&$q5NmR$>+ct!^Ys5!YDWJIvD1#7sgrs9&E{7Jc?)IU?H_vR9>_il#q7!|g`9 z-hi=-U``{XaTqZ!N_vshFsvAZ@6n+lfd&FU0A`WvqahPscKKwqG|23`Uh1(%Otx}jh!``&~m~11Z-ceYT+D|<<`4+j4 zr^3>jGmhovyj_G-I~8+PPv7^cq!Y$h5lhCA?i+qqdUEf9^yEi)pH61*^oqgLQwC27 z44&eGyo8bUMCZVb#qnGveB?B5gArs&?o}TABaLnz$1;9qxhdln-tYpt)n`w?MZ{c% zWgV9_0?XsYsC>dYWGb0T8`tX9OPGr_OAt6xf>(J73qDl+t^|&p;{iBFPk#=d=p4|7 zJPV$R=2nZxkoPI$cpqk29$vf;*A(xAix7vTFAj-Oq#c|wGk2qd04iPg64UPcCu8QH z)Apsh-lDsF+I*pBcx`)*T^3@cIYC0^BpsU9<>L!Jh|j7{vjx48$N3%a$SF~N3eUoy z-18<_S%;ruI4RW&S?DE0=J{mOS22?&=Hw%H+|ORj{0I!rZH2+vpf%$#^r>w8{hrSE zW`H)dbwX$VkTwP_A>s`!jV5}J{PuwP~TJ3CwOa{$@*-}Xxi^$*5zj!na z+&2>+C_Mq#KY62~;bcq$EXPaKdbAkXtt?}w+Kin(U7k3+Z?|q25QZ=;j^Q=Bp6QP^ znM{8qCT_eGp)lJj>_CrRNE?^vx4wxY^Ew4}LrqPef2xi_M@52JIB zqjL{u8)ENR`h~ERf!I=?HqmL*x-}D=xOh28-Pp%Z&LdYNr^k9n$>a=-pYXG_lPUC+ z)ST7Jw6M_3bND6fUBaCcwf1!Xh=$vW_vtJ`+DkD|u4E;KcA$m(RwDt?elJDEu4JUF zw%C|2ojM?fA&~Yf@NOzhkDXIsFI|0G{!x?YUBOtAK@u{S>y?16U)n}!oKWPnZg|Fl zvMdzclZ7I|h)$I3fNYiz6u5FF{!a+i?U!QKoeam_5hIAE_a&O%8;j&QvDa`39B`+mO z^4{#am?2Y0F+Mu*L3b*f5y=Oz$Ph9;Lmc@aIZ0&@F4lVmL1v~l>g01g!o8J&)5Y1T zeuJ?jqq!wI93k?;4r)9G&7wx$N-Q$`!@FAVb^Q$j%d2lUy&+d=>i)yKO5H-?AKq2n zt+d;mva|l-U5Udm7Kh>OmQixx?%<5->5t^vk;&vAbGrQT5ARAZ4~_$|5-UB|M0F1;fUyPYP15a48L;n5ATXsnxQGYto`YrV*SIr>f7xf z-c{YL9azQMss{z@AKq0SthD4{p`#(4g9^sV4ctn{KjwbX!G`^JzUd#_)PFtD|RFc-fCyG z;H|9pB}#=wyxT zYClD;DzUJEXDt&imrEz}Rfrv9yY{Dot4jQ@vm2uxYFRFrO9}gJty;3iT%QM;ql1jCGIrXXlXLhCG2FrsB zBA1GE(?XBvGyus}q_3BV)C;LQQV))`xWMZM78~>VyR@xy ztZHo6Vsb2`C!r!aB6Sj}bK&{<#RWI zU`6f;6MTYat3O*>?;a+UoI!Ch`GbC$Ah?D0FOJ(UEMv0Jt-3|E*iSpmZV~qN;>FWk zir1-AFr-5F?!|1IhK7FVF}uC9!wLIEfzuamsebcQfisv2!$Dvq73v7^q-}@5laY%8 zJ-RPAB801dL%4b>gsWKtgm85N!qt~TxcVK!)fE9$EjTEZKBdwvD!I3}d=~34rbXg& z6CqrE6J`=`wrNa@!-eOS+Fbs{x%^N5)x2`o1>4T&f6~7AkkB2qz!RfQl{wM6PFQfnkLq_#-i zIM(6{M_YKqP+1HDYa>*wIzq+rfr_;fX%kc|E0Jb*5I95Vd4Ygzv6os_B~N;6McR(E zO{AiAMLLDF7ikBzkm8XJA?>1;wMfM}iWG^o+rHxD!#`V(f=l(h(8%!CFJ~*#)k#IV zx}`{0kA-x#ZkHlmjaQ_r(~5L8Tu4`aUmld|!`lcg;}_UB`(fV<>j(5|+?Zod*De6I znkHn8`9jthwSHE!s4_aC9Mz$UbQH$Od7vMAp+nR|np3)3h(gUMsWMVKYAuplW2j{e zY1V?{vn`%JpR~Qtpe~#o%*$g=-jwSxf@F)KQrK2UzWdaAR5gL~m;+-e44MU?QW_#w zCer6&&%Rk^VS^bqimexkO-Aqq!xxb@<^uX8RKAp#FNf~Vv-b)pEw-#=C${|L7Em1l z+x5B8e&kL&!B{;jCK#(5b7n-AX*VHUk*@key1G^m(p7y$x;mgpSN9a@DzT-It{zVZ zjK$>v5b}gDWG>A>Psx&h%!EhfSzV45!VR&UbZ=Fk8^CI8c|`PtWMNBFvE}JZ{;>>) zE`YJQ^F^tiEye122iI`LM}kC_n*(qbJ1)wFU&AvOm913z@y=o4k=VAgn6rTZZdy+o z_^n&@!yiMsy7nQYt6hq8HC~afIx5oD4n?~9S&^4;*UU5fIN(Ks+{pc-$QwKbsP~Pc1M0C$4{eiO2bLUBU}aY3pJ;6;C6QAx0!mpY%uSpjH&wEkTI1&uNYH#w*q<< z4D_lp(5s1Jxlce?(cGuIG#6GDFWNIa3hU%is4Lc=%a;xErHOoT0)YqGtXk}Xq1LzC zNb?>k$9PVguDb!~RcARveJ)@Q_nS^Nf-AH!tTckdui%U_G8!DgT`-yiUC)o-ScQw2 z#YGrc${!+wCnsL5QG4dvObRLP(Es^ho3dm6<7u;a%zu7y-+br$1rc3iXB>z)cW%Z& z-*p>{SM|;R&4d+K0zI38I=UmMqxOP2swMCnbH2F9m-6x@0xS-H$-nK{(x3n6ETz&S zhfv2^zSNg5&K{Gu2$(7Ch=)Un=fjS{L2hA3DHd>{c#L8hRs1)_>Zxz2?^=ex_ z%5vLEpjU-}UUdL+HO=kl*57+JMWgwdo$oUtZn| zzS-!XBxS|Q+i9H_iD9Q@+sV%*1UgtyDGj4#$Bp4tzHB+qj?C_$&YMH+v{Jj%Y`I}Y z?m|!U&$a;U=mD@})6CABzqQ*(08c!BzK||sCBR#Ph<^_ej+CF}1(#l{B@HA5={C{? zk(MBBLAr-DQKXAV5lDXtys8+4s~-hkW%WYfRSkhx-4S?IugSut+5_S08I>Sh-K0{Y zRN656ZQpti9h+@kn zUUItE1(zS!N^(X+q*6#C)H<&b8GGy};KsRGhWj)gQ9sS468 zjz#Xr45aEv-^h*|ZAhqC!k&MYeI;rqK%^N+8i#GF#1PM_iT| zJQR%ZdH~M#u7+w;-BoBqbx(*F;h0)D&Bn zCUDBYQBvs-FNqMV*GW3}O>>`|6rZxacj8vbjLt=N_b%DByFTlR*L zs459is$P+jEr_Y&iZ<0EN5!Pg^2^ncHp+cC40|fOEN|_-*`I1sz2(+haO(%G#|nBE zo0IjT*_%C)>rqla`DIyU^!KcrZijLj`&QnSdA=Qa$`*q^>%=LH6vMqBA<&U#JeKzU zg~}2<2mxs<1f+WqkS;+$+K%PjuzdLaw3e4mX1BTaEW$IulT=6=^-gKjb^_H>T}uV& zJ2%USA=8|W-0x0KXPm2T%{BkXmcTx|)cPWo<5GDYc z&1khySyww*$@xE!;XW4@Tur-FzB`@Zct%S@Lwp6&R31pvVYc|z`%o7;Rzt{AJAYqb z!kypjnnFU)?Kns1xxFtH=rBob5x!c?iAk6fdJu%2Vt*1t3Yu9nsN2b-E zGWJ%bKep)-`;&0HI_~FROt(H|x>c3wmQ7tbi_kv2{IcV+WN`muQH~v_GaLF}_EXm0 z?#iU%_T`r^P`|ujhk6-Ns*qxpQ4@+6Y(RsiEVE2maLwCZdfvG1tl3Okpzf7Dm{+sx zocFHJo1J1CpPhMKk%Jk6H#xUSK!4@G(HPqLYM?H70wNA7^+! zF1@~*Wani&X{X2s(A29lz&xK-M7L4Ua~afj^5QpYt~j%h6C1&U_Kc|yuS(&Qno8^I z&m4NDE;~wSEK*p@-*A(4N!|Oo)4FTpS8$-4m%j_xFazS3w5vY)%0+m+5d zV?Xy&@)~5@)V%;uWBt&_l**IsEBlXlm}>_$l10G1*z{`9ZSo(`Ng@lif*AK9Zh1xvSK2991!bdn#tWui?qPnk$aRj<3aU z%!2tEN(!-mES>CS87Z4q;bS2m?tIY3a+0!`E{Vz8+q!EmBD>a7Bzq+-#i5u{Sf}lL z^#xfbYI_kLw!thDZCl7tu9Y7ZV*Rm}rzZ^Gf)%D{cX*=9S(<9ia>c}we5e($?jP}= zs{AMK&fF<-ue~ z@ln>vl>!~=ay2Lu#Y3DZdYeYd#*yUjZFpN6D#wf7hd1>!jbye2+E?d7^aUA^Q|V!S z=wTD+VZ)=721!k9!!q{4GETrUPQWq_$1=82z6VfvNzB1nkd`fT#O~6#o~nst%S?`q zl(KE5qPW4ib{3)4xzp-i5XiSkR#zny#H(k)&Qv7GU~vgt*LvK!=HB^&w2!GMBt+GAU>B%&f0a<_%xewiyiO z^eKiYkh)ZSe)ydhm`DXMFpQ2pebOst{f%79(YmYp9a(+4u6x6()~tF=V%6g@s~!)S zDBrY}rLCUkRP`XL`b(;M5?0aU%!(b)4d-ilT_SCEwO3EI z%|-6F=gABp>-Xx>s&Z^S zH+ZRg_%9*mfprg=z8kn|ziIHX5R>i`kCst;4K6Iz^6vSl^>+^}ay<2ONSiAiKD8Qn zrGw7CT&y8+3TQ2IjpR*W9W3YUcn}h97O@E$b{3mp*F8Fav}w@RpdUN0lptSp;+>ev;bQ9*hQhfIEi4i>*GV{0@ZyZc9Dnj zA+Yk~$tp-}Sw7fu)K6_Wx{<-$J;R3}(IW28_95i!FVT2ao;&EH5M~MCBYB31X}dW# z(lZpLRGnU?P%e|xH)V<6S7-m4tER<~Cxx$MUjp%4Lf7s<*FJ)-{XAX!=XCAE>Dq^@ z_^Tgq5Ppt>aJbe2=kpsie;3=N&;fEfzNnwq#Ol}u0UPJN;-uNQD3q-UALZ>BtckD4 zkr;N_IYrK00jnruJC#@YPa^*z80#vYOM4bvD=>2`B8b>*&Sm&b9@Q0##UJ9z56X8B z$zzntvEiaDHJzP#h4rPYtS=pBeJP6dB}W#MH0w*6iBm@Tyr;>UiIZ&BF2)c+mi?*l zI91^dsMcNtS!(Y+BB?Stw<9SkiN3*u(?4VHk)cGndKF8l;)(HMe(1mt%JcMUy=ekV z4}Y-qaEnHkY)wTN^YI;xENf@>RxvRTZ6ket?&ayVIn&CYrT(S6x zz0b&aF-%C;JJyd*q~8sG`bYZx;Pfl$Pwwwq{`l!*ZAwEJ@wtAPt%tF znV$amz?{_Jr`s35cURC@HyQ~V%Xb$ztfV{gcc4OLZ2*-uYdff{Ne89u!%BX}!(JP5 zSN?;WbQ zr2NlK_F5VRxonP~Qrj)S?!Sk;Bg@}uGTYK0&Iq`sUCHr5EF zzDVwz3#k>7i{Px>dI`?T8#Y!2a9M4Ux{DMYCen{Uuk0J7R62j)sc4sAW5uA=re4uOE5t4+H<^B4cz+3PM&CApaD`O>uoXhp*xmYfJH8g&Em{4%W2?fWkyI^#FcM`lu z8w%BzLZvLE&`K#}zd#CoLZO~g$gZmt>P(>qB{C6N^1m~^YzJZ*e6(?9P zC#bwo_*zczwcLcSW$G?`t=>qUNPUnzL|TC4kJJyTk4T9~K}ds;`ifLJT%-`BAsd=M z8o$HyVmJAfcgtPy4Y^lEz*hl}LIr%)Y|=5|WJP|NBAhJOLHFTg-G-BOauJ-Yl=Fgm zu)jA(ibu{AZimBEKAK6@53dd(YdeIj%2MltJIlEz=}6jptV^qyC`jT%-Q< zlk_BkDLfWLs%%Ixpi0jtQOmQa^EWt`!0Zm%=jy;%e{;5-5=JVxtwMqRJ154J&x;yp%W+_y~$PS=q--ld&5bXU9|b*wE3tS z@~XVGbM*cvqq@Uc<9X%D_xd%HkaaY_qPqB6IyhQ|mVVA8WZ7^h+E}m6NW}x@;vLFy zdJQB?={0!WI>7^@$q(mFvZPbDOGF;rcB)cI`P>1)>{A&ew*o`bs(mXkN>B=?P4-O8 zVB^)0YE71I`C=x2vL%1OOS)zjAjqvdRsr9deDGwppt6=ujy@;&tI2EB=UVl-PJOQD zQyOwnVzF|ZD+_^j=Z`brnpEN?&(i1=D;AsN#KWdVS@7uVaUI}!p?57KqCbSS)Soma(_Y zqJD2Ft+q*m-R?U+wwFf#B2=uC(-y_`I6dv%z?G}YwYk!6ML9WITQ2z6wCT1JkCv)) zeZ*kr@Qy;_NjfDYo@GMfsR$?uB9f^Pku>O>K2oGi-@W@1Ek6LubW#d;5TZ_Z{*Z4v z)xF^?oGQEf776h-VS~0s9kom2(DdINma;@uhZQ(9{SRstrE>UawScG6AX7bEFD$CY zV6XHhWlaKK^%ICGs8v3@T|DM_S|0T-72$J49UkNG2X%Oy!|Uqs1c#5*;Ym5XukL`0 zx8Y24p>t_VV7T-mW!ZgeX)V8Y_%?YQ$2c?{!Qok@s>2_ZIuiA=QaOCINuI$ZSY7Jk zJdDu~A!*H*dLJwGzHObH%}CBxGlQfgKuquW^219Y_fPWP!ic1l!JhMOUTiPTtYD!Ei_Yk_k) z3J7a>IY3z9h%ungYVgtTj8y;UfYU}eOLd`)W z3i8TAYRez?lNU7^o`)1dodSolf(O=t;$5hCzFe1z2P0Jsh4N>2=|}h~OsT?iz}~#^ zhv2auiBrP8+qibeMoC2bqH@c6eA8cC_*bS|CE80e;OCMI*zCC42Drt_&~Cv*OV*Ik z$kwcU9%dbS9^qFjiJosy(8vseMk*3CQnA_69`CDs@T(_Tt9~8VbVd2@192QnB2tK- z#8UlQ4Lp{lf4DCbr(FcnRiyDEEkxRYbOULENN17akZxD&*|f^UPKhp6mP^c1yq|=x zr6Nrd$sH*P=?|pIA}vI^hV&RISfsN^eBqPZPsWO#wAyq>%M*5I* zt&q@-282YFlaQz?A6d$|kQ|XJA$=@Tm6aknA(Frdm~9N_GDJv}=87Y@Vln4u zJnQsx_}SWFQQgQN-2N>8gQkTAlGcxZHzVXqcj$(({NF{IV=5kJGfiQ0ac%^8OA}8$ zOqOv^0{vDKOKm8B!~)ziCWd!Kyr_I~m9-I_B$3ct2-6ryn8qH$G=d1zNF_`ol`xH~ zDokS&VH$lh!Zi3wE}lwM_P8uf+<-*5OJJ1l7+b@KL}{)#p1L-4J~>yE(43a-0Yo(| z(BaL`glO`h51Go~vh>aCR>|M~4<4;K7nFSvZF)lbRljBQt9$52gBV0p8APuzh+c_K zN|4*c$LM!~QM6_DQB>2$qi`Y4k{C;;*zY8_TW7+l+$tF)Dmn|Sl>|f$BsS`@ijC6y z@Ihz!=wN_1^d^U?Nb@&TPT|=(QX`cl2p~eIhc}C)Bm5jmDeOW0_8@@gpHz1aoK6mC z$CvKbW$E2DHE%{R7!GKh+WBRxpXKKlLGlJ8Q$f#FM7t2`*qAV1X$L>M@Y@&ix;RIs zt@lVgPVD1XGGhlo}QPtG9eav_6AQL&jbr(A98cqS(!OcmA@aO=Bt2w7-{7{=!?jMsFQYIRg0T|y$3{}3cJhajPv zDoBXvYHHS=ZfQ0z=<|hD{U3{t;s@mjm?{=2&%6y4auu$O6T%+*>*S(nAQ@ryk2iUp z+QvYeS>MlQWWft|j~S}a!CuUhcQ8*LM$X}PRCk}^4Vub7gh{_Zr^1wae&p3y9!_B( zTNU}Df?m}*)>^X5iOXu)P#Rhg!H+=%Kc=eS$5V`{Z)Be{N$pBb!z|i4k+VAEvNW(m zVNv$BZlRT~vX;cdwKQ)r%niiuRj6Re@(t){m?RQbqj9|v^&KNnH#S{SS4_inXP@AhOyC-@=q~#73CET5JUU4^{Sq9+)c) z3riRZ>AkcUA@)!yB>8?yTdPVcpbbgBo+`<=&auf$JbG8gI;z@?f038wxn1f%R%?!2 zlW7^rpt2SwMvu;ho*f!2`7M8Ogt>kBINA09~ZM}B$z+NO}?E65UK zPKvKA_~lKd(qvg|qysNX)^8!RF0wFJStf}8gEd|~`%F+l0}W3Wc^Y3jM``8YlXhF#44ee?|=cjJ%;& z^GPYR*E{udubeLLmK}IRD*NgJDmz4-d!aP%z>SEN`RL7mHju`jZx)6tGogZ(VyWU- zv6vqDCYBeuGbB%Ahu@fWMVfXDQkKg^k_Sbjg>7N{?9aMG+~?HBY?&43rervgK6p-h z?!>Z(&Z$#IVe-01s=V$|oV*Grw`To1E6<#JdY0GY`AhxA=`{$d93B)MPL-mRriwNH zf)dLuR7#*~WW5M3$y3{4%4cGytP{Nti*$dDg~~dK zz&g?YunjYFWu3sC(tm#qZPN%F2hdkZh{QIE`K9lnJ_O*uJViiyb*?IF$Qj}Eur_M0 zEWSNg>xKzf#^G4THdw|sSjL_X@-D;`lp{83tMXmzi?&h>`M5>5~j)y(MggOZkc__OS7QOtgoOPUS*{iY7Y|~ zMv%sjQCKQ(A(PSz>^8A~oa!ui-n_}MSye5oPwSm!*wutyXjVNQv+D7HRgatHqyZ-Z zK#Kh=MV7WEQPny3RKW{K#TMEa(f(roo)Z1cjKY-aggvL9eNyD5SZk4ZE8Wnm(>Dc& z;l{GVI+h)}{x|W1w#`(Ba|gm_#Z-i}UU!TuWUg4aX938e8|6L`Q98<;jzkr`U!VKklr8G^CYp#E0O{V7`gL+=CZDt%1Xs&`hAmMn`7|=vDFItnvkDy~vO*E261>W9cE8 zrH43{9s)n3ebwe;AdPG>FBJ6Qo%%8fxEQw&n+n3Oi@htmK2DgC?jv?b}O-=$B!^*Hq<@9HJ*>Lu^$ zCGYAb?`rT%-qlOq)l1&hOWsxSAh2HYu7)H*J{qeHvUhT^6xrn>l3wzz zUh=M9@~&R;u7v({2ELa)WGFqUSTA{3`H{0;@~&8se#yI%n5mb%tCzeh@o8y>X~$o^1g(4}^8 z`j@;b>jLL;6gFP!Z_bAHCNPM>EA_)FfEOquiC*pI0Df(BZ> z-j!r5ZKP{1N|Kd+=X%Mz$_b>Z zP6VqqqpBz+{W2_yrPNE_l{B&ORIj1zm6yCL5BrzAt2}KMY^fs1JlByx{*rfvgN96= z-+0JHPQ@x*PWgj<)xKCXAb#uEn6Gz!__RiyK%dQ3s{NyS>+@%>`gdPGKKYe8V?R1S zggmt{46+|Fbc%>_GH8y;Fq zc%nh@L{n2pdU;K4XzbRJ(r&0U^d;mSjvkc#kxzu2^C#q-RLD736**@ee2wlv zbIecQjPW{k2F$~{ZxErs>r4bbUP>hj3x;bMiBHXi~!BbT$&|#5ou(AHAB2}rZbiEG?yTQf-tt@f1JBp;DS0xqQM`fk!eW>rIDo(Nc z_GKVt)fO95r6zI#R$`Azt@}mL+(Ydj5A*8j87}Wa>}FI?)NLfR`H;|-P*FO8@DftZ z>`|t$Nzq9^HP(SQg&!^(z(D)eaD!z&Wx~QSjastb&(7>hPo;n6`1&Hp{c;oeCU5JP z;$6^EMPN8|iIvR4V;@SL_L0^Fl|z#fo~yRIoxZu+t7j_d{SLI^5p$$E&zB@G9JI@D zYv}`$&Qb3psQ2?U_i#w?iKXS-Ni<`seGb)5dLk{jFpiTke6bc7vKi7FB(l70FsV4f zXNoY8g>=^9thM5=x%^z_825Psc}gGo22Ym4m3Y>So4NAAwW}KNRhrJ0t$PE)ncdcV z*e6O=2dW(a)ZT+Dc_-S_vvYS@S>5#36$&fO=8J|;2Ul18zq-qZi$Y(iZ17}&8!8L@ z+53}aZBwWrCqa^~Ew4syE}EI5a5>Ym7tyk9Y1#c1v`JMrKnXAA9#!dgi#$vG1*U|* zD9*$W8aK&o1-()TUk~av28K#M7%DqqsEn*7Rgqj$Ccro8rl&}s?G)Si?99(|alzHb z8{bGneETm#mfBh+I%!cr$Me(VYwt>T{3qRbE1K*CD*FSfvoO1a6ncA+7qIi7a)7kp zc~|7;s=ZC<(2HB@65B@hPf?~xQ|unLs7keAp6tmO8OuD`k9qP5;F8PWu(x#LJ4>~u zNjkS8JD$M@ps-eLXXgHAA%htw2hg1=Ux-1yF9rknGC2OoZ`52dyRjfHAT~xTQfZ#A zG{I#?(xEP+LuFpmTw2}4J0JJ;Tj(?H;-RR+cMqJ8s(VS!8-YU| zDG(qlgR7zJRQZ zvX7yUsa+4@7w58)qLcm*V@0QNnj6?%#s5K!SI>o5KpR;Gac3E16U!hTEQ4%T+p6qf z%6y$EbCrx`5cx_ooy#CtJq7UHydbkgL9+gqyL>3J``BDtR?+b$!%+bh%}lyw=5kff z3E45DdF-`8ZQoQNuHB5~V;ReDYK`UCku4aO3cc6HGfanK=QtbG%W<9Oq`9J=Al*7p z+AHWimqYbMGWg_*eZXW|ye#4WH96E`m=Zuw%SJZR6)U&_E#Zq4O} zLZ!>HPl`O)E3ea!WwGg$+Ov5tBj*H0&OaDAZ_$?~s|{6lQXjXe4?$<)6X+Q;)SQl* z;n_+WtRoGUCFL#hGBkxSoVnYiU})ESY&X|w1k5ujWrv^WL^wWv7Cy%}hez-IJ?x6JZ`_dK#r#4_)l>5~Q@`m;^2m&>k)SG#|DKRo@3f79gPr`x|Do_1n+)xZ%?|2#8z!*5bx*7nCz zVA6E?-@{6Nm4>}Gq{h#`4j%Ew#QsM|d^q>hy~pmn-(****0xo5etqcMOLZsqA3pM< zxu2f;?aupKcfXpx@U=~EOYt#Q6Z>zzCB@JFh;H24)?-l#+qJ)Y@Bh@PWwjD-OkY%@ ziRCTtDYF{9UG2>w+q#uLxp-|@iDs55-cx38aIE&;kY3$N|Gaok*wnWyFM79~)8MUY zi--K~S~_L%*s!TBER((W&)MKmZP$=c*V1VPQGkY1+AKs8g#)?d&!f59(rh|9b#d<6nUaLy?*9>p5;!BS%#z#$@EbrIXV6ryI9dru_jb9KJ>1}r{T4)V#BXt)k5$R8) zHb^~0s=Pp?GHXO?kJMA7-bmGuIwSQ8cv5nyXWe-3UR_=7BEoxxxmd1EtQWSSL9=-8 zQAo>>){E4jVTE|_(5~(6BG#Us=VH0hUP>WtL)wD0S)>NmBArJ19BB)skbXz{66wE` zvJuI|S)_xfhu^y&5PM*$JnD;Pdybi0v%au)tNlHTchB^#{wQ*%zfFZnr_S4lPyh1z zi0aPHKizkjy=G102}=&1KD~3V>k$8IH>CLXDpKdehqb5^{=LKKwl-TwT$|E&@cC0E zQpdTiF!Bv)RqIXXn(_u*>{4mcVvBB4q3^F1xtz%TuTAkB94&v;3-h;W6z?sU;GRNV z78mhwa0sUTEZ9J)v!5Gdn4=vz!z;d1IQ(kZLJu?bdEB zfA7QB&-5+L9rLVwcyiTvj`~TR_@eXzvwc97RpZy|k|y3*+V>)Fiybe}ES}jLQcnrb zC-IuOa4u8M)q&IJD}DT#cQa@1HG&^$$?b=5`*jN@`SQgGz9{|0kO+Qvp3<#r1Co40 zjA(Dtur79x-s|q9UwlLEef^$%bNrB9{x(hb+9k_5FH{>@J;9}Mh32z;*6y6XmhHVaoYro& zp|kH_UEY#i+j&c_rA+zr^0Kz7(>&9+DtAAPyMJBo-jgShC4FTc`=)wAIdmOGE%-LS z-GdV@nuc z)=4h4jdyK0w~-~Cx?Ljj;I>nhO3LRLo_jfI%v)*9T2=4Y;@{!BPL_y0uyC?xqD_<2 zax`07{w*oop3rTd`fTH- zj@4(I-W+pl^h`IowYRz3B9xqICr+HXOmLe4Hcfa2^?3NSzEEBy6CS>%6m83*ND3MA zOWu*IjG{ZQ$t@U6;uVYHidKj34XK{sd0LuX>?&z?ey-B&PE40(x2%ygxR!5AgBw>` zYWMpyQjJrk8b5StBi}WZ78^ywZznCVkNp2%{LxAN_(1+x%n3|+f`lo#O!=t0GQY2oGFI}(9w}3A{{1x$PQDS3LN9xV$2a!u<{R;p!!mDj zSTalwoz!7z4nx#oSq|elOzXL%UhLELuA!d6iI(x37yVE#;(jlY1_p$ApK~4&dUX5- z`CsE5PIfoA%3iHPU!Ik(yvzUkNlCi_mez-DOntX~c+}2^!!UI?LaBbJW0a~6CngLP`9#LPC1Dio6B{%&A$qn9DVfIS-Tc4xk^o$ z@BX)gr_boGhHpD^?ZYH*_mib!<2Oc^^9`%A_ zJr^~PUE8_7{ksv%`Mu$w5 zwb4U4T@a(&eYa#{X7hI9{Ul1M&CKO#Lunk>>9q~DO9 zAO(wb87U3vl}M4MaIO_1RTwJLt4LEh7g8;xe;|G6E9Y8Kt(jY+p|Vv@`AE61k3_nR z)C%dJNFR%2u~H;gq{>LsMDjrzfb=h<>6{B`1X4|;8Jr7g5>g$cPdL{qk!BASw`M&r zxrq>ofAS&zX(>{DBtoLrWQ0V$&US;_UzMkwJL<71j(parXG(?OS*)iD-(-OrXQHl9 z0?(_FRCY5e+uHwua6NV$ki%iqq+-9r_pwF!KKkLK(2<<+{1R_Lp)t$mOQ!lckU#uU$dQ^?9U@P z8x=*$9V4O%RT`Z;da0PDB8`N~mX(ozpp}2epy{%Q-U2@o7xX?%(hl&+CsJp9QfKl9 z{tD+gee=GvR(zHavglM>(y0b9f~GQpUcrff6eoT}m~Z1VGk@PhwFgn{so96n-1}8# z#A)el<2kb!j&5JIr|mHp>m%h73vzfx%+L|cqkd3U3>B9v$~lTj6nSVW z<|;<#Fq%7Ez(J9#en5ugsZy5tikK9qL8`gB#f@Zlrm-F>b2nm6_+O!n5kTVhm;9;#(`A zT@!*=k4+NSXl+B=nQdt2GDok?Js83y(PZ7Ll(wu?3SMx7Nz>#d9&OO%4gEM-%#nkd zOQ)KuQqg`qRp#u>TiGW{xu?kerIBaU_tG9QDHr&QX_QvXCCzmtubi>GWGPIQ#?#V@ zd$;p!S9Gy%_&>$TBAPvSh;vm!oNZWy@T|MhBJ|hZAC*M2K}PA=VN|D_^OmGwPNn+KeBgAAYwm$>2LU zeGz<-njXWs44+tD*aQugRya-X>`xi3zt+nBY|RXK64{@RN%eg|s_#u}Dwh?`SgT`C zC3Sx%hlE)B5m@b)xd$-~CQ*M=;Iqz82 zAn%!SCb2;#R=r||{-AR-)wFC!Dm#$M_B(xZjn}FE%#`EEJPl;xc9qQ2<7A#jF#wCh zV+Rh87zR7ztH{#VMU^pLUg~qC+GHFTLYxAl<&|%t?200?WV9`YA9!Yl zlIqis7ki>cmJy`6+(-70d&Z<3#>(x<$hn%4voj;-Tt?2?jGQeQIfEEEQ~!}Ma>`f! zrE}yIPjIe$6)F6d&Z*im`jr0}>qKJ@X(xIYqpQRP$E zD&CEG@H(1yCI1H=F)99tXArIO?#Z2ErBCRtbB@M}a&`kqlA4e9kVNGpi_4H+4bd-s*Q)F7R znDsWwgW!R>88wMcU>hC;A67yVvKz*-fO&h-GhBw*Z6VB~|G$kBI<5j3I?x*uS%WNq zQIW&+h)(LfW0kMo9)zAT>w}p5E}<1W;3^z}tMELo!q0IP4rdu8iG1H!mN@;KBPaE? z4!|vZlNC*>UCV_~7#GU(rG*#D(ZY0zFV^R2=LM!JtntFsEiWE)L8-a##J1Vj+xogO z?i%tu^D&D?x7)GmDU1J^-XcxQcJ!9I3{(TTau%&*AaCE%s<(A@mOUKp`8UfRS5NXz zye>Vv@(uAI^h`&GIa8enP@2cA{l!j5gxd_I=daG($zYO1SXoDMUzXeii@XF~8AS5s ziqA4QEQye^#}W;^h5x2zc1tvOZAT}`Ecl9^gpP75oXUch?M%yFM9a3NW%sAL5r0puv;XNrn>BYx%byDF`$~4(Ty?WrYiNPxBhYMjRq{xw4)P@X(6);dg zY3Omxs;Y>iUn|xo)9Wvztk}@MX~j&ch>uoOc99c$b%cv)OUh}Yu@{PIvq2qc>n|Xt zONCR-0hFnTcGH0?cZQ*)?8ZWII8eI83P$dP4pwBl&9O)9THYPf?b5i5 zBf3={ckwgFo)<&rI=&OR*Ts6{w(8xVI9OG0dDo}g_Hh^II-dF^WRWA-XU&qLrXvsa z{Y(f;I;jmg1F3Ej1Ep*mu}UsumAEUbMDN2aYbOtPfhwfzlzv&u^g=vy6;)*-SD)bo+ls??lrVPt$p?U_&NYnc;mjR@0C7r(cc+p>8 zJDJrc=e^80)BdrCpvRaAyJG=uWcK9FGRP*DK|ELn*~~JC=NRb@V#{VMgUDB^>s$t5 zcywo|)zAM@08^p}JS$qp%X69~oGXW=qQ6vl_lF9RdYiEGYBG%KcGG3TLdDS|*3e$+ zDbos0@}UwFsO>(~_7-Y;0JZ%EwLLaEN$A1@7|Xw4EFY^imh=0b&)M>Kf$=_fC`ghgeUZ!+LT}wOBQTxQ|2Nc;+-i z1jpm}IWzQPFJIb0{FZ+;fg(HWo3B78Qs_-y*Oz*Nzl zZ;}DX(m9&u&Ns;@%*1UA6Sw|M+~SzH1vX;hR(!^YcJNq7ezy+a3GaPznl0Ozo{!)v zhR->9ThXgd@R$eEm+qx6oj_mu2Yu-+M$TlF;qw9Y0ogl)VWlVI+lhs#A1V#^)Ziz})6;^}e%dDxtF+r!Cr?hl(dNnd^oO6N|Mt_< zgng6K*L^3%tEczVpVWvAPWOA7p5A)vuTPe@X=K^|N$R?9$0rESs@g5#TMhsGsqn4h z90Y*1HSvKI==4LH6lnd8{O`$(*cm%M*;+xERiD4s+V+aWSBJj6;QMgbzmiLun|<2v zmtO~u64_y=$SGqV?&>?>!}KGcoUH}o%2W_nABcW^r072ynVW4&c*V>u$nNKF>n)o# z<+X1Tru@tF1G}~d7c4EmxQVBg(NLE&@l&dsj<(x>Ffpq9t|kqvjNWrO6yLU{>HBtd z4pojSf3(S;mPVspzKCyI%XFmOzYq0ZQa-s!yrt1Nm(Swc);1kxx8l%($nrOvL|7V4 zbXgtW*4%Wc-Oq;-Bg#K%;%{jj?6N5SD|1tyQFjhij;Q&hi6hdd@z;U_4?GpE_hQk? zpaoNGkVp#_iIij^QXo=)krKm2+JNMT|8XqnBZi|0gK0H}s>sNNGjRt>g(X4jrdKb@=C7OJ*E!t@C z44;n12mYB5Db$4U3OmYeJ+N(!pcH&M8@r4I$T9!-x&C!5O4o_)(6#N_j}}y(>Qbgb z1EYwly?Xt_u32<+W$*D_oSGc2JU?{QJpZ~DrCxXIc%*~S87c{?K^PDGQL9fT0I*7zS8LWe}Y@AsNH9c(e?RNA1#~lsFy>n9)qkiSWM#= zaDr_DMp%+qFRYA}z^INm37uiIz^K+P6)6PiI?_a><&>%~Qdy8yA0w@#6jDQ^SxBoX z)u7qrsmDR8G=PES3HvaHrya1e3HE){%qft@|q&bv& zLrPr(d}0WxqWRn^&gCCY+}wAtK@e9a{4fns>lzPZJiom5Pe01Tl{e=v{*~Z4oVyFL z<8;1Kn==zS95peMC%+5q4H&oP{6RHjHnMU2M^RAjb*dhFV1`s_#cEKmMoE>vRT-|% ziss+Jv6=wK>dv?A28S5!^#pY_P@%4FR}~V`ibV=_bzY&a?km*QWKdV*zk-YfPy`&9 z9gLCkFh=x~^u$(udB2;@`*|XiX{c&&0@C*XZ9NHToqlaI<7u#X{e-!Gf38<@q3Uzh6JgBQh3U$>_p{{l))YSz= z#(IC(qa6#DNc(I}wZ|*!)fvI>tP!|jh_k>AP0Sw6uXm zQQd*uajWIH`*w2o^qgC5w56ZtdM;K^D2J}2C?KHCeA}86cIAXcDP3&bC_>$dj%%oX zskjhVys7FzDWcZJ6R%{vGU}SMrI+)emrJ5EaNv#1l2ZP7#dSzhig5|~Y{7FcC5>4F zKhjivQ{f-=hjP?)pH09s;78r%o8yFj)#1@JFS*W>5U;HVY6Y+M5E!2MhGw&U)(ujh z%hl&k>eGCq=rHz@=$XcHYfHJ?B9yY=RUhwLZX3S1I1yLcu&j^dmt3ZocjTHC`Edr5 zc%0q1qN(?zCbKWw2sZMfC$PELwNS6xL%j-@2Dhvh)GOF#Hvw9;)iA7J7aphKuap*O zE&rdzAFJh$x8)BP`Qt8av(A~h{x(--K4&8Hxp3xl2drg27t*JjT%j>H@F`CLoLC%B z!M1p%k(_=BSA^;p$5Swv#0)5i-&mWQn88gHvs5BNrcEuuNgmxc%XVT!ImZDHhuBsg z{fm$7g3-U6@4r6f>$!0~&P>}Gck<-4eOKB!o3*}D@}Kt|wpt|UIF2wle(`qdht z>&%xwN_yOGyd!?899aq+CrIEp@nQ1EKq(V?_z{FEmr3!X>=G_5vayO4%R~-eUCiNB z4(qAIk2vh04ySSG&0!Yns*OH~D{T(ePkcpDs1$C>Hmr)!q?&rZ;~Qbep_4jv;4nlT zw%{;c9ky0w?WJrQfGKrx#g&3Gl|#w{aiz_{a@iW+RetS~&GI;6IqaYgcW~&f4tH|+ zu{w<7Fq*@s8}mh634|*f2dj*4TG|@zTKIjf)Kn!1R(4RYE<-r9(}Z_ zMK|{|0I*gf5H4rn{W>G-Q6d)^LrAXEy&Eo&7tYP&Xf_&*SFJoG10t@piCW#cMQCdGxW!i7qM@YnT+v9bc$`~m z3i3-&>EGvW4{CU+yy>zYnt6x>l`;eYdhBKrRpS3<> zV@t{ButPeIbWfy)twidDbPnkOrI1D;U1++}x8Xwky<1DlTsZ- zGC3tur|m0z8=5qdQXM4N$?lZon0G^}EK)<_pL!vAY@g@5&)wQfCpaOuXE9V29xE%+ zxwaTRUPIiFty$kbMrB755VX+#v84N}4L5d>uQCkZ$9MQXwkY360aG&cO9GK9FSg9_ zyf|1znTAo&b9I(@l^n?$R*FeQh-+MPYUN$r6Bh{IX{9rwJ%eFoMr;;NhP-3&LVX9x zcIoV{;)1iu1@EE@_$7hU$ph^NV58vzoLlyyZsr7d`SyKxhmxFthKwx@53 zXTA^VV4souH;^a3r=iqy5SWZqg~>QeU%H9Zq(1w_Ih?`B!i7Iad{1fz-(38gWTFGu zI!SF`I6y10Ta$`rs7NRsu~)?%97P4|%v6`SpqA|=F6c;8LWJ}_%-YOO1^DC>siU3G z;Q!#!nsY(fN6@Axq*L`%d+O|A1P#K8pNbRz3Qqi^PO*yw#-*Tkd#Lsxsy!3mkb6&^ zj5sZwZ9HcdgRd~AR)Cu-rEpXF9v0~~?e!b88Q|}12B`mGVYg{FWZH(xC_J0@hGpmI zVK?K>_YCv>N%F~Q@S92Y_54m6eC$Zxj2~(6yQ%px*=t_%OJzsGRyw1E2+%r9Pn}oj z)!#EViqxA=NjTv*?%+2TG|q}>f-!ut@L^6WKx=27an8q0rAr=|5e^^$S`($ ztoj_)=V(1g>p2?A5h)CQb&gH$ZCzF?EGv`0q*9Lx9$~efS%mf`eFl?CGmdJfQy5Gt zXxNitSiMEXf;#HPi26(_jx<1zn4!8c9o=ZyQ6wTdR$+$LP^$H62ND(|Rk}(u!~n!Z zrfsB@tLX+at0Ktm@a2&gCbX#tzF2@1aK>d_!BpIRj`%9QBo9hG%aX7-_H?7ib`=cw zo3ym6gtq36az0L#lZU2auFmNkMsr8%%(s8M$*ZTzJ7fcCKjP{AHgmL@Bi_Qi%!`Yp zPB7&x1Q5&cAyHXZB!cocdeRq}w!w~sJ!xNl8+qUxIbx#hNAvQ#&JpppL(G}V^p zKY%&W7pyycz`Db2)*UXe?y%?W7Aw6@)ylhVYbcegO=V+pohikPv!{qgzei|qD_-(S zNJYL=`Lj>&-?8I#a=E=p9?<(RNke~q?$mBEiRyMHmwOb}k=}cs?3mWy2Sppwn~+bRQ;z^eO0R7hHzWYXNB8}qo@$c zD+|=KSBV>X9~L%wrMI>0i+*-yR|YW+mbU==iZ|qoWn}`fp7hWn_@de|oIvRO*}3_a zic~x*wM6lajIKJ{Tvh_ZJl3F^vGO#$tW;{!0*s*zbmeYzylY8DbR~gd2?-1i%#_u# zRWqI7Z`F~N=E3NP_$@R__xZp0cg!jGe;{Mzn>y{#k<6yDr!Yutw2aofw6azFs9Ykf z{RROoa6VwZQd=WW)z*dv>iPej1Es+wnqKG%v_7QOV}qeJ5J2;WNwi zGc*LzyTQZ0lq?+UwPVJ>ja6LpZrP4hcHnWT?5i%3dnJh-K8Ir;#4U))ya93WImFlD zg|EXy+#egOi2I``2)^PZ(Mie`ze$ngjpucG?Oci&u4pJp2W(d?7LSIWL zsOeZfO6#m`wVL(5-hd8SnVQHvEgb8%5t-fnNaNp08vjUsdX^DUe90Z!iQWdaQCxwcCQ|XQAG;vN3zOrCOpgE5 zJvq+w7pVoUln}=3Tyr$qY<2@^ZIy-9a2iCc6#s$#hry&(E52-giQSq)I&!*^fNj-O zu&n|eX61C}@FD2Ux>7)_eFCi#tITIA23pku9qPln!fKMK(qm`s*;DQW&;$}d!)fj| zLTHzo@WFYMfb%FE=aCH=pq_N@u{W7M1BBHqdI=&ct=EkxCS$W?0ZPk1+%vW@1TdAz zPgVVYZJZR)&-yshZTMgweH-FuJ?~t1|W`yhJ58 zV7Atamc53St&+;k=xqw)64B4SlBeT@RShpp)nX~7|E_~YoPM4~)$J17`0UKjm1zQD zEIB|LRGjkA4Z|iqr)-$)fmKqqf_7e_bKq<)^&I!BI1usakk>64-V%y8fJTlhk#0Ph zZaj|F>_8pSUBxRI7{!|s+;ps!b%;#s8B@QNR86W1 zY>mKbiX|+^kD1kpDSR-!TE_IMCDW@QwT)nlx23N2S|t&F`{-M|4vfzDp_cInKs0(e z<#^D*bO#`r(H9y@`jIQXpv@19*}2l56{qngGRn53SI%ZgZ9P8EXWYd@QHSpyI3HF2 z&VlTVtg@cdte!ep1;EI%SB$KS!pM@%HFRv3l(E^MPAqt?Ej5&Z16)c1pDtlRypFG> ztRq&{VQiXqFtaKv-^;w!Vr5Ok+|d+$?!5*THCTa!<nF`1Y-Y7eLU_&K=%90;kU;SYGES1&nB0bmzaheJWQ+}6~;DyVo zT@f>j<`Z=%d@S+!X!-Bi!&hMlbCEWts?{(?-=>xMV6xTpRcYJRu%)XpAXKZ)hZi3$ zGJ5q*9+g=u(*V+rOEXrX1GFHPmGz>u7L~K6Fpi%9I@kglKSkgRQdiWrhYDaw$xKO5 zzSN^5!>mq(j;3o>%T>*^Cf4VfSbwg3OXZ|ClftF0V=M3xgGuGgW`l_i{H@5r=d(9- zR=5hk(;^e8>kMTt$jehuc<=K&S2S0w&d<(2>Z=RH_4YGl=9IZ7dLD6DYI8yb$YMFt zg+Vlz6{Q=H#UP%Ol2t6W&I__)l-*Q>Zj*w#U?c;@DbHPJ8H&)=r9&Uzhgmk z3k#zCi_Lf$s%;znFQ%thu_fSdbf?L5r*Vs<=M)TNt)%nPU47SIqW)oQSj5*N&C{9 zrl$ul|Ni}_Cze+=wSD^MnZbK6w+a5C{2#)@a_9#StN#rFX7vq7l>%>!NS6Z3e=Gzb z>&Fu53t!vh{1TA$e;tq|_>@neWSJyH{xGfY;3UusLdmk+IY!tFg#cuIB)|ttVL1FB z0%Y|TsFhU}09hRYWX%^qmPjE;*O4Y7EvHm{k;--z>0_joltOBVGz)1pr5aSx0I~!~ z;k-czR&EUeWX%MSB~o{!-Xc|AD9kJ;m|1Qxv)qN5)f>qZsSlEeNDGksk@_L^5h)QV z2x$;fUy&+@ixh%1WJ7ZufUJN=0J54*0+1E?C4ekf1;|>d09hv$AS(qxmc0UGMYfeX zUjik|K~b`*L&@4cdVk9ciNapd8;~W?uGtyTE|3+~K~|L30J4z0kaS?Qidm`(AnWFx zKl^SyV0b#0x+3hEYfkb6#!vjIyDC^<5x3?ZBAOfozPqq{9*0a6{ zD<*Sm9KP^FXlpR8EnxJ@D-~Mv_yIv#Z zGzy?&0YJwYfX<>1VPaXp#7gNL>N3Q$A%vzx-V%R6TBlE!NKI%}OI|PdPo6xqsywu5 zJT%}lSyHLsqhG@Y%&F@rx{y+^^E|054^CK=Qk7sKWvDyJeGSFVG7Ko|wcyex)orM2 z4yWd8@XB<83C3HLP1$?Z7Psk@nTOWvd`t#}z$S%5BDYbcjCk&1Ap(K}Hs+ElHgD-lr z_&eU+g}-Ag{2j;B!ruuIj?QtQNZAQVCjT8DyutOB$iKrSS5dSIJfABdJ#U? zox{UCE%$jlM)*8Zhx<7!>w@|fht<{L*Bmxfhu_HI{mvtV|D?cFJq5p{&A@8B!^!T( z8i7{rO|*>P%vJ7#Z9Nym~KXDQlSClSpr8V>~br;#tSXqS@-+#R52X7v}l~Akpz)*6PIy4tdQZ*P^ z)kg6FHK|%xKK5@OboTvr9fg(D-j$E`e1J}B-&wvkfvN|41`Vy7RIAC+NA9((YxX9(vYf$Bg-X?Kr=lBypL&+0 z7e`A!+EzhJ85E194dN;Y7E7C_HN`VHeNDULB)J@sEm=Hm$F=)ylmzZAmMn1}iRN-8 z$z_SSA%0bEh-lM>*UD=-owE5MSS5AD=@eL=53+=>_B~Uk$_EDt>6)WLy0l^mgnD&% zmMr_h#;ObT>IfjLRFSSDwL?0Mbe~eNu?8dkfb<8YT8SItLl9RNL0tXmBBfwstwOqv z^jM_pNM9rUj+90z*jN{l9wDVu3aKO@tdfARN)VXUR;0Q}Ws!_Tx{lNi$pm;+sbf;= zou+bM@T{sM8H;os=|iNtNM$Gm8*3F(L!@$)Li!rX4ygjAU}IfGYJpUVQb;Aq7iov| z8l_-k)x{0bRnk5hnl_SBNbQh%AypAc(mwnjh||egZ>Q5wl0ia}OD->jW?edtU1$T3 z5j)g1GA)ym)eQGUPE-~*P}Erz>bRdh8)zVH*9z^UwYJJ*rPa^jWl^U*N%X4XU#UC)0 z!aJsr1=?BShLChqvPy~v>RG6)LQ%4`BD0!HgP%z4k`g|em(B2TQmyDLvgcqJDlc8) zbC!|jaam=2=zaKr&F|7Qkv@8C@vTV~7lzfo#1>jxyI-j$6?_y_QiPebwWf`wd-ba= zRpK`gr*f42gb0rXS1VA6?RX+Skaz$M^Fc-7X5XJw+{^dZoP%+x3C;~7!c&1ba-=>8 z9!%|PzK6&t{STk6ml!9NM6pJmgI-DDI<|HHD?sbA3Vj+#RFwXQZ3wW^fdkOqtT1=t zi_Tn+vb=qIM>Xjc`c!`&%&Tea7g}3tOYM7=Nlntk%5J86^}H-q9$WX=m+saZyYhD_ zKHL!%@8c|E>qgQ>-LsG5Qp>W3S^&=D%p9kyGbOm>4Qb7EVEO0B=bP7Fe9=?SmtazW zfGQo4SkIrx?sfX6WQC8_JAOm5!XHzKw#07?Ab#Tu;y1<;zj2ek{U(ukNoT3@VYK?r zDo$&R&Q?ymN1vVT{=?PMBo(xAj^`-#}@?1 zqEGQ69!|g9j3O`fEI^iuWpaugbav)BEYS>%ua+e`hbqtBn`Q)FRo6L;c9%Cnn{z3I z;f+}oQLI+I8?m%6UaszXcSnl%{=p}rENH79ROmc|5*PLj_4 zSKf@wiL&1jI_V=!(xA~8&Q3X1oN-YSWtP|J2QWu6Xtu_H6-nO>%8QZpHnp7#l(n=+ zOv){yDCbI-ZA>UNA@RB^Tf@lG)OKbd-b+SSw*rB&vO%4eutzdJG}fHwdvlM~Jn8z;D#u*m;t9 zp@Ms};*kXuCQmDohtrHN7J7s9!hCTDS1c&;w=l`>IvB$R%vm49tt!T_*eZem&L>|q zbBR%?3{v5*>dBq+Zn$@OU)8xS8(u}W05jP*9@LMXPzM{19z%BfzKmUm% zqF!7cFA-TWw6f=Sp*$0j0L$ypjvJF$vJVgx4}z%Egi(2KE4l&O+omtY(j%2|?iMalAB@38{<{=)*9B5bG7c&7wI_RVV4t2GzF7vH}9COp(GYPb~6-> z5A}1rWze6SI&)G9c*+bcL*aZ-!2)@1w5T);-npf*TK~|mx zm43~-{$meW+14PlWOi<+2)=<#)b&2RseCoSc_+i`QYH%0giSK_*FV!68>eZ^dK=Qn zkC0)m|KVdjO(R)S5}W0g)K)6BrPF8U7r~U+4hW%z|AS#(Jw1uOh$Z?WRx#Q=c{R52 z0{HL(Bxt<=(Mh)#d0ox!JJO8i*=-@rqyLYM6Mh>6ir%>1-5GN8v}&}?1$?GCEQtIi z{|7P)9!L|*^w{KTZ&yR4@ikV{s!3uEnM)_0q@J4WsPwOE6NV^ z?8CbN$a2l@Ez+bKt1NFFUXgsIs?VJs9zYlAMHgAXbN!w2%HN4?6D$T~CHmO>9SA`u z%bcD0NatW0s95~-Xud0{xOu+8n>@DXfMi+F&J`(3g1d61ofo0>{6@xh79t8`u;{Q(^oq!O-a@Cc z!mXl{glpH22DX!_(@v&NBbg{Cv#uDogQj*vx@*mnat8Oxl}7%|Ep*hLqO56V>`-Wn zVGPv6SWbS6fRALBxZ-pKcNMQR`hO?0JVX)M$J0rwc~Vp6Nq)eZPvD+@esX0);L$gY~0(^=MT&kVk`;zMgRBz+A`qzlQ8|?D=!ZpuklJOw9v7B#Nr? zwzA!yjOdm)?qWjJ&^rgr16O@(+Bk3({d2Be2gMrtG6y*}GiEY7Jyy#61(YQm$yYDH zRZbR`UJ+Dz8ACTU_K{wItDG#XEHg-vgD>C#$uE*hQ|Pff#*|=-V+Un8P4oa<7fJn%5{WP(;RwxauowC$$7`C#JI)Si#+e2kV8 z3iD8a@#Q&nt~nbmsHBXv`Z;0>U`Oa@ZRlU>EK`>PI6Cq-Q~1^Tl`6E;q`iuCBC$ZP zffPEH)1L<%E(xj?Vo3V|k^%~TAKMdn=`^REwjo|O|3MZVsp(~?ShbyE2619`% z3MsS?r7&M?MeWR$nQ|i2h5J;#p(H&mi+R4XW;|VM!6Da*QyhIaAUnl>|0es2lg0wp z%$nv<*)^$b$576#f^6n6h|ggVugM_p$RHlbLS%JXZc*+)qT;IbbDR`;DV7)``9Z#n zwgwIE(iNkn09IK9-$lgP*s`A7Un|Z=6H^tP^jSd11ijq{LdUwylGU*3GFAJIpsFpU zIJvV_a9m;SjDi{{&ud>4Hr{IlP5A|-n{ls_89XWl%`MK96GLQ_bW1Gnbt?Gj-1O9a z>7S)PZk~Siv-Gs&6U&3sW&}SrPrtt}?R@Z`-~E(+O?X$qX*bgUZ0?)>^u&|&^htvc z{V5PDmt7C9cK`H#c={9nrpZFN`hNI*p#pho&H=D5JmtP0JS8if|n~~Gzej4BL;jZtKOPiamJ}>eZ<0pMOZMOaD z(6`sSJ>1pz$5Q5Io4!D=G_n6?TciFim*c0Hg^jZ-*{OVEqroo8@vl^K8*BIPgWgNa zuV~_GWfb6YGX9ksZh>|`AB>JFzrRT>E2H;a4#ZEX>Gq!8n};qfDSxubZ$WgKgHb5&+g8l=!lw6 znhdZs4t7}(|CPC$_ozFEE-e$GdW3N3<5bZyr)k90OkYW=lHc%w*MIs$TdJn0e zNYUXUEk*K1>dVO%iZlYLFOoawLTZKN(qO;2Td%Tmt_3BZG^w!Wm0*{)NZmz>4io9e zXp!t2q*OY8;HhYrLPd)~t4}c}k?J8$LaK?>iIdG2$rb6JNbN;x>EIT1&-l3S6th}y zmfLe}O2p6YjSrMgm{swU*TNIW9bIkb^N#U>@(Ds_s1+_`hS$R(GuR9ZFdH1=BPC4| z!YeLLJ||>`4oBLoox0#(Q;wQ6C=pSySFcy?ETW^!dwX?pdi`+XywG0ruDx#YZ5_7` zU5~u8He^BNk6o%X$OQ4!jrTs?#mO$hp;xGj<(vie!p7g5=H08(m-Ae%Z#4^bYIU!j z-G>@@A zsmd}+NL39$T%87SH5O@^NE?uTN1BYZf>I!^Oh8;sM_NTGBs-)zNYT9?mTD0zJe6n= zSB*eixd`IQ4eHe;q*h2hka`QLsvhtvS4dU81zzO_^~xJ*08(Ehs8`WQBar$dLA|Rx>BjlTLZk>g_ zF#-C{Nulq|ul?vvXWd8+C&6nd#8nRJ)x=jaNHiHBEK0oq>ea-S9yVLQxjN)qleZy& z7@m5yjEYj!tGho|7#z|H_=+~qDu1cz-p&VX-d`zr6KkpKSzvEqC3hdQ!1V6wT^vJE2+K z8>!$|aSDDlK*6sX1HZbh;8$klh5j^8xIN`z#%S}b@|Qy8i?jG*p46+0{cayH=}av> z3tk0ICV#}0b}9W3S2;>ewAkb+Jy(GdS1$a>ED)A9&&maYR$fwI_uEGtw5dm*+%DJL zIoeFotZFEl)j|coI(*Qb+)rCqeh z5mz~ISx?qjWZX#(otpz%WkG}5Az^u)WMBrTP~wWV+q{s@ylU?0t&yz-oV zc!l6q9yaeE`U&jSwax*qLz1rbQJ;S5^8@ucgHN7G@lmfFHH0gp;5Gwn?iMfN>azCf ziw~rm@7z0v1_EQ`DGtnJIuRw$UZ!fZoH|~ zet)|0t}^=aDkSqqcC=yL!}o?%PY9y+mq_im=Hy3c$O~!6hCp0tL$#JjW4bJplNUg} z3gSI8EcL4GTA5LupkIx(SzT_>m3H0Co-Qs|YQVUNaux#~I+&Fl@UV$l!`*ir%mQ}b z8D?ug`j;WLuk?J^wBNSPs|8}zN~lRSp(b?^u8tM>qceg(nkIalEy6jn6AYHq{_AOL z9O95a64_G91VP98RQ@pW90UhxLu1cwz7bDCFMEeyQ-`mF$zg*xQD5cIUmgB~!wu@N zyd0iWfGGufg6}kbgKMZ~ew?eULj9m+Wm2zf&iHKm@TlE?EUgdQxcPGE&*2$$_`Xv8 zP=l1J4yVeYF2t2K_38rjDK0gBliVF_ts5~=xFBt5!LY&`ICwhwMtFxUlwYe3hjO?< z9S-O4nmT-s!v@VMJ6aCUeFn-)56+dQ(7(^g=I+|qvF1{T6TuuERv*{os6I#aIeH~_ zviqSjRfLRGz8N1C_-MpOE&19__)2Z1>N`{Qr=+&uywPV&)PG@MEtCrGByya{@k`|o zU`X1WtCCQW>csZ`f9#!kTvb)~|20z|aj3-M!JKly1jGc?P#kg=5l2wav;;wLdJ?U0 zLMt;UML|)V2Smjw#Uah1!88XPaX?MWN*qWn$5i0A-kZE|<#4$d;rjfZum9ZF;lsY? zoO|}!!`f@D_ujkmN4pd6nGJDOL+^@ngu%63$Dj%X#APlifS;XT)T?h+hhKfObBr{~ zSEXjoQ8RBz%~;AGF8t9}{unOx@%IsdSyedrV8ztqmmpl#Q-rHyA~xbbo0ovO0&aHp zQ~TMSH&fR`n#%V|_>JqiH$a7s2MQw<5UlHTjS3Fd=9&d40 z*%3zrJ5>hRu{PQp*HQyQb=H%5>eIPS&vRDnp5?rmGAUUjMal?8|^SENKFs8?Y~fk@|&?g^>N0-jYE@T%VgUKI!RDhw$ODFq4Yl?6Pj{YbZw zpk9R`T}66?1og_IrAQX=tX?GM3hGrDk_}QRB&b&wZ;9jzma3eS_?w_!g}vn{_k~m$ z3F?(aE0MyGY9T?r3PXxRvO|J;WdYA>Kavv?)T=P0t4JDs)DZ(~+ z4vxfzM2^@hn$}?AgiaABbc#5kwGHu1P}>FLnfSlxhS1pDTs#v3$Ld9UT8C5OJk4zf zRFpBAQFs~K81^?h##T<=LQZ~5MO{uO>T)Sjm+h(Sm(1jlF!T0>nU{N(o11rtZy`C} z&eDjsldcjxlUlIgBaXh+gQ{4CGq4x&>+5hQt33&~Y41;FD=q&E!U^#7gR;wr=c=s{ zC*(K(8EpkfOvP<_t7k&J3TPWlw#E#95;u%KRGZmlQm>57>`qKsN@8GIceR(1F4{Gk zq)*4g1Z(u8A#W#?J(va;OelNMv6O+reMw`>JipPY@q)UJR=A3h|D-S{Xil~4|RN`rbOkA9YV^y~;|{9!6tBO27J z+)`F#Q#Ya^YzQ83r6VgVae4WZBCb!&YAHX~vz+1l&v-@7m`R%sBj##_4YgaI_#6+0 z**F}`9ypj+;b8XE8^=`+Vw@((L1i@%@Mw^FRd773TsIpGBnI*sQLjwQw$Mt`=ol}4 z`!j~OBh>Bm8j~d1Cx1|hU$Y(I`}FN8^zBLX?eQh~SVfih;yqYP-(Dr)u0XO*X|{6S z-aKW1fTS^%RHfV0@9Dl+jE44%Qp-(^eNstR>YM`CC|Jf!|3}|srj?ZGee?OexEW;!m&fcu|un3hq{oj5=>n4t;<>K zTJlu{mSyz5ve2QmLG`f+;0SALY$U zy_)FPUy=t$svX)DDPuk(@7OM=RtXbY>h4RLhFRv)P(*g1tf2c7j)|YmWo3KTaGwzZ= zuFG4ma*={~lGqSBIJ-kdZFO*C-F_+9DUb4XwKoN=@Q zMp;yAHNtgYYZSQ4M4D-O(ZXzLR{%nuk@`7GFi(pv>Km- zkw;=y?wQ|o2u7At8HFB34yALP9(G@|;t;0L+gQWfu!cv`>PKM>Un8;mB#GUt`%wST zpVji#3W?11&feH%kvI#_D%S*#ypXCI(plug7rE6=-N`%$!m>vLJSc>Q14$lk{NU${1n}GMYI^ zUaXb>pG*^eBa_HMrrI>wzi5q=yQy(3WtsO;Op`-ZrK2n(EiL(HTgp+j8=Qm#2jxv}8Q#xgnnTO}PXphIm=KH6CA zd^AVewM?GWde-GoUWCW~A|0ZG?knq#B(ddZD(fT~>%{m&=G7)lkeNm65LcO5-AIt8 zly!2@q{An2yECa***C{9U>ZHn?cTsfAvS8y5Tg%`HI1aDrHRdg(fSw|`ebguV64aq zJU~uhl&n_?h0Kdi+=1?V10(7{M$`km08zXEc6yL^L25}Jxuw+pJcjM835jAI>TDq? zL+$^s8YlcVgNQ4ALnl`YBKM?o#ZVt@^oALdvpt@kJd)wsnwfHEX3BG!DK}!K+=!X- zkU*x#PSUBzzm_0Lhz<3;MeSMtc)Z4(mmNd$LaNg8oiJNB^<2yt^5pY)`Y)PlSQJl4 zdn9n@7REUclHU@5)m0i`_QCWudiK`z?33x)%h0n|enD{VgI37PkldAN+hSHDTN4Q| znMeR8m8E%|i!jf8I_eeYn!>px+{(<EpmhGVeo`RUzCgYDi zq}jrBaaA&{k}ZjpU!k;A&UG19voA9~-b5j}m7-}yP^-&W>*&M^=PXt@XR*R*&pqi| z6!r2^TEn^id#n?tJrd#PS)eei%%t+^Y#%sO(Ri6Uonz{>m5FlDV4B)VhSW7#my~6q zB!+P#OeNVPGzXCWV*)TegeTei5=W@?@Dm)cCMGd>}- zY?rYIOQ@_gF7S5)yukISCg*JgOT{F~ zF2AoaPgbbV#rO|iqiuI(0<9)aNBC2bLXR*hR;yueXwKPa#>Q`mXo4M)?`$llE+-hr zb2mWpyHwtNA8N5mB^DSpkcug^l_oz$)<6^lnEjXI*?-x;4^_IEx*p2>X(+y;K5A>i z%?toTnI)gqYv??Mr}MPr$zdY1+ip+)#XH=+xe!;0yj!{}8fjUyRNDa>UUAa(thI=Y zDs6bPZD+OF_Cbc~4(i+t;?4}>&J5x~Y7kc|+4#tC@WtHSE5?^H zE8@zJ`_f%eE0U`NTL(rdyM)M#zKRP=oK4UbX`MPQtS+WXZ3kG-X!ijphYP#bijyn; zQUy*9&Mw(p?vu7Wg#tH1vIm82WVvZ5tvk~|F_+X76#F1$m#9GW9dxH-=uXGbo!-Os zejQ)zIef8O|8c#q@Z4x5;9CV=ozY(JFsqY9-v{%A)j-7?4&_RpyM9d4%*umL*^ITl zysNNHuRY$=CocLWzS+11o0q@TY*?X}zy9`*@2?-3Sh>;;o0S(=9a=TIr}KAZPK4zP zT5BY0GX)swm2rBjjZ4xWRZC9}N$;P2Z+P0_{^<|5E?fYG+;pq=9r2Vn$(X~?{ zqf>7kZjt^VByCF4u5`!r^pJ(8-%GpKrFEDO@ole)eou;Db@=9oo(oES*dVk{&3AU+ zbf~^(_xw`R8Vsyc#Lw;IzCx9bk91hH=f(M@zHHF2PLW}5`}Y;9eEdC!m-n`rSL(+G zMe7s^a@)DDP?h7u9J=oPWNxX`4Nh1W`M_<%zCu-x4|bTgclVr9mm4gzE;7a~c3+`t z#|Jqa+56(0QuiB-vMv(hHb>x9#|H|$stvrXw(zp1A`KYv;6ml~yF@FG_7PftDYhFp z*6%Q`-bd;y(u+u&kOGmsI2pXGNl5*WJVp8hIF<)eccdPi3piG7;8^X1XLY=*@T^`$ zx&z{>2~uZ~+C+Yo_GRakb)wm$xr+7)aIBdWtAW&Bq}{-=1|n5JYQxEp8j5t#$MJ`b zAwLf(_MspZz7eEC2|+3h`SRf93IBe#6C(Uf{5jkgC1J;-5!P*qAm%b5r*2lms8++jEti2yJ{;c+0 zE}AtQWngSCh0AKHa9PU~F6*Si zWeruhti}qLReA0BdcViYyYLcVEC;|?zX8UotB_d7grqZRd@Xq_%joPoDUMbY9IYx< z-q>}{QkXmn4<=Z_JsW5m(sKsbmE=}4rTab=GM>;AdiJ8Lk!<<4D<|YN$XDrpr%oAn zqH&FaU}5p{XrQ<5J5I>B4fWpEl>Q}&j-(OAr${F=FjIQatfl zKSyNglde97yp$KoG_X}!Mgy2n9eGXZCu-BIYf){cok;4XciF=&vj8aDJV#{p z9>xycxV!nYP`v!nBneH%a{jRB1W5NWzF zklcleH6m6RJtYOp(^s%Oz5shBoOsx2=!oTVR9s{?Df1U{Mfs!FhMkGl`|Nu3-!Si> z!{45HDIt=xS9IjTEgAn$Biz_}Cw=zy1 z>uPmlPvWya@(M}ore6!&0VuVuc+h&)7s5pHbQUJkYKv{}H1e7WLFt9~v=vi(oZv7J zn9>PgN^wg|`bByyl4{JxNGsu&+O5iRZ?I{u@`BWqYCgvw?()Yz10XDOVX0Pf6Z#;m zd?i(xNWF>z&{bQQT>;#eH-N4@OBviNJuF#OKy@(6BBg!yqwUc?Uy>?LQAn+~-KE~Y z{z&Tm{o05&QtwHsvIkSyr>N|;RQB6c_B$urkD51(BdT>C)#@hIT2VTIj;2wsazLe( zfVDMI9!Z^PIrG$>rjS{gSngeTC^`yP5dp&G4U;wd&b4agM|>)*1&>1?wn`Wwk$ba* ztn$5(Rq7EbJ4gH$XC+d$l0TU(b>?^N=>Jt#FI5)DMQ^-R>seOyVMTQ>E2>jV&+q!4 z{}2|pCHh{mvoaGdB&IslU!0J?T6J?QA1odTj|H-39F3HWG+LyYNGp-9A&n8~1kzTd z8_``I%a65AbSuA5JQDl-g$r>DX`DzNNJ&Wdkj9HN6X^=lL!=OqP9Xh_l#Vokb1f37 z#2}H1h+CxmM9zg|g;X5rBhIx*ya;s%Nf1KGIdWeg`^mYGoRMBa`b4Dii$&^)WQjCM zBo8Dnq>4zNiZl}`0O?hv$(#!*7^xc4XPgVaMJQ5D@mrJ+l?-$b(#@j>Nm6Tdz~^=8CW~cR1B!$B20x5K^5Qnd}tl^RJGS&A0E9iyShtK zVIrUpM|O30WZ!2;##6@`eDvfakq;+6Hu5peuSHz>N%ZMsNNvd)yGI&g9*}POK~Cn~ zOfVl3Hi+mh%^b+obD5gyp`cflso0#sDvuK$BAv#p@^pf<6a2)sw0`q@5R$!|kZgBC zvgf%F>%=1PZB^4fIA^8*3EEa~XSQt+mizSA_8VrSJu#uqHA>oCFS|qv~h1b2Ty%T!4}rklLz0osXX|tKt+>CK*Tr2^DSUK^s1k9xpJ*F>((Pi|Z%7QlnjHRPz)k+wjy7Xi;gYFaA zE&|753Bryg2(NNd$?+^f_`fwL)j_~jG;}W-dOQu?Up4d^SsS{J=OR}aw=#!JwiQYG za4ZtSlgK!cXTPKk&t4^a7=4&RYPnJPV0~b)^d$OlER~X;?}-%p`QC<3pRef_3X(O- zNJ!SF3X-*tO6|dtax6>AoiT{#GI?smS!^BRFNm$8iE7Rc+ED9H-|0ajWwV|Hvi0n)v7VMFd)sI%EESAw`Wf>`yYy_)fXEYZ=SV3CBDygXmt1^7?>9JEynAVwiF5@W$ zd9`C$+sY1}USaCaB1cm0iSOo45y4(nW@QOqyX-ue1D?AoK=vbcxW`N6Y4AfJR~`ssS(|f+U=ue!p@$yXK>MN z^`Kr?$#9u`l9i`5*hPINOaHnhYgZ~&D~9pVtp1{$yYUR3*84Q_SEZ3R=L&~uvJ2p$ z8E;e!qANN>MZM3R=lP5OKjot5$xV`(hpv{JjuDf1m_UmK1X{S1lzI-1l3KX6np*Ip z7UC5~3yMk?6;I`ltFIY-xaNxDT50%>;u_2dzS5qe>2@+P@4h1RotamJ=Q$FW+)p$q zv+jY|j4Nh^>gMwvh-z)Bj>gdW^0n0)N_BZO+tPW#hjT59F1YXGKI6lSKJL@}>K_k_ zTfN6}*TK+YUB*UR)?09YsQbtdFAj9qHj84Cu60@yq)9S;a;rhb$r`^(AeFJ@J(Q

k7B$N`(x2P_wxo8*iRjst(S!iK;$qYs}z2OGiztKcoY?Ny$Lhm#*(8#b4R zdK^X{8s2D9jFq(Zs?{0ekZ;Qlg*|_lRvvF7t=!*(*;5?QU=N_dtAGZ3Vi&K*F7_%a zGc@6M$XB#U;qboesgp<`xpQ~=g(q=nFe%vDVz;8c?hdMal_X%?=lQz3D(htAg-sLx(v%Vzs514aM3Zg;T7i zNc%g8WQP<=sTv{$BJK4Hi%k0_snktD;Y@5? zy@Y}C{RY7veKrv6(Sc9TOcK-;V3Z9@i&$?d+T@+64u9`;npU>RG_M-9s~>;MHLPXq zCo^VDbSqi6?u*ftx_7s5XciOmZ{M&E9i4x4njZ1dw3Rh}e@l=KmI6u=98{&c!m(-R zDhQ|P5x(8ScM90*TfkO#1#C6BpMb4?1Z?%8aH)P3u+`|(Lca>%CWYRj&?O4>?O=WH zxbw)CsrQRi>01A@*dkZUFCW=*N3khFzxw+~;X7ZpsM0lj)v>~NI+PrDxb?WYbIYt) zS6;|KZR7;|0Z8QzqYCK`Qgfs(Fsi^-6$M+>3aP6| zZIH?%wL|L0xn@+_)zTmQ$qeCO#V!*LR%l(}UkfX{Fs$a zQp%?EKHoT`)kv#EDq$NeD?bx^O4eW0jU2Nd;csG?qNlj1|$g1VXm>Z&xTt3CqA zIsN{~Z(Poo6ZXx3E>exf)PFt#aUK-R5U1z*YE- zVJ~+|kvFGzCIhREkXEkbDlNRytcG7`NqO>pSJqF#NVs8^j7^=gfxUY$|YtKo`z^=98x@BN+SG}S;|`GUIIC-B0H-H%9*zAQ!{ zS0z(BL)t~-_GF}mx0^W zkw3NrC`)a%My`|AW=-#lQ+IW<6#`;-;+#Djj;~Xnht=l|_4(2X(Pd;>pTey*<<{J} z+kBKp(9c%p^u^Q0Z|i;WEjfP{jY}4s^fb(>r=efXqy_GtDYf5@KcpAfJzxH)Dlb3- zx&#Hsx~0&DQu{KW>wR(NQMrQca=Ai9ZlEpCo42no_f)`AW3DLEojoIXgU)e9b4h>k zp1E+vm$(U;6zwT!X@Z+fn-)x#8uasOS8?aTN%QOp!%ig{# zu6%d4@1V=yRSR0YtYo#I!k>+vdpcs^L_z4>1#zVbz}b3CC_5d5hEsUey;&K!qnCt> z6AdJ%qsaAvf##qQ$p1vd`A;jpYa{FcKS>hL=b9XQ-|LZD8W z(5q#_+}Q!=Y1Wxq(RXsAUnx#jA3#x_!pU-*wa>!gz$ekGtH--Va~Puz=W@7P9nR!x!gB+3{RXL8cUP3bvHKG#Z$ex)f+FL-ecI)4sK%2S#-El*f_8;SzOthQkf& z@GOVlsl#&|9^)`1N3c~6^s5)+(;h9=uZ7^_Qd5&bU0H#;8UgC6JbWvgD}p>Ks`yoL z9G*A=>S`INtM=frG=XPj4?bAh#C;PCw3+gP=+T!V1Y*<^q)~Z6|G2jm8c>hvkEMo4 zosj?pB~r><(sAHQPF%4xH_;kOk-4OLT(J{Z*=wonx2f!}sqAl8 zhhKg3Cyv^~xr3t>Ep==!SB!w$Ra3ZKR{(xBf!j6Jfb=xXDod{L0?)0wT+g&KEw95Z zf)*RiEiT{|%_SA%iom@5xo<0eg^|)5*G{#t`K^?2`d3K~!<^q`McQ7r`To>OR;(|5 zS|`!z1DC~{WktGS#)@>4#Sw@8qZhkzkX6yyL=CKG^8g?AvfE3b&Qukb^=gyF7c+L7 zR`K*cS)CsepjGy;#JlWqT;gZ**B2|I<6I=_$pPsQ(ruA!nu*jM=_Jx!N+FFvI`6pH z&*r|Hlxi;SgNVaI^1p=iK%_XN4M^9K9#N`=NXL-wBBfCZ=`W--q(TyBWz$lmvPVQJ zCYuu4ydY8>k^@p1q!%gmmZRL)5ebB<;I!1wrkJ=Q;*drlRYm%jNH(oRia@ePvY-^w z1|)l=Qj}^f(lMk)NM$I6^cPZdq?akxMx?TYUbT~b&27rolTvNO72$AHwmNr5DkqW+ zI|p`0^4vI$04;A#|3mf&SJ}5i3coL_*4g|InSnY9RQ4Pyd!`D|@@6%B6RY8aSq(qM zYWP}K!~5p9@4*x2npAng?h}}UC*m3T9#k}zMwn9_6`(~t^VY^VCSc(tpC_KVSx)IH z;*iiIqGWR;>wJq53a0gv)S(M*f;WZdA6p!llfULZ01caTz8-6W(6)rO+eu#tW{1jKB&#H!pcYn5uao9;axV)%M9{qPKvaWa;IMjBt??DgR_pHjzmBDtLVq= zjG)1cptl%7FEN51>=-{Qpl$GZs(m}v9!$089E=y?x32!CL*QDnweiq7lJ=b?lRvcIAJqd)+m+~WRgY4>$Wl%QtT$w4}-0CK7)ofBeB$cb347V`WmKVo;J3_Lkhbr<% zw!JDv_TvxbVK!o@v;%6Ca08~hHfooh%zk$#N@mU zW?T6bPnCOElySjRc`3zUUWviH9Y2WK-5`U~u@s59dXtKMMe5RBA~G~EDH6|fPOKwo zfSzjx!Ogh^$U%>Zvz#y;cfxe$Sx9Skp2;+=2HA(5>C@+_Y?V!jq@5<0dz`Hz7Dj&T zgf51{KRFr&68~iA^kRnyHkSsi6(z-eDbu7tO4)Myoc0Wqd_b{ph=tqwJ`bMAR)g6p z5}!5LNJ2-4IjNE|d`V90Sb-0svK&46ILQZnT-yS&U;fKX6Af#nK%_D}PGyT!CxEI7 z1E-6cDXTkKvd7fCgrR;7~KbjcKElOW@a)K8`;V5#VwajCL9`yKL*no@}$U>DuME;_I5 zBBn{fOp|UgO-feNq_3AsLf}uDBd10vb(6*3M|Wrj*wSKu;&E%54bsan>A6iO)~tX^ zNglN?dDLw`C8gTv!<x5e4)pHUjfNhtCQYiLFX0_&o3)|qn3WPDZ`$te7czEtZwrvO z=L}U1#vUfIPrOmak$%>S^dx1;CuVwL!;Hn1&c(R=ih?P{P2>vAjWe!P$9RFLU)3~9 zbqi1DnMsj&RyyGBGVgAYtTM)85O>BPo{K@;h{@9sCQnJE`o_x+#9scEOrF$N95p9y zJkdZp=t?}%VmxGa1IS4-Ay1vXf2ifAM_*7<2=GgcA4<2^r9wEF?W|PddDM%H5;}eM+D!Fe4gJ(~s&OI@LdeU|F zL`y_VL`y_d3lC~Fs}lB*F_3TIShcZ-$ZgT<%Ab*GqKqN4nkM>|kJ-}5BjKfA*L&n$ z=uj8Zp*Cmq91FDJ@1D}uZmp!PwVt!X!*;Yc;z&f$pa$1GWcACEVO$*lO+Lu#3T8B| z%6Rk-p;s&dM~njph2u5)Q00Uh?=^rOtB-}ftJ^puw){+$SsqPhx$%dYhR{+ud8WCf zd>Uk|!@5mTJ9@z8%AVY6xF2rNCt4`GI!M0?+WeKauZU@nv9WXb5)#CANH(VxvSQN~Ka>=a^@ z;gesMiE;LeeknudgKRQJ{b@t6F!S|{|j zy5#RL8lHv;^R$JAa$dD}M>`3N@Z6|ebgQUWPx{w2tVH#}F4|HCQ%0{VRrvO^xv=bH zuEnCJB=1Yj{y`&eERB3DS6D!kZAN9A-$2nf7c?x0f|JbSCdqWTC>HxNEYSs6qAmnl z1Xqyud&`cF(~DY&2if3{5qubA!vYmgbto$l#egd~qp+siU$-yGHo6*n`jwKh)^gdb z8;2AOcbAqoj2~p^^rQLNSuKX1w)rZlwW%%|L+5KJy#`t>xZj}82$w$_)v<8-bML&@ z|J=QIUiE~20%G!-QfGX$W$6X?9qM?y{CRfX<(sB_iWiFm_``DK?cLTc&K@CtmN)8$-%D3hc7;x?F;8H*jM0rJ+YgI z;#YOTgD{Jv4||pL(F9W^Cwim+xTCUqj0|uKW0EM$#BD7Tx4ul=wlZ-GQX8!26ylZN z-jjlg*~-nfF^793)BMqQ$TWq-KIky><9_s|JLpTt(3jq$FTKvlc}_*qeL#J@B;B+0 z$b!h?NVmgS&c0y5N=hyY{$dvvn)RU1=E^N;LMzRTAfx~OA5S+K)HeO^7HNmm({`oZ zxbSG`qg3RMTCBJpispg!45zFP;0>#6JGiLz=VHWe&En@&y4w{W;gJvQ)H0a@qH62 zS&nr0W>4b0QeQQwTc^l>-1hEkS=sVEhw6LF%`0`V!Qa+JM!J2yuVod>VGi%??K!v9 zxd!{Ji+t#|ZePo)mV+G@?VT~FR7!(r>mp;_mhNj=&2o^#&wCT2OFe23U|l>!^0vRN zW;t-g&AsKKD?e)BjP&`wDR}=0n(@M;23E@og}Ak@`%N{=t|BEyigYDLq{c{{EgpQ| zX#FnHwxZdhxk|B~5h8^mRYPje$)=0sg=C4;hLcSbDLkQEoz#i(RzC|0=Y`=--m$(f z%#&{&mKGWCN$rMJZ>@0iI#Rg7_Zx(PGI^k2k6u0i_9&|KrjmlXS|SEUfLmGtLcEPZVH!b z@7qGZ`V#upC<;NpI!K|d)7-8v54t?z!JoyOEb8}i=i-UB?pG#^E?r6JSAQ)oa`oMi zCX1@}T2|!h^a>9aOn%V4QI)R!Z6O2631)DD4FX4)n^-HdL>-||?e8drhLHfN=8F`H zbQNhV(n3nTE|LYQwqrj=?kQ#l&afs{KP|mRO-UP>LeU2%O1kPN(7DNjMN3G zr%2^ye(LMcahdRAdIWT^w)ChJv9BkR7g8@IPmyLI1t9f7>LpSlQZQ0~q~0QxixMdm z$tR%EgVCG3F1iaU_b-B8r4S&DjfR#C4; zN%1pbQs0E`NK+|QQ%YR{jbjd}OttXxol4ywySn!P zU`-|9W58*uZ5H~~6&}WDetFdkKgq+DH)s8AZb31yx(K4rx1E2n9$P*)IfB4F+;TO>Vtr;fthsrX=et>e9;=bGX-R^@N_#HHtzoTg|s^IiV{j z%unfJ{dyTpJ&kK9ZWk|}f|nI2{p#Z3LK&}&y5a$v$=y3LuXl3tnYxB9=e3X8tpLOP!mwA*r za{ca)<@{MRE?IEW(=e-QacgbleTm@aO*@k_kJFtKSo%I_Fy(hU2y5I0gN-3B2v3L#@So3)sFW*6e=zD5DkB^v_M<=zc%A61CFK8hEn^?=XTr5d@i(? zyIi3@H}E;no1ShfKf}IYrD2?YE?0!?x0R=0f|QLGvzWk58`JxX@=m{e1V`4=%SXJ*D5wo_~5Ido+uy{O(?vgyo&DRnSZ<`oJeB zTw0i{203A}`u|s9vJ@h!MPQ`wNkyvqzlq5L6&4N`3`SRT9)==ztq?qydMZl=&owR! zOG_|WY2D|#3E1eb7@;Rsgr0Oo=t-^NUVQ;8%NbUd1+1)@Fq2-0Pm7z{;{=C+mtkcc zgO#-uRu*`)W^#hc;Flnx)e(473BOd2D$Bi*Tt%uW|3Akc?(zqCA{$^qVc>~s2rOtN zuplMPL9#}oR3N3yB?WL3mAK-k+{9~g6K0d5xMFRt$j|oXCh{y*IQU@2)Z=b_ap=5v;7*h&HgYRAmpQvQJUjYpLwFsqA-7wjVWb zm?jmkBcv~wXConfRRLnv-hlKXKeVM3cpBza9av_jo#{9Xw%godGj6d9w`eY@h+Ody zzuA%dF2zk4Db2p~aF&Jh_Y(49xk`9gy7rcO~~fN^<`jCP)y#P|5wDqVm`x z-B-jo_LT)uU7%)V0yUip)C{sC0;D$~nd<>3`LKq*_fz*3UpXqrMGF7^ch=A%32@#` z4)LE~tcVVSkYxk=>LAiBku1PrxgsSZ-JujxAksOcdjh($0EZO@=;}8CUB&$^QW#Pk zQVP;TN`b@Lk8~R;l~PDokscwXQ>vv%7T~a6bP}m>XDNkbgH#Hsh)5Q1iR22xs+^NV z&=pOPQg1oReIZpwDlU=*IIJ+FT1X`*g%pQmhg6bMtwq|8kT##O(6of1b z2w82AUa2RgAY|E)bM8iFx}``KWTv|!^+YOPPepM=8SSMKmsXT!$cL`7`%>9kRb|&s z7{AJMV-)qihKltjwrCTvMT7B2_QJEGu?gT)Nv}(l7g)ZzA>W1KRhe~nj?63Kr+S~K znYj_5N;TYXRq;u>SV+AG&ydQ#g-=1l&5-X>fhV13 zMpNN5(OvEt5wcW>>*r1nB{6&^Eol`|(7lL)UPlykKcb+wlOGxkT;rC4Ym}G1R6^a` zZ(1^#==YkWDiS@Ac?~$pX-t}16`Mt9!L8(Vbee3lF~B*wa!ov6D9Ip+b`UN z)Rj@-9|j*wksy(6_@qbSlfFjpeo{qqQS)BZe0-U#HD4=Xr-yA^9jW&0DXR<@x$aG9 zWI_k$$~Cv#)N|!$Zn=r)YQhgPaaVGcNS^t{nqaK1R-nZZ9B()hKEkg>T=`L8Cri=L zOEI37BB!ks8BL{#gfB(!UW&>tMYKsN71l-K!=b8@h)k{P;tz=aF^!O=Lb8lZ@+gR~ zsvKjejEl5-s!~(IXTgv=4Jhf6%(jpXZ^jn3;$klOz-1r3{?y892jv;#KKOT?m5? zR_Vcdaqwzm!YW3CJtV?*uU;^hYTGIgT^0q*M95OciZ1iQ{5HxqIwtexdbEsR*I$^v z44m6pb_iyx%3JoVHN4Fl)7PvqeZU&i4dOJ1(#qmcO83E2NfY z%T@{haD#6%{4{$OHj2rBECtibAYthzfGhJvCut-(XoIuFE~sG|AWOltQr3Cb!O&@w zkW1Qwu24+UjsAi2HOEo^>5QW_7)RSOj($$ZT0xezj)#RUVIXbGK>9fYX$1ySJ540K zm_+wxFHD1s+-ZwNob;a?t>J%_9VLYcy=N7?@!mhldgRnUHcdnjX#cA+e2n;clBm%)Y4OB zf&Bkun;2)o7*~pk3*LjngB+=|rvy-_a{G`#w8g?Jdqq3dVmebY= z{bZMOEZ})CJ)BR;8xW*$m*;o`a>`VHD#ON`NsLy?M}Zh4urxBS_*8z6K?V&Q?%vSp zHS)|m2zqEym3%h`Qc z&Th=@W_mZMl7b=q76_g92}g{EZw5&}1EUGQ(OlB&(^+m>#^4!?DH_X+DHc;S7Q-l( zsd6myrC7St*o?7La*~d5!~pGVI9X9GP1U7LHl(QwKVA7T%x|ceKLb7Uiu~+hyw!%X z#FY_DSRB0>}*}v6BHg#!hJ?J}^GkSJm^sJ_+@5hzMN^=+7M20rl z5D)MI&DBh1q*-ktKkshQ>@PA??Jr{Vq1s=>D28liA^27LMA;N1$2BVsDpFNtlMeH` z!Ny%ZBkAEPNsAYQs{+oWffG$S94CY=V_ZhErX-#sJyuy4X`jKgy;o(TOAi~*9%cT~ z^so_54+nd9^THt?zZ%sGbpsChflQwc(B7l;rcW_R7i2>f46j2>n!lBo0ccxo>9v zG=%w6(n;!lDD{4p<{m}nVq!6QUy=Zq>KR6PwQWZ6#b;!q= zyc4bI*{Po*%;j^+S~uR8V$e%soQ;v^QW}SEaj}} zpwlG?D zngeHcZ&3zPOV5MQj3zsV%Km`ImKoT^lQho6$a5)k86uan2a4tMt|2)DaAhXEPiJEs zSGD1zav%`5cuNJTdeL#lGf(zso_rXqXaNocmyYpbKF!ygCS~&t>YV-=g>&{G{GS2% zW{(}qYAi^1n(w=cOk=refyU6;YIXd62bVv6+<*J<;!yW;A6{JN-0fm$xbs_cb_l*{ zL!~Z{8r7-f^5;PJjUQeNcRu<{=q%?~H2p;x+YM?4O+Gn0PEiq6xLCv{_#KUB>9mR#B{|G(`EeOcS zy|B~%v5RJ^XP_R3(TBO%MaNPe&U#MCVt!)C6_dymuOX%KlYeF0x$^EWc}~d+djT(% zX;zM@wh5i|9bS#6|Duy|mc(;P*8glsmx`t`iIUad6iOC_pHs3jD8A+j=Nd}i@SKt* zy=1PI1+LS4DP*Qi*|jKHH$qY;hdiv7erH$e*^s|a-AKRv;Lf#EyV4eh_}smbelR`# zLY?>LrQcfq!zZ7Iq;2dy{O`jH8-1Ue3?(c5Q9y%Jmln3D7j-603Uv5d3Y_-8FaJyb z&)qL8G}v6Yx&6sT-|hY3ob~;$PMVXhe*Sg9d$wcyy4j0-sgZ!Qekvm*tfoKj zau_hG1cWTnui8V%DlPgLDL%^T=K(fdify00JMxt`27GAsvd=~LVn5E_5LwvK`kHT{ zDFIEay83+NUhMSjIgy1MTmSA`XzGUq;a=>w*&jttbhf_WJ7H=-W2+TD-*qmQ zGCMGGVpHoR-$LP68e0A6GoW*^+q1hzPHbj<+;>8FfRoi_pBFk8do;UAKuRXstR*F;|LBr&vvqE_M*f0qJu})ez|;q)H-PS|5Eerp136 z71=Jljh{OgKloy`Ce<7D_8Zyqi!WpL_*9))w`7y*e!ZhcwoLhQ_2miw9^eH|Wy9k4 zUyJIkXh|uTC+r&vy`y_tgVHg(3;9NMDDmUSX%RK1)qSn@!0N|axmvsx`{|4sAGy6$ zw{EfM8r{2>ap)WqQ{6YNL-1pkM@Q?(cCHcoHcpT5b$BnPR&?T02w69UT@?-?YcYhZ zzl4xgyq^%VzJieTz7VpOLdZHoAt7X4eXU}|zSNOrs&s9U*0OkF$t6O_`k`)>uIt`f zTI6b5p}{mu=~6uL*El&i*6PBouKoAN7P&fjk}xNx%L#<@a`mkW5&K3)3cc!=7{NI> z3%x4RUFcOCk^V$#hSWu*+en3BT)l(4O4*8Z z5osIJI!YnE&`G54kk(VmE}>ojb&WcmyE4J6#`tf~+D+eiQ9-f(5-8TVxSp%u0Bx)kpN%VRSvkD;(U&cgE8T&2nz;f?kAEw_(M z_PPk1#b59oUs1a=<;7?xe?X!+2K#0s_f$`CIGs8nT`bZ8PT4EUs%lLRJYbmr29=_3Kx6mmLFCWPw0MmVu?Y(ovuyilJpt@*f@knb*Zu z^5lET!~VBacFw?@-E+@(@X3Iuyaqg_HSmPP^=LOiuE-`cJzaxb-uo^jat_Kw}5nj-&g@&DaMcBIT|S$hrZgq<$P%EsXQ|+ zh8BpW+(}#6OXZ1ib>G!9z70Rp1hke0fJ^!dpJ=Msk8?%yzzj*37M!0sH0n(n)^urD z?$Ud`a-rg|s1EfN6sxgIHX zeWvuNLCK6K^n{+hs3+1)z70api^q|#(xYXyGwwv=8s;Hn(ebr;WYsd`Hn`>ndbuII z%CGW9w$qnVt1gm%q*j;DKJDeXZ)qtldyKSfy{dmNR$xgbL1kT;)i$AQO*uLTGz%i) zOHz0?e{_^T>eB)5>N>d6flpg>vyJ-d*Wrm_wXff8L)Ns?XMZa%)Yw zHFs_eh+BS2l{tNJPCs$iLi?x>;Ra=DZ^^?jxu)05o0IN$nCL?V;-LgM0x@J(b7f^d7xm#luCSkm-Ig2RNB89s zROFrtSb8dA)d*g_bKGiUZq>wdx$wo8_@YdT_WY%Rr^!pc1ay~9_ zok;@MSqo|BSkX-#zqy*atkG8Fk43f?BvP=*`#zUH%6jz|LQ~Yr`d;pS(T^g2_l>%u z4hu!fVcj=SU*s@A9sY~MmFlpR9A;3i6zd7Z)996gc&fjtqr)|$z*l|bD-S${5w%l@ zQFg}%Zusb+!@JhDKic*1<1m23nBLX(EQ4}i(NUIuX{glcM_wTwdskKvX)6*Ktj7EyFF;2i zM;fRrB|RI|m4a(MBh;0GYvmK_N-?sE#y5}qb>noYgkjS7Ml2UXRdK0kZMa#}H?A#h z;y&v*K&wS11!&a~@>Lk*D=IsM%1%<1eT~YlD3x7n_ML83mcI(U>@nR;*W4qFMqMc& z)MBwzq+>{+t^z?_4L~}BbdOTaBvs=h zh*cMbSY-q1DiGAw5~Qn0psubWeTVcH5~!;{P*)d`9w33bx{CAyT&ou(6T}A8RbWez zY9Lu4fx5bi)C#GrfTwIgT?M}7DE9@PsuB{YtE)&KA=N+vbrlHeY6+4J5~!=INZ%nj zAc49H1a);0sR5RwtCd1^Yj>I+u>Y4Kq}v(p>W3=lcg?t zDVJy+T_M?PP;w0PwssF@Yxi4ZC|xQlE$mhhPR^jmSJnP&g#5 z+pQPqj>(zY6c*#z>su^@kXR?CS&^SYx9Qly8 z!C+u2>PqdY&V6}P6&1Ku6Nyz%_r<3}T`?25+96&t1h;91Lf-mD5)bs)4Jt$MCu*`a z4ZStvX=~sODutmnjF#5)?yXf3Qj?0P_%A(1OJ%0pyhA*=|H;@W<07a`EF~6$v8XF1 zl1>q9W4K2zJLoYsAvsK*eoe7_&M|yWl|M4}CDa5UIkQh?5WA8l_hcru5*&|Zz+K6g zh(kyzx1PPM`0&7$&58a9=qY5i^}0uJS&r zY?DpQYX{R%4ds4@c-VUD)%Q!%mq%;Po!Y7BuLfXQ){~sHp6XW2=k;{s1+b@iTPl}V zb|axTLz%mo6?LVq_>53jQ{`umq$8-p&o0h3hL>NbRdr+FT*?z~PhT3&z*&`n)8&b5 z6%bZ*rvA*53}*4GT*IU9Wz8{lq-{GgNtdOAd-M~FnJM0k`vol> zNx3HAKrrY_5&p)c|4k7=TEO)z4_b`pwlhH(^DmQ?!J)k84$ z(73D>bveDg-K8hfM_oyth_Snnn*gzzBzMU^D|#AND$-BTbtjC> z{d`p|Z&@>%c4nSD7i32xxUfS4rS&H{@lFI#`^V|B6K&J}eKD-+K3RK%)8s&y21pO>8UqIB>%Y(H)&GrT%WR^_Z| zawOIpwuvH0K(x?vA3UUMzf0GiLf4)|*B-wPv$#K9`vQg2y1+WvPG)W6vd-ER$t;|Q z&0BbfpKf9*hm(o+L=o(Xr_UxY&8?bhoA5$S$)_*!s&wXDmi!>rKE=V2O`5I{R+?RE z&>m@OC8eqL6~okjxBL;4BrPz&u=^mH%05J8&+8a3gL@E3{K>$04ncgL2YbnRi@X6r zPsO#$$v&yTJN}I9lmD)a@(8~R!si8mw1+k2Jr2wpTJ$UdeoECEaP=jImRI!A_V#k0(soTlcFhd}MeDg}ve`Z^A7aygRQ5(yz9VY@UnzAYNBU?R6rwucCosr+F;`{AKi^N-8(P zWppg%hIon$10?O>IC#Nvh_989HpjDP6h2xz9P(a@fHZ`eR1*E}2HN{Tz3EfH-Fuz% z*|54r&Nc};)RpoX$s#?FkWAE-qF>SK3TC&ET=x_)0Z*0d#vi7hOL;Kz?D|k&R0ykh zgG*03prDMt!me_mk`t)Txisy~bnZi$Kb>X%w3+$S5av%wn<-d3p}A0dHL)FP)|?j; zB`;=0p6wC+FXolTYshjjD!JTL>ta#TLa}u3;HcBNYz(Y2j%>AQNpnqjWM$?~&X5d) zUZ?BsN*i9h#4@gYX{x$1TVFZTvj<(~-!Dtgt|0CIXN(gKd*$gR3ANHhT}kwnr&FZg zE)Ux|eR%L6@ZihHxM^_TsV!pRFiUzoc`~r^(IlsbYrKy}(6X1&vOCeTXVJ3lsqVgX z8U<*+7;>BxNFB$PxQ2;x9~Kt3 zWVMSjR-1;hVwrtW`LTEK@tSf*Jk|SIJqSUEX|fBb>;g7KG*164Z4*`;N&qaRrPihb zbYWMz{RT5}RZm?gCJB%)4ur$ZlNT^gc2N!lf>dv*AXP7FAs(y99|uAg#aH*wI!#Ij z09!|EflJ;4@gyl<@Z;Ln#Z@T}0<-3~`Oy{WS6F);$&WId#FhmkSsVL_n=or|S5{*| zAC)UlA|K+t)N)fDjiK}9YpXYu>hfr|rSpOh=UNtBaDTA-j1MpRxCDRnzbGc@n#_(hgC?Jx9jna))h>Xs6>Q2Gh!br%1VcGWUR#AFlQ=^k5G|;|~qn zMKTFa%V`_OE>eH`7~qWHs}a(rdzF`_9&dxUzyohV9PVKc`h-<1dU>k2D%`^v+XoV! zo_&WLT8{}%mi*i)#KdzoT+Iq(#@S}vDaW=eX1OX z15ljzt)yd5p|+D$ZG*1#??r8|rM9c6aH>;Gpx0sqzn!&rSJu!|`Cb0Mu}ye2O!SZB zd%J=y7mg?{^aKBEM`wt$tKJ% z)jo3s-wa~yqSDh#%v}bl04wI>`4y~X+_|{>|DKR8u~#ITs=KmRm^^i2@-zz%g1z>l zL%`i$l3k)Xnr7QaP+kQo{5$6zOvvOZVx!j*8{M}Pvvj6aYj~S&nO23#BxhrRNCg?U zWeDRtl;39la4vO4_c`Ol7z*MsSHu`%^W|i<`Eri=CTjn{Ka5=Ri13p+`CZLuXtQml zUIxoU-wrAW^MhK<&DxO(n`XR~JGYo`zLZklM?=!W({JrcUzh%{aeDH)^we{QFFfa6 zJ?C9L=Ur`h&bxZfyL!&Mdd|CA?*<_ycLdgR-jyEQDm%og!gJnLD6i6Vm`cxiS5L6B zGTBzoc~{SQS9u{>8Hd1n&bxZfyL!&Mf{Haqcu335g}{2wyL!&M60Vec7r&KLk4Fl) zt3aq&&v{p1tDf_&p7XAH+Uh7(8bMBZ+)VH}@9H`4D&L$B1{@jx2YFZb(*08UMGV|> zW|PGSlkPX2u;cx;Gi^(}etG=Dh}f8wou-s2^ljZEKC}MNYZSNsaT|ND5idA0#Q9$=a6& zk@4`vD7r4N?O-EwTsm;>a)cIH5rl6=ESHrnAA|WI5+;xKO0JgAGYY0sI~DR0{lPPD zN-YDg+GsARI9Hq~R~$Kwu&b$nRH~MjCguW2CD=)-`PLu;ypGbkmI7~h9L6Ovc!Je} zL708q%$CojBEYKXWhVDv%wDOPmP1URC;QH7}z1T1o_b zDecOh-*wI9^O|9~wAf+Kz#hr8fZS|t9GDo_z&tVjFsF%e9`^edLYGSTm`=in@rS#B zPO-E2!xh4tGMxIL3JE$VeOV6p!3qqbb}HMU9CIgNc>ZtANge9lty?0(Ag0AfF_@MR zK;1T6GMa#-=`tNidk~WJb4r%U#tmKh3A&?P4T;=K6(l7qmd-sUNuWCkkMr4>CntX) zuR=ws{pXY{sl#0DojcTYo^mKuF5&~SNDZWeO9$*I)8vf2!qiDpc(_!}-%NsEqv0xc z@MP8|%P>){Y$N@;Gc7zwVYr+&a;WmbnJFJ)sy0>5$x_}R=D(F#K`KU%O=7$$5?y`1 zr&Ac0n(+*iE-a|-Tp0o?6;bbjXP+qB%J}+)RE5ylS9+E+Oa%{u3Z6U<`zM;>PP3?1 zg}dyFxRu0+AQCS8smgpu{F(sV<$cP}v~*8?Pyr{L=Wu#08$vBkt!6Y;9F-v)r7)JJ zFdw2Zw`UZ^vgHp&WWSg-sVVtWkw1_!*%5+V+UDo=}xhIccWonsrmWzhnU@pm?hpkVqGMfa^Z=23yC_rA8N(>xFn|xKqzvj|+ z-r7fp8cE-|9Jodo){hsme%ze(Wg z{&DudBCuplZZ{c_rC?e~${xsVOAY;;@!@Pll07+GY$Fo^Sz<>8C8j9T1X!28sg!+7 zjZ7w%M$R}6AW22HBNctW%1Sr-(0IFOmw1Y<%h0Ox-z?w{mZ};{9gU^Cj>a-}z%s5K zaCfi}yWl^>!+-Es{D%#Ur~`Qc4)6j*>Ae85(UowxG-q!A;DUATB3bBQ9{q&(BzGqW zDr?=4Eq|CVVj;_84JsH1%BVrH{QzA3K_xs48>(73Pvm zwJHiFq&<>-#@@i$$95?SynxZ7O%PrL_)2eEmB)=cc{a7J_FnLzw)axoQ_IV$)gWeW z$)}lOtq0`e1ITAD%U=2EXwh(vm`lplGBL`0F};vMmx$Y(R3TZNW3g!~6Wbuo#U>pr zTGq8zc{(wT-pY_|7Qsl=5mLhS5{N zkz4`*7Wh^zTGbO#H3Q~*MEw$4EvUv`%i%#wzOmeOsZD5|=9gX!xa+WH#r{B-Kesp^ z{W-LL(2^f4Lk@

9YM`sHVdxW4l3ZzyFilYN&ZKwvAXNHeh?>MwoP%Vzfy#Zk3Gj z7qs^rOoHMoh%OJXy&ekNYxLn0+pA!28E+CPpU*lt!>eSuT`awsM3s4%c9_e~D#ubD zim}29e`AJJy3(BEs>-YNt(n-xaoEKkbndI@+&$^sSJSzB(YeQ8Wm zc^Rr<_ponO`~mEqUd)Nt5?A#$aaCUvSM|OE$G?pc{53}K`+7z&U8Jejh}tSqXU3S- z8qv3Z^6vKF?oG99^c^k6`8cKnYInNJR0%lQ<2`H?hcX*tv=$urDNUuOvyqc@m7Qe+ z!Zxf|&0&Gl*@KDN6B`g_#&qSQ+48KIXl#@2>BMZ&pp8->rRrfwJz;^wBuRW!C*qT5 zfhMyDP1cts<*m0h>spmRV6+F}IVI~E1$LQ8$zp}6qXKK``HQm6lyxTXb4nIHug>Cm zBFw6Q+$EZntmOXbzg$S$8S+LWYS>5l2?Aq!8xmv(qz z1xx$1zmE^t@q3GqGo|h=Y*DXKpY&VHf9N|mByD5wz=u+x<{uPTnA#%5`_bf}37bA! zKjr3o>o=EZZhxu5&%X{B?l`t@sbLetKmTFP&G#B?{a3Y$bI*!Avgz2qtFKQ;-~ZW( z+V{We{Zol*6<2*N`l!a}QvAfg37@ZYvAQ{+Y?pT5eD=%0mS2Q6wW{v3-@Vwu*{dT9 zJH=k{Z8@bx6RUT80^N(9n>{14@SCx}`c|JB`li)19}D+lmu8QREZijaC*MU=OEk9n z(kHHSvFo#aBMZC4p7O089@^0Ah>vUMVs~e|MHX%zd(?MPcnK$~n?6_FilxnViu|}m z?1A5Y4i9y3zV8#}RwiwBWuzZ|yS>YKK!|8IXfLAeqF8;A_IDB~B|@aFB9*WgDG(_U zDV|bxB3U49M_NNETan^iMT$XMPN}*@@B6sA7EYV}MfV9UVi%W_Qm>12wWCNQk>-jN zYF#w--MOdxi`ExyCdFz?F&m1tK?O_BC@5XlZHlu|WB3PjrL7Z#cJO;V|wON#hS zY+U6H%dwXyoPHy^a-L|NVv~MFxB}uygUW6~ zNh0pvu(XKvmOCTAv77!^ctG{q#j3}*acvp<@r-g4-AdH0TO_(d_wN64Xc!Yy&UbW& zjtzb+H$7s+w1675i@w&Q?f#F;%&u+S01A<#YL{Z8`5M^)n3brT%BIw!Gg&Tx;LuQwZCml5kG;M zjGn;>1eFy#H?dY^i8>AU`R?!7*&%vl_ei(c`67iPT}2v;w2)G-i)7&{(kDoZDTQQ% z^aavVO4V&Re&QimDRq}wN4s@e+0ojvM_|Oh#2IsZ9h{N6AoUcf+{{mX9Xc+1E!wR| zKnH6}k4h2ydLnrt^+NI#X$DdNQXiyVA|)aPBlSn>EmFBCkwTGt0vbISy~*pMd+~#1 z|15dlFZ6c#;m3PddJwTCz^?STgtJajpYFUov{I+m{qHoIvh4q{cjj?5r~Us&(wE4L zrS9y5ib_U>iDb*tic-{&8Cu9TWEokq#gx5>lD)FVkdU#>OqM8HF%xbxV=P5uFQ%y9 z>vc6wojU52&T-%OuYbLTNcmwStu1 zAElHbX*35QE92SUL-)sT`q}o$ryXpDrNIo=uyrfgmz|MHw^$SOA@ zoKXLXS|}3ni#ksAYK}k7KV7wV)c&PB<5oOlRO&Ov+9L;1Ir(j%3HKUXS`|LF*@^!TLeTuzuubm5~89R%qe1 zvRAcE9vTvcif>d06@Qp39+o3hrkr{+dB6ZXMLbnap1nWMo(+u)FQ`EJv3bnrqGlJ- zWfWzT;KCg`bBAlV!-|wnk8sUzV`LmdSg?R(#pCn26_?kNj{w`IiYXMosj6wg?i#a- z^u?hLtirQ5jt^3Sbmd9aurmj))UAfkskG1|wyr&J+xxL`y@JM-U%c?;$Yp$4Gsh)G zG_&!`VAIEFbD#0i2*8(({DN0|z)SU59OrfY*pUHUbNfaQy<^|qVQixd_9w+>cSo@; zKD!U*Hct&NvHcl5wXQtdij;a{_mf%cn!L_Q9~q#={TFCFq~fI3w6Y~mAc#+FJzAM< zi4~8^W<-Y;Q9z-|Yz)JB6uomVM>V>@K2>}S`cwg4>{DG@gu1q|9qO8SSJbs{vtYSN zG$X5f_0T!Cqs;iC4d;H>i`r^xUHtKv7Eb*mhRP*Ga7ni{Lw`u(?IKq&= zIKsYg9KnqzpvC*$hc@7~4pXcoAJ9rMrF!EUpYu60=QY;lWh+=xF-GTUMl)D&orm`D z*T!0tk3Ky+tWDZa7lyS-|LJhtz$^aEeYQlYPxRTcMg8RcUN%}5_p5!9*=fJd1>d8a zJDFWpjZIi(w8PGRO3(4e{1S>UM))#0Qr$b4zf^O^%6SPJu+@xZuAodXzPRB_(79}f z^{r!UXD3WHzHoP~pHeR z@tkJ!KKxUtdd!?WhxN9&`OhO@Ag$p8*B?utf8%a%twi13OO4jqIhzgteEptUN5AUi zvS!MU;|^4dnd5YJr#HWMX3@AF67y4ZK7 zSp!gmYq0)9PVmQk!L9a|!;=F3}R8?>iQ>2KOjf0KQk4Fe~6c{7?Ig#kP}rLs@G zqv~D4+F)mhxq5E9BXpNJ{1nENE>e04NxvH;2TIo|Ww8{c$&_x_A868WRyFUazya{b zJg0}BHQWHvQkZSdU6iBHx zrJ5{7X%{6!O6n}t8`617rj+Wi6s3oh%qi7nDN9JT=<~3o^l3YkvV;dhpSk3=OfRnw zsTQ3Q)|3Y4XPif*{)W7BDfgZpCa9&-!QvP$KsU0Lh`1^xVTH?*J_w^9d5vif(i&pv zS{zGL|3XvmC9+`{kqwGjy5s-Hbvk6^k;5s0-11-O+-3~kamL`ylo^8uj|9rM zrz1)pJ_qBo=trL6jw8G{$BH|M^?DnPU65&xr>Wx{m47TX|GUIemAosyD2Zk=WhbBx?`VlQ zt%^*;DC55B^HecTa5j}M>Zy`U`e&6u@J`*1)$y&IEKY?wE~ zT}tQhi$YvyU6Q_nR`<3>z@Q3e95l6O_fyLu0!YIGkwh^~APKOB@*$-BaBoW?A^ zO5Rl^@2cXdSe3jhk3~#!_GFTC$(xnDt7>K709W#^;IDa)bEcw3CgmCBlt{8-Ke}`e zN+s_Kuj4YXvy=t5l1?WVgsrk>g;(;f)Uww#F$-5%lDoe_TP|3SOgzF0uek*xbfsM+Gtt$5)U3tXvfOK6e zc~_XBlri)uRjTA&Rr0RTPfp^b!-s`!A+@9sPU{6D!|8qSWSv&!5;D?jh4`E1I7N@% z$<%)tA7XT$LO=!;ahJt*P zSaJ);l3O^0=k$^MCiJ1xM;OREuBdF3I=tVCTL`4Y-CM=1@a{8{OO(9g5+#qt5+w#q z=y`9tiTF#7%(bQ@$wluNm7q#)bG@>WrhjK`2?e+r?`c6`mtxaPq=!LDT(wYwx)LcZ z%1JNjX^?#>@0nljtGrCVy!&}?GEZ)rnU}dQ@9D(6KTqZ!_RDFXmz~r7cy9KieSUAd z=bg#;EiW`L@8p1tFY+D?SW;6f@6DL~x1Vq7K7JALR_mklfVbM41iY1D>{}FAHH`%> z<${Hk`?J|8*Z5!i0$_EsdUGuwb%3u9Yg-uAIDG2t={wG^kE|QEaK)0O@c>^PZE9iU zJpGiPNBqNjBwRtiHXOx|HirHR#UC1RKBzcnYCuc3gYoF_&s;A;(dm^Dq)8q-p1J5p8 zU;Eb%*K}2;+a5@$(kywb@yfIDVYSmbMCz){w2exr(mZ*z@#VAC!)m|oFjZH@&o(UK z$L7f%lb@co3~lnJLmyo=KilP$Mo!NDt;znA&>B*kPi+K>#jk~QPY2R8O2Z&krxZ)c zo01E676Qqik{cywNDJ3Ma-!rw$&ve7UF}T=oyaPFwtd^4YMwl>7WPFcGXhcRGq|^^m{3=Kulr$+>a%Yq}LP{KEa@xx8_i;781x4c& z5GXZ)KpFRaV%pq)eQmYuthv6U=9C_Z-y5dS{q<`XK(OKuL;;`R(fhAnhWp2Xk~1>( zO4Z<-zQ8T?|NE@z%6cj*U0Uk2NbYGJ*duD;>ecgX)!VkM9@@ykp_XyCh=_l=2llrz zJ7>BoX#UEbE${UNoS{A#4uFa@YHOvN+}AoNA%0bmyTghTAYA=O!c`UsSBu?1xH?C| z)wdvA{Yk>ruK-l7IEq3&S?E3s4ePJ_D%osGkGHQ?K)CuYO66h0?NfRjudz&Hht}Vh zt7d-Rz3IReyRTNw?5{riQt#Pq*K6$9*HECCth$}Y4%7%{u>*K&VK7)!_aZ=`=>is2 zvOT1DN|}@_C=GyAoy00t603Sq8VJdfQbS68DGlPjRyR7?!;1`+)kI)Ll8V(9R4i{& zvBD{BClyN{QlK?R3=vlWXV__qQu=ig+;>shLuogpng)>0Q#wc~nx!Z`q;!nZK9(|s zRLcfZJf;1njb|UfVK|9gs@JL$V=S`+1?eh5kgo0v($!0luD0wGq^s$Ibag?HuEv9O z<(hpI#mDynE#oHHH;2f+8TTb<4!=&Da?1R63c*(MK-O4JI>*+<7K!y_LOBFG#s=_- ztAu_WBz&SBK_g4*wg}acNKGmAV<}=drm&PUq{S=F2I^$Jp0#J_$N@Y!F)uH9@NPUG zB}m3JRBawn<-`v?4JQ@guZU(LY^e|t>pjxfQLnyRr(;AjM8ejqV3P^_Lc^<}j@c4@ zLcE(6z8p(mX6hMG7q)C-0$YA@pHLlu?S|gzKXI=KFjlW>0akTqiGO^(e!ek+bmdCY z)$MiwhV*YQNLPmi>FSXnUA^rEtkui;1Y_~^2oUlhDM%aDKu$@Qe=MC^HS5uap?3(Y zG3Fy;%X?Oz6q65<>JfZXD&b1H&}(bwe2Sa=h%D(H@YGFs>bATZK68nsN_AiE9TyW% z+uFmN9RRqooHgQzOUvV*lXP|aUnE`a6Qrx@f^=mgNLSHr3R>5qAN-BJ#|E$g{`@wD9V0`v;9Nv>}LREkQg+1n~^((&ei;aohPw@l@4$_PucS z2l)INN=v`5a9Jm6b`f1hQP%%G{I>yjXw4l~q;#i!yZkmr#xX4U)G3N^CC$pZbE!(0 zxFO=0%UDH7^-JYb(TS%~Af>&kVmB%^O|2?EyU;@9NlMs964aRqYH~i{?xdmjd)P+< z2tvZE-7?$X6~}oK;JQD)soyqdGz`smc3kGMeT4YjBtCx=pUrncC-X0rwRaj%Z3EA? z0;PLw;mmmD8gJfC*&n|E`!A&NkcyL(N4N^&6-o|g#@lJnYpd^`-C@~1^r?p4L7xiH zEB2|pdJ}pTLg-afLa%1Ra$gW(#p*uawmVo^e9>Oyqp$@v&;Zt7$}ijSr7OOe6M;vx zS&QTqV+}9uv9e^ohNg?S`!Z}HJTNwZZ`b&D5C~b{_rqbJ>`#^!*-L?AUBQlNj0Kd`Z7h8PMDoi`7y8G4I8+Yv? z*M%I)GFJG~9$&27XA@8rb;8{&)Z@8LNU%%PNp4oN<>o1F))SjQaj^6ZP;ql4U6JD!9MPomt?e3$0e zCfz7Z7)w|Hi^w*1({-7Hnr^>9dfAZ6pqK59AoQvao`4_1@B~b&1B++4!s4k@Y4Jz2 zpZH7T!gRB6e(8nkoB()P7ox9Vrw3em)(~qA)oYVVs=jZhLg`=p-+8)`8}B!b^(cDUn4Or1c_lCldv}3 z_-5bsTE->XF9zH1h%j-ZXYmZ^S9O792{*=ksM$TvPwNxEGnn|Doj+lI+K~%DY+q!* zXZCQ~ntWj?@g@6kDf_NCOF_^nj8tq&1XwQhG#bCZubW z;wU`hJR(EMU((a190`lzZQO#z@a}1IT|Bur#WHqpcOi{gtZXNi4CmUq zBCC8G)0p8cj#3I%!YJDKm*mH7GYbG6SzuJ#$K1uL7hM{V|UV{Jah zrCrUqFkzcZgb0RC=kHI5D&wl$GMChWM=>+%#q zm9{M5U;}-&q}FUn>v552R`xQi+^5e!*5V)0^C&s-!bzwE0 z%KAR`Y6kF;M@bZ%N_^xa;v=sUAGwE?ccJBD9v8MeAcni02dlxpX6#TEUOif@D_ZKJ zfaMNss(?Q-ozt79aOE8>SCCYB|Ja3pEJLb=^kRPEkFApCV7YNkdEcjKpr`VEnqdM< zraqu0+oL7-8o`$Q1UpZ&*?G!g=P8Swrwpr@=GOwVWp>>75-Hc(=IFCVk46vH;3EV{ z(b9c+-{o5rup HL1LR%wg|7$#O?;pbxxSX7t9Q+OXy#qAM5iRlbNT3fH)r5$!r? z2iy12d;mssD~(%esM(Bt7(@eMh~eFb<|1jgA;uxGTgeuae`!IC7-BhMh~|jFfFp+d zz$Il!(s5BTLZuWZIrFmL7YL=3GzSZ)3l#4()IguV3b&;B+;^ZEYVJ~EN|&o5R|SI-8RHbi zNd=>j{tVFS$2hnZT)(#&@3=YF@11cFW`4oi_25e383!y7yTf@(by@Gt;v*6>jh2DLp%Va(m>m*%VW{>CK ziOibKD-|Q4@{LEbPHO)U?4GcHTJ%qjKjzl_WYSNUo_$lh(XK-g(MNCS``T9de8PhC zpZ~f%Z`dK`4c?M`20I42VL@E|jxu}i0FInWhG2?W_tGWP=HG(%o0IWE~ z!k&19!`?$qD+7K|fe)oj&QV(U zyRH~#KL*Q{51+z*T1Q@f>6z{oT}l}ouJ;gy%R3Xh$~0%2>!2p=fN@shU7t(9=qAwK zoWxXvDgIf{9fhUV*C=5H%Vis-q0&M=EiHbh$Q&iz;*l!H?%lrRfwBr?cE>ieh zl%EmClPC{dtPcNJB3YPEqGC#M?%lLh*l_=_;}~IbIx>UPk;PucSWqR}2Melfz=A56 zmv$@TdhQs_urbeH&%GAvc%enz%R18Il)Wx{ZYBOvse>o!;hN$`N}9av5_iwbE;637 zih(!jI%`iMZVRcmPVQk&sO+e=tmc7hIsZJ3wnW>OcM|o$Bc(c`c|2d_r zG^rv}%S+ss73Z^FNv&+6#}VuR&N^@6)RYCMD`wHl^mlcBtn@@Z-^j^G3ruxARNc-88Srdb>zn{(8e>uak`mo5@;PP7HjOGh9{G?7S#LHnr8;CvETx-dfdP)x z?JmiO5C6eKHQ2I~Hf%X=GHjXJfVLz@$IFqX$1~!!7^a+A zxMgRruUx|${xO!VfbvHvikfgOEd*sMFSiT>47ISge@D6w`lav`W$~ING4%pWTBYc~ zIK^i@W^>jfhqE48ob|}Cq0xs-=@q-xf~Gz}Q_rTUb2uu>;wzi>si0Aesp3W+thFWX zz7;1WLg!Ku5G(+-ZDcG%8ohpsSQs!VIcjj-FP`jS=1g#BbM_LDEMpS+R%WOL^JwV>oCQO zaTp{$!1!iRbedE*sR{c;@4U!Tz6W&Ckn$hL7T}$=C2cv|V=+UeG&hS3FV4q_0sD8+ z!Ga=Uz{X@bM5kG?Ru$*`0OUO2c_U;W!V zhs_548PMKm>yP#Q5(6{`97_z4*_LB8gcUQSCb=ZRcSU>0C)i=8=LKT|r{x?I+$+;& ziHm7SISwS_9~na;At45A7h}M7)nYi9+?yF9sEr|RVx1Lv{6hs!q}*NTe)w^mM&A$b zK>+W;nlf#cGA=^kE1X1o<$I&Ltn&N~3m*y}0%x9F)}VsNh*^+^oC z@6PujV643B{XT?J{UwqWP2`X6sJLN?*pvKj4*8rRWhm8=b-r9KlZaG!{gY(2uf_XL z`GuvXKsvE$AJ3-!CY$y{Y}&`MX-{R-o*LxY9Rn9S2*)vEBvopH^TP)<|1D#ak`_oQ z>o`X~ugQS0<4y(-<#r$3#_*+N$DkS4Z1xdrHuvDZ8(G7iW`imIA3qq3_24q!_KJy* zW5@KrB=U{@@zVVv@|EIc7l}f{R1?TtoL{=g`K55qFPSlF!-tbelKCY`$0@(O+!G#t z7z}Zd?l@ua1e(=>W{qS>E!Kf|y`qej7}+*NvsHWFvWtNj%NALQv4W%uSiq2-!SOu% zvhFL`6Z1`3oO*c7sfSyfdWaiB+t%gBK3d~8t#O=Ow3+OD3F3S4bQRgoU{SamBQ)w` zfFzZCX3hsv`5qH-M1_ZZy(hv+L4DlXKo?|C0A&Vq)&wO@HU*<-{+4;g@@G-8avG#(LBaXe`eo#9^gA#djZp z%Gya(*3yGSWz9Z=vajoUsg3<~)T2NC964TP*099!KwllV0}|^9NLiXBW!(iS>(^T~ znrm&li9%D=-VEux$LL2OvFriX`nPIxt=&IRuM2LLk;*XJdkJ&3g1*O)sd(F7PN>q@(Z~4rGZEpnPjzUjr!vVlK4ESX$8U^3KYMq5 z?aLkh(p8yidn93QQ^)bf-<)l|zV`1Oj_az-u-%g|x0$22@%Lxl!)ib6uuNBFw(aJG zxy>EDjGvy3ARB8qIasT~u5xq-yXx*bNbPjD=Oulba{=1d&{|V_OT^VI7ITB-PBvB& zrEe&G2`PeXtPPahDGlY$$i^B^X(%Np?u$}4O18jRIXVDmV)3+|b_vYp8Kysm6DohNOI(xXsw3r&@gN3qcy+H4SOl^poC(D#-sg9P6z`R2HBM z7eX}F-O@~->(cUG^W+}ZwR?C5te$JD*0yc6(0UFIHH_OuM111z-QTM1xtA-0My_nz zQs-WaWJ~K>y`lnFs{!pmcn_dDVV5andCA!yorLFFU>Olzy zgF(Uh78o7J0l?@yw*uayI}5czAypj|+JZu+t5N7X78-;?#?~m*kA>P+eTT@xZ^;h$ zZ6trQ!*2;~v4d{h!4B-8!5Z+jtjO1L1YfJZ6Zl$#DY;M@LdhA@YD!}$eMxBuq!das zD2<>r6jFl_NCA{a?d+WG8|!k%9#{EH{kCVo%Z317d1nU!eARJw5;$35C(^*lvKx^} zPSz80vM#SBCoAnHP!Farr=oaRAh;c!=JBH=Oh2v>30Vh8$Z7zqkL-ti=kq*zH}?!^ z1&b2ma>o|377!gr1cnTNibViaL=sRjhRljaWLDH@-ou!Hw0y~xQV2`wP_jZPWk{OM zS2VO)DhOFTl>owe2ze^t*(j2slg^vbg;%ce+rM#N%L51Nd}XF(Vm&Y3Y%*2W$ce|w zARg=22LL4PZx1}y$N|J-MQ$e^>*}AxW6czJtZv7N$J$6dmdya-u_Ct}D3JXyK&vm~96`#|I64 zy$5LMbuPYaWd&vz>-+2DtL`tFm9G8@QHeO?x^%k1tJMZ|D=KMllQo5EmkXujnyieDg{$?3aSsUg= zTnGMYPNevZ5}(_}=MH|NB3C39tH{0z5Li!NC7-TWmk)V?#zs*?VUiVZHfxj)Z+&YX zhlsr(9#ulLQb3`5e81$AvR0;_H4TX&jLwVv$xA)>K?vnWLMY7%q5QTltotkQX7L*( zkSv*R*Z5`l{V^VpXPfbW1V{>_KL;2htj}KBKJ@2w+|01^W4ufSW3h_tp05I>VX@fl zDFAUP1B)e1-BNQ$FY38DYHf!L#z&ue7~P%n2dG$={ny3~yy`#EXUkUg?)Q6bR>xM9 zx?ht2BBNP}sx2OlA88ZP2c)IcD*z>J1c^t3pd=EJ>Vt?RLFWuXk(xt~pG?u6PAt=9 z6t)CWX8^z8pH?j&*??1JoT+mm!7zBlf$&7*x7@7%6*pCNsfx`y+^qjK)rLalX7;vD zR-SK3rpny`)Rr^^Yb}sWnGX2PjTk8&#g{xTNuk-h@$EPMb{Hi+j@mk}bkR+8R}J+z zFE*37c|&YoTB1x+^Nm?N!X|00Yr@`(AwqtK9 z*jtl)k`l^$M?q4DG>jCbzBm9M04t)eWB{@#RVOj12MW|D#HbpPQRElZBtVKZBRvAF z6i`TMC@vZBuToH4@<6rtQhq8d){Q0&p%ffUw4?6ND8)F`DSJ z#{Bp)8RkDkaN2kqnENKdTR-ku@$ifB1F)qAQ<@R67J%Jd!~+mSQJM+q8l^Z&PqYV_G@R8p#kS!lc%2fw0K9lXX*MJ$N~x4yQJMp34W)ES zIh6b$U8D3jr94V=xv$NTYL14a(g@N#?u(K(B{fR(xv$NbzHB=hp&RO9IIjh|*cT-; zN_8nMgw${gBr8hwDfvTkqU1tJi_#)UYbcGO)R@v@?u*h4O3f*K$9*xCBY;w?Fq}ky zC-%iW_)zA->rtXpVhyF8`Kj?%F>v`NF%(XcAf$qbR@u2pK_cP`)-E8b4B!_jV<*tq zK{Phj1OXkufi{gK}-`1Q!VH_ znZQVIg_QE8qpKNrui&Kwi|!r~LFT;)h%#YtkldRY`^dimj{d{>>t} zDw0^O60-M2bQZ!bS-l6dE+ZPtyN?bdFy)VADltD?67Q5>N~HZ=ley~E3`R&Yg`t3? z1AY$TsRyzRAIL!GPiSsNa1_Gnd{;P_0L`?MK`plK63c6`s^j4hPR`QuL9X%gJM!|C zA0<@*tE%(t%M)G|%Rhct%7zW|15;!NLdsg;429WOHX&ft6Ao2L{mLoO&A=}pqfP=~4g_SBb!>hJjP_GaFV*L-5QPf=A1io`No4iU(siOxcOFBp7eU%sl6_Gju zykIdnVdm$s(lS4DcDr6VK*PR2ue&p9=PdTT!3)NUhe_<5xw3N>%YO1$q7HwdxfQ&K zVJAM|1<4zH=9MNXJzHb6`Rcg6V@zbzoI<|CYeUDdShU&1Ui;vv?B5+6gT`Rarepq zW3kN|&K5-Eh^U6mev6z2Um9@(`$SzyCYwGFRq6?olWsFP>6i*X`0||5nI@l*PE3}} zm!}y=LDI~l4FjXoZu13OjAJSp@Dv>~z~IV}Yz_2{IVx$%0gC*aB3(7l9pO;aRvi^PT1 zFmg1{V zL1gzf6zpEPH?ySjQ%V{pNoVq-n}jLGq7+|D_>~Ofl`lKIJf$iy8DmTq@_>i3qP^p0 zNWjg-rWs>&iFDt^>`xahnv~g}Uc=b{bm80eD3g7sGTHYLlYOsqhEssuuQ7*TVsbsS z*i23ngP}6yrxWt&&6j8epn%J`uZjf*XRvw$=OkB7M>z%+fo!NNc~`s(mAoso;ck_@ zt73^El3bDhu$=Nr-W6K;8?=r>s8}C0r@WGP6`jUj(^0;}jW|G4Fak>0Z75_ zD|uIyysJvy)wMveR7q+6jdH9lAlHDWM3NODm%CVVODt8%yTUwA85}VPzlm4PbKe)75#n7op6CAS2nWFA5^NqWm3tz!X53x z?s9=s1@V;?FV$nX0sH2ayes9bG*ZdCs^neChrX)hU5PodO5PQ^yyb}s>&U)xc>=OJ zR`RY4ge#?NqnxsiO)7a;AG|~)yPSR5<)o!X(^uO_SrQ{anEPQ6#$K9;I#HU$YxLx0 z7hrcQc~^|7Q(QhuSs7K*2_uW(^*vZ_sgif4)G>+(Pf*AbAYE8-|Jl7v-c|N5ey>B~#)uX(>JA3BkUV4+4H+$sSzk#!|J@OhjtIQCfu1s!$Y4z(k zevi9O^i|6JP2Jn|y^;H3`)P|mQTEN^m<6%l?azEVY5$?B7Do3w{dD&9ZQa*L{&lN% zbFC#`{{H94$p*8AjhnDw#gZ$3q0mv4T!U85YoSlo1L5lN{1r>C{hPX)g^}~xszy=I z-A^sCGS{x!YSG%N9dsYN&t2NKtM=!k4%pYYye=xZYDe8P_qoeU8Hn?r3@iGw}y0x(jJ!5hZIC< zBc-SYDAiW=^(bTOs=4bHIn3>@yBX3>JxEurAWfhY*5Kvh@gx19O{V5dZ8eLvhE$J| z1*PTOSu02f`a{yC^c_om2C3Qlw)WX7UM8oOXslDcJ>`_`(=93^7kKnli~m0xZ}a(IUpux<}N4 z)eYv^)@<8WB~;VF;s1;~Mnp7l_w8@h;ar1NL6cXGX{n?7nPZ>x3jk-(1=azW8B+&f zW|pmP9URa~2kfcYAY3gV;VJ`!tGdTQxLQTR)l(3z&XRETJpolyS;z>55?Ls2rS0SG zK528apQ(Xx^@*KYih+IlT;Dp4nhtFLe2dD%ul>4gZZ;%R<>4yL?2U`F9Xd4~IKm*G z-r~EOJ0N;xJ=jwVNw}I^ufJ}vJpffVNVqbu**bV9F<5^CgB7(2g{qTqHJ^nBqEI7J ztSniG7%Xj2tfIDYPpjvS*la>Hjx~N8L&8-D{uYJb?s5kkv4i@9v4cQsJLAv@hhW>N zohi5n`W+M8cTw6yX*Z;r29VBEI!Gy+r6@h5bd1tImNJA?%LY|IB7dT z7_U_)##m+t3er`AAYI)Tq^p-8T}AB^q^s$Ibag?HuEv9O)hPQYirbOMv7SVZ^(1n1 zB9UX9YnQK@O$?N#uxzOt6Tb=;wTC<@3Wrn&abp;W8!d5zY|0>R;!(qOZoll? zC?p&9dZJ0v)mlNix+zFk znSyjR=QCife1BXy#;_Z&VgT*OC+{UMOg>2kf0Tn-bt2Q=a1yH7C~e-68njdCkgQTm zSz%v&S&Am{Ad#kYh*kWM17YI1UCN6r11L)xr&XWVP124rxjVMpSBcWpmwU(M({D6b z!`O7aKJiVArSI2*bk%{RD>p&9dQzLDtF?l3^`#(P#R}5ZZ2`ubbR;`=^?E!D7DOps z6ws?=K(FG^&SeOfN3E(3qP1w?B7Cc1(pzPuGUzpNWiPIP}_M zVzv@`#hT}3hw64|5vtq9cBpRVgj;2xK_58)4SLV0=E*}Z%6z-t>5Jc|;{o}Wv_nft zVbR*t`s}3*L4U5^zHsc^jVGYR``w2&VAC^9vC=K>zB7-Ae#x21e5jNrvDfjO&zU(- zqApKD!IFwGdQmf)q1LYR&>sHUSZngpr)P(?N&D%-ur}#G9gZ7##lN}FXP5o4mF$1= zey`qI7Wb=tlG$m$&V`o18D)T%Dx@AU11pGl820s4G7LpGqTK9hWL};u`)k zG1kiX5s_5J!*vbL8P@kaFh9}QgPXx(bG%T!s7@8C*qklY(NMF=mzu-<3apfXOi4@8 zxV+;$6scO7&M1DHII7|ptk99cYjCxlTyQ%)xfvify}6knHYaeiW@i?dEXs28tyAfQ ztI*6s7_54U**P}jjfp7>2Cc{qw4&!^Q`H6fXpb?WSNDiM(kJ!E=_;s4wZPQsV&71F zCk1I2DM(JFAnhgvsVmq=sma*eJnU^b_J#wXd`C+DkoH2FybTB713-?^PU5We$v6rm z5~<}oNqK}TX`t3lQkJ}VK4Cl`U7nA!q(wa9XE@>*-jqf>iE>Ld60>(KPu^4bb{DH} z60%w9e3$0eCfx`Jwd{~8p;tD9UOCh9bp-i}%(I(hoE?fJ^ok(6uder-8h)rS+Uzdb zbzc8)%#z8jI!KaLJ0h!W0I+(Wq&&ivG*ByTMWkwf!V> z$d-YtK_X6}B{v2#7ikMKeS0(0cQG@47l+yJIAUUoq$Qux%m)4h8BdZWCy|U3Z-SKs zpVi(G8fcD~Dg8@`tV*Qx0#dDRkgO@CP|9Q}O5T)iQF^r$r7RF26?h3TaCc1*5%)Kw zKuWtPWl+jtsqT=@Q+i41ElW{)Na+owJeKMKsn%sk)tPx-bs0)g(x+6Lk_x0+Jt0|N zMgn;Q=9H`2p;S-glzUTZLP-r$tzM7`Rq-_6 zd^lFg>#G!6ZlhP&Tj%J}TwwHp0~677X#7YfqS-JJO^fc43QzHW(3|~rtd9g`o=NS*JmQF(X4O{lPuRQ(gFXHneJJ9VY>Xnb+L1EW9)p! zUF`ft8zvnOV&=HA7Asd$NK~;1tTZ|@3;PPNT)46%qpKNM>uLzss@li3s@#~we@rCt ztI`zLXbNwd;u=k1fFyqV{J*R~gRI63Pv-U4L7pcP=Otbp4gWbJQkpk%f%1D|t#Y|H3s6^Yov+CamLLvgp z{x{w%v3wwMY5dB}DHi}M@3XK&F{Gd*o4+@~ zIK5flRmNmRyAEnY`|dym_u`6WCMo=2_sQfSKP*wfQweP#-7bhL82U5WTVi>TN*@h_ zy-CCv#DLXWtXE|HwBa)^odHr}MuvQO8|5xl#ys$f%sj7voN}F{IY^0@n;yx+>?>Xv!FVT+P_$-A4>g){>H8R5Aw` zt2~2X<-&Jo>3|L&ouu4d&Id`d^J&MMSQ3` z%NjDs7)2;X0%%E$N>*`zBLAk0Ua_=voa=DQvwk-Q27yg5FxYX9L|VBw#Twu84u_Dy z&aUi9znxQcQ6Gz=Bm1zfEg@S@ljul8YZ%#OrRPaI1N}gbj+T%esmXqmp(}rq>LY7# zOhoosMCz0FMOkP6RCIugBRMva0s#x6FRr|exN@?1<=-rcaOK7!3rAj}kn~Wf7>1X$ zqQRK(Yv{y>u?S693DSE84svCMOBb4Fn&S}NW)H1_N#zYCPcym%dyd%E@S0egogHPD zwP*lh_Ht0vlpn*{3LNFy>{Gcm`=k7|+1pl(Xv<;nk+@y7}nRrDr&-CGkQALq=%su zH=r$TPY-#YeEBAjbJY&hoEJ8+Tj#v<^Aw+|k}~xI%v+@p=q$1IZBAlwOe{Q#i&?WZ zIA79)^Cf13IVrYQt&vY zq}?lcEs@2hGZ6tMYn7^z8=OM^2x#up@@)NyK3h-K_e%<>H(*v`O%Z*y=GwP+4x3&1 zJ)phM*3gbBo9<$7K~Q>2Tz7=^;vZuu`NK{VVW+#cMP55YVCbZ0hn&N+yZ*Y;n?qGG8DV5V0 z>@SP{FvFFlg4kKDTPNM#)v!*S--+=eN?UtS91%$&u1pGX&QA*ANhnJ?$o^qF9AH0zxq!KiHu1H%rzmj%24Lpv{+beeqnR&H;J9^FnWq(880%Hy>tbyJ1B9n zd<-GxPo~Hzw=trA?YX<8%K`9=Y=`u(6gN%mFuR_97s(Uf1=i zJNDC2jlsPd-)h#d#PQ%>9Zz~XslyRf3nR_LfM(roS&7LS^IjB|VPkJCLCA`) zcVW54x?7sSIkddjJh_K;?H-;1tLNIPwQXB1w4Q@Q4dZqZ5udnw_qS?$?&Zp$kt^G_ z)VbFp+0wdJuc*M)Y9K+_g5&^1&6o%vY8tn-(yiam8a%9Q@UYZIfQR)fd04*SVYMPO z>v!O+R{Q{H*4Kn)J!Bz5v(~ZDTJEeh;8mxv?GZIp7N`oK`rld`&A0-FxH`O)}6y-pkRS4i!x=|^> zX|)BoizmSjiu97{Y8MI)kW9iFGJp<~(q)m)r(l73kmehu{q#hIZnk@6!{Hhkv zO}{VkkFTfZ8v_8A%5hilvgX|eFY7{&_FCZkY(5NLmht6B;ALs2y#+6;_RIO;WtE#< zB`2tA)}swW??|(z$_=S1_@jJ~D(O-S_qlf@{%%w#9~NC&DuCdlmSvNQ(4~q~q>3=8 z9;Xja^$bv9eIp);Oq^%4{{RE&CjhWKeMf zO48Hj{(Wy_57B6rLbv*{dCceH4wX*5QZS_I^axku{4*&I!U|yRmO$$)X-7pd^5QpD zH5I2Jj@g*Rp1x>p4)DPm$I~c~t~{w4cILp9y4CPGmG@m8m3coavy|z*2*V>AY0Vs$ z6vGZA;VnbWe~iM<*e(a)OC=@?cUBs?)tXlR&%$ICA!Kz$h5NP!(P%^+&Vw1}+ja+H ztALA!8aM>M|BJ0aB_`|r6fSg%{u41-TcXq_`fS;v?w8~rVl*pJwZ+5nBW*%dixQG1 z6M!TphTUoEaM-=|y38R{!@b`@ z(v}wHHkE|Q`beZI!N#f}QdM~nS9sS?4G$qMONY2D0=mjCeg0@$7yHKPsC<1<`KF_O z&bSO*8EIAn_=Rw^^)Q+RQCKQ57Jx>X0g{zbi;%1}6n7JcHiX9BOB~v8;?RDev8U14 z0oR+H4IdAJFBE5VSe&Rfz0L@7lSDi^7$+=wfwKi1||szAEP zi!I_I#`p-eC+GP$ug)yazlwLy8?*_?%(sfE%EJbNDrQ0T3JoR7O zqLc+Z5J8s^LUEr`Hl$sY4p4eb=?zPDhjf)v7NuO4qV$|nE~P5)E$H`vRF9;p8o*NN zSA(>Rk})L>O4V7arwPvMGCUBP@IdI-NJ1$}lPNW$^nZ}_dqE1Kq)Vw5OHn#N$%s;I zmg)`ZDy2@8G+2t#b4nJJK4B@cvFg$1(H9;F{d(o{KCt`G3??qU`5%UW02p_i4Itmqw#Z_($=$(nBDdS#4ck}uv#l#&ON^{6%s zd|hOOi_FD`jKjRnILtk4-Cf8=i0#Ov z(`>}Mp!^^yP2P7A>s0O_sq+5u!-AW-@O~{f%^4KE<4Zd2199t14#GoFERq@s`!I3m z2eFeTjA=Jn&5yzSNa2SmKMwL^r6*{H{xYL58G0uJdRAJ@RSM&(%bn8wVSiMiOJBbH z?Fui&AcAEKBEX12p7^IRS;$e~(BuI-Nz6ncI`|^c!Bh7lR>y?NNp1=1VioGgobGXP>S>*|EZ4}#dd#0gw#^4nKWL@ElvsIB7C+JAF484;lTg3wD zA(fP@|5QpA=a~KhWT7E_@i=Xvcc1C3sPE>ON@&O{DOn|Dc$Wo@Rj91;C|N}SSyN#D znEykqmV~lP5|sdfM@EXww6wxG-6Cs6qzV4?iK)KhIKL@oxV-sFH{&Z? zDs_V0zcQe!J_t7@gFsaVX(~^(DLV=kxr(=Z`zj5q{Js%}z_foYGlM}g?Nk?b3FUnM zm@Gs_OSunXE;03J6Ws?V=suWD_dyQb2U%>|GsKKlCVOoe?6sw;74EgMcmMy-*hIb& zj9jJavlP4;&Rlon{TUo%vK*pEb8J$)NtKcN38+?BDeeP7y9}qXLz%B=N&=n_33v~N zQH*1vzep(e;%K45M=@n!OL1;QvjT@K748Ztaje4uhvbN|(l!K?ohd?I<5>U3aSJds z7cbeFzG8Cf4rdqP8oW-|;QQNgWHfvkyY)3QkJ@pT`b*|c9A@ss1d%(zJF5(TN>h%f zWjIfiAa&t2YVhe%)}kT>N3`U0(`vpvLu>JaGY_Hq{P5-n)A&O<@etaDANlW2qyt*3 z&?ig7%FOJJqZhC#CO(2VH5Dn-IrxI3+mE%t2yeF1(#UCEBgqlT$T-Rxr$9oM*!|TE zcwA=}_Q$?RVA~nYwsSk*o&)&y+{Cx11>c^t`p1CKF@S`QO(b+!lt$=43ZZXHJP5_# z+j*4fx!|>UoihVhqS2^g#1!MDzz~)%k_QAw3)%K zea;~4X%3N7%uyGT{K?(oeD)!B0h#44%q(9cGRx)O%;Lf2SXl*gO1Tcw%bb|AeoAHf z8ncDxr+bbR<9E5K*+8R6?4WsXRTqccPbVv=B4(O-0k{-SZ} zFlTBAhey$TZ-2=);1K&y<5}ImWLn{%#^`ew$D6X(9LteLS+TtAD}JOQN@-lGk`{z{ z-^hgxI2{fR_>jJ*P+3P8b;I8NjgfA5&Ns?jW<%OB+fxtO=Lo%eRJ>+?#+ofw&{@pB zlLq@vP4v5LalJB-rrsi$STyxww(J^g*=g81G;9TUT*~S=k!#o?pA$yT!HIlBm@<~4 zn=Fa95TRDZ(#ywWp<^4zY7wC1tIV9ChDhbiS!t@18tSwo7kd27QT=&OCPvNU`I3+E%E6S4o z%_EA%K9s)(V&TDp0@gt6O@_O#tW~P^U(~d?t(`$@r>^3h z)l}g_;G|coDynhnI{*_;;KK$r|1D#aGA=S$($GiFaIXAy2j$K`Ky=h1&N03-b@6U; z6BF3aOe{zz@L0>lsK|igb#|CJnf*W{o3I}^niCa`*u(0}9@d9TVH_zIz;Ttj9ASk! zLrO&Z@_tE<=*r91q*O2r=^t|v;}v$EhBd}Bn$v4SISXsz7KQg{RKBzcnYCuc3gYoF_&s;A;(dm^Dq)8q-p1J5p8 zU;Eb%*K}2;+a5@$(kywb@yfIDVYSmbMCz){w2exr(mZ*z@#VAC!)m|oFjZH@&o(UK z$L7f%lb@co3~lnJLmyo=KilP$Mo!NDt;znA&>B*kPi+K>#jk~QPY2R8O2Z&krxZ)c zo01E676Qqik{cywNDJ3Ma-!rw$&ve7UF}T=oyaPFwtd^4YMwl>7WPFcGXhcRGq|^^m{3=Kulr$+>a%Yq}LP{KEa@xx8_i;78y;3#i z)Ow9|H7%y}825c*+T4GAZME#IxxS<3lpcxS8>Y|w^=p?aRXfBVhyoYIqxWCE4EK*C z_9*pA)!>`efKG{cGpbSlfU4&VSJhjY-a@BO3&&p8=X*r?uWm5kwoco&s-evs9BLc) ziHK<89@gKg=efbFp1*@~1lj5?TMgt#E1d-QJN>PUclIOd>UTn@W&(B9o2aY1KwZ^6 z2GrFgqOLN4y6Q*N)n*p*VIiZ|!8z$ox@?~FW}e0lEz9JpnSqW#T`lOVma+s`7vEnu zY3w-bls?xt!vDmBEhkpnsipi<3%rPy*ntOju)wf&aJnuqR6kh(Lp7NgstqYPDLqJc zDEU&_1Sy?THNvXqQ`*8(Z6LLz6i8_sOHt}&y==s06Jk!RLBC3N01zvlK&*}gV%bx2 zgj9VEq&|`0Z8?kqKWA{Gpajb`i`MrP3y+^zN-D*pFU(l^C4-s^$A4s=)=>Zs) zYxW_)u-eW3H;NzH3Y(87l;h?iuy78wBmSyum#>;ltR)R%*-|$qo|Kh~ge`3Wa>W1- z#!`GCQYMmIn=!cLp{^v3git!IwvxcHf28Gt0d{t%VwX(#QWpU@5Rk7g?!Wb_^LC8 z&$hs%z5BwXi^E}34OQZ=(vqeUUFAk})vWz13Bb}M-D-%STm2yDR`&$mY8s399v3jI z5rkp6eNGq_&e)h(u-d!`6(W7)ljLJqeK+xVeVZnHTIA$o@y_ze^B|c@`#paw7p&^( znmwKYyvX{zNWycBrGZ%TNw)kWO`OPmnQ&hvO5Khd+%%lTX0sJ4RyZkxC)(dKT;=vJ z(yb=eCf#a?pj&knbgM`~x4JH1SmOl@t21F(ZcX;iX?HIQyCL;#7^!DR1of;f@mCI4 zfxq&f(;7D~l8wDhZ$hv_2*GOF^z)Oq>hrKX)m}LJ12i{U&M}7S($ecun)!FAh+e$t z9!duMw>5VdgdJ9>^xDQI|4d{YLpi7`K7IkOP3GpGhIk^`%B8Zk>BNV086VODDZ5(_ z{E*!fpNE#?zE2?XD2r`sVbkBS1@%aa%&V*ImxSr`cgya@Z>zK6q_e;6XlQdQy`Q(;sMPc!;?qlfP8Xkx`N_&Mjika0$RS%tm>$M@(${9GbXM50*x|4bt)h;Fy z70#<4D%>Sf7<_FB2?)K!On8>+4|{BxUB2qSBCd+%al3H|2YLXbGZPpcGct8n0f%Exwow$=N9tr=0lVWKfiH8f<=Bj$ zyd7I=kZn=sIb|(;X?@^Cif)3T>5_hQ6=qukv)!giNH=ootCgs` zJDeyhRbY_zSObIPGS9`&>FiE#ZgwOQ$vYiHq-$3|MAE0-H)01Gv^#BDA2zKXle=rV zV>?Qbkoa6o;1@ms1pYK61E>#xKaQ&a{245f>?j38N}<$|rIaO^@`!bK#NIfGWP*s4 zCfV?aK{(<;oIu955Ja&d@mDl*_*U)p7#7T9qJG z z2h@HhCynZ@H~5zJm;8Aef0l};$2{L1CIf#9e?*^+@JFoif^?tK3`qWzA}Kwjx^izZo;gk`9ZV9aBg*H< zovwoDueS`R?8n7}R}k9JOch5kx5g1>{Ew~$h#H;m^ib3i8}h8+(MK#Uc%C)Mi8X0A zy?a9#gSU?{cy5frJH{Bi8H~Yu!AvwzZ?IlUN4cF%h!rr98F6_G?TW%PHt5ijv1Gb} z*8+V1?rjaun=oC%yf-o@&ED-i z_%E5Ukdi>14eTd%p>w&T$Uq#$LnHTHZy<@>uW?%a$`(KAd4* zgsKveMPJ1C=^~~u zEMh3ZA_ml2xABfNf9Hlw9wYDgFIIpqgY$({O%0If4JQ$KyqGxBFOo9~^BuXbd7wVudV94th3uN;}J zvYpu~_V2P)>{ul#Am5|Jv<>zp0nJs=LV=*|x?Yi9JzQy0@sOoLLk$72isjg3EVEU9 zk%^Nll&!+`2>Z&Ht+F&Cb;Py6kxV-r#UP+eWb&XPQp|po)*9tQ7R}6)Kdr z!Dn4*%K&1?soXq`8|#k=q%G{k~|gZSdy#usNl-tiS|OPle$Vp=>6|(+ux6E&j2;vjGNt%s0N+1GQGTw*@Xe{e zvA2`P}ogwZ|_~yLbbi=^tG!1mRnZ*%kv|K4Q&Sv)(_5P)I2ZN?LMIqHoOciQJp-OXn`=Cm%*uMiw*2Z*x6v zCQZC2)f>4AtC+gcP^50iy_q$HdD3!@hQyHRYR0Sfv9kH}+fMZ(6Q zvTeR6Pen#Di&Vl29<%@9gmPUHtadSv1XIeTEzaIaOjp_QZMvTQzxg5Xk+P>LXfcSWDv+~m8G0hUdo>GQo;k5%Ct6KpwX^_IJ+np-y0KO4VuHAaUQhi z1=`b@)7c`WTxr=G!c#(v7jd2_K~keF=fUDrl;tgv9C3C37)&=g@a5^qp{SU7aO6vVrptNpM+w|vv1^`6)D~dU$4B_K*gUo z`+q#C+%60_s-x{OB{74}TMmpY*r3iL-0bfLsB14s27MsNpxgQOtV?`*+8Bz-e5LBq zP1Fn-g&ZOIFyBaO`q)a)u_!lYPmQz6^U$)h3|~Hl$3jS@PGnZ~`P$5?mU}aY&JjVe zlHYy6)a%*1(INkh0~RrSp#;{}eZksVUZ%~r?Amwdo|vAV#q$x8pjgSB<^9$PcLako zbq>xB^eEG&9H=Y7!-_~Hq_-<>zBy-tIR&AIFUMH-mccA+VO^LG7?TJCdtq6Hj?p^| z>5zA!Lq0~(3{%#*?-0;oISs@5GJ53FP~XFo7kKzWD}Q!+Ng6 z=_=N`!K`&olo~2iy2c~^_vVy~X(dmYBhq5l7Ab-|W^mNAp0&6W{YB&1xZh;|=@9!* zNrvU;6%P5Oc_fd)T&UPH$$xoEf%6H09J>2;~%3k zK4`*bc?DWx+18Fog?s3J$!p8qrhAxESn7hMrNf$S!dcA7XjLhiY4$G6P;tZo$24;! zhj3Qlx1O84aODCQgzNkL{rvv9k8@va&N=t&vxl|UTF=eG;&3gyNUb)V(VNd9@l=0h z^&ni0pvkJ7^8Z`52`dhjm?ap-and{j!-K@Nm-2r$>@hPUZ_%MmYcfj z7&_lM;W@}O;!zWek&btpT9k3TdosM<-MGEswG;Xag2{81#iYfR%SSx2w&?44cW?N$ zJ8}EN*(4(+z-Ej^e318FeW$MeBDHeuzrR}g$Hlj8dwp{J&yX$d_d;L$@NCIr)6Oh6 z+VshN>x3Qy#`NF6*E-~foqJ_kt`#q!wj0!n#?hd`Uz}7w0B4noFUGZD8Rcd9jWDRT zSTt{q#I%@;17>PvWXc2PSNW*Spx2$+4oY@*yrFSS!+A=yL)auns)p5c8cq}Z{l)O5)_ zZ4`xQZ#PY*)j6YNy~L(f;NZw4A<%wAADlD$ZZDNR+g>IB)zt!*3eMR(Sw{SF5-E=$^i z%*8@3zkpI>ck{&sxPU)+)vmuQ49S!$YE5Z{cS;OCDJ4XENQAw1sGoEfsYxLucDk zMF!el4NtQS?Z{%57V!Vo;IUNrnc*V8wC$y$$788&O9ppHf7~kVP zdwMM1-KtT?(`l(f$hvjA>x}e&KlrXnlWoOnntWXC;)o{Sm#%3tez6>EFHzHE#s_i` z`!5B^+Wz*r3PQxHac6+(rX9uQXvv-Jea@ATgL51h$-$t>GuAko-Wgb_Ysa6yxj3lx z%)s|eYkTkOQu09P`ru-=QP+K1&noR;`l0vGE+x-~&JQluJn9dh+Oq?jo6hwv)1~B< z&9iJT4;5oJ(ut8wjUTES_8D=XuB!aSfqU} zA|(fj6f06`E0KmGB_hR8%2K2P^zIwYn?@kL|RR$`XwHDJ3ALk3!T|xa;vE2 zZ%L_oBHeHjX%y08kpj(2q<*yc)Bw@E&=ye4Oo}z2SbL;76ssfBzRn_9A_Y?FU6F<& zZA^H}B6UiP>F*s%9eDjyhY!sk38&#d)+>z$er0A?GsQh@^D?7>Uk`FB6<1+@>r!!V z?4K^cju5-8WjDobhOslqrIhRNn_wCKtaYrlbGg>Of%7N3ma1R>^{`4kdX%(o6dC!3 z&(O|J^?$oJH)!D8`tO?kS^HRf=Q3@hrq3@Wcn4SD9X{4WA_XE+t-h0a*!=}no`g?((yeKYZnYXl3Ui`v@RJ6@+4}J}A-)Xn zG0)XJyjR`e`WD9VK1ZE8Sci>4iV$fH(%(pvkd{%Zo=BCPMfw_P1*MRzk!B-B_Igyz zA*Ov$eB}J;KGuy^37f)oO=t6-JsSkYUq)(y)D5YZu(ImH%5npr)l2YMJ>5m}LF$Lp z2gyUENTgv%UP!$~x{Ndt=|iMGoGV16S*y-p`{TH8;QR8h<0^i>*z9Phoo?Q1uD25u zR^q)Tg2Ed5WSKA>>?S5c&T4rRa#pPekh8juhn%$+a@Ol0u^I@`<5Z&XHZ~0r-p0UV zM~kK0kD9H;Zkc%f7t0YkIUYb_6tPPnUUD673|_^MJ7qg(aAV2~BFDu=5IILdEZYn|Qg!%9%@rT19vGF@pMGm2P^^b# zgx&P}jHz*zN{x$AAgsQCu+BFUkWuT#Ce~8qd&SMVskm9GiktNX+$`#Miq!8Q7&oRM zO7xRD@{f7)tU6A(xunk}{fJumC{+-=)mIyR>|oz{hw&rLx&1(XH~5)+NWT1I82>1Z z*E@__&sDm0yaJ6YAtFueA$IYTV{WM%~n zOFo!cMc7GObF2nBYa3vzWSLnF>?(CyN~-Z+)~TVtj_gA11Gg(HweKahKaf|UntVCS ztI$RY^Il{?xEfRYyb9Cg4KiY&kkh#jQBa2w#4LZven{h=UiT*m$ zP*O#%*iNqaH}8}qH&N8mZ}*zc`g1I^q>w?QF7EgG?fTE3`Y&Hrwz2>6$g&r%v|U!V z)s?m#OwM0v>jpooe7{GbWm_kni3_p3DfAtmu0r1_1u6^XQlKD_4uV8lE=Z(?LhG3+ zUn+e!PPk0B&4i|B_MIDB7 zn5YgTIJ~D0m&xHx#is&9H3=-0f>dcs`Vg`dMr+V?H;*7s^CTa$utAH|;b{)ns>3rJ z?ofwkIoziX&&lEa{1CDfM(e$shZ=86=>2CskX&ZB`t-3W$nYqWj@~GV?G~~ zJp+VgWGwWga&~-_=c5rHHKc-*g@tw*Tv{jI0XdnFl;+%M{!!K!VB|`v>G!2DB&8gv zNG~9>bWpU4PBJKwD^ZI9R;Wa-$)2^2k66@MDx;ZHMl3k2FQsO66VV!l-tS&xbpjNu z4-N|jYg?q?vW6|=qk}NB&MXpU);8+;lMi5KjiDh6if#5WEhJhv)!$aG2z;t9+@}!W zQ)W`pLvoYyq-g2K+A2_~|4~lX)rDp3f03Y%27ZpqePboyYQJ&U=#L~tI7BwIvrCXL zfMK#z$1Js>U2vD^NE~=S3h4%tBT_|5wHK+(5s}&>z1c`gwU>;K21g`h%5{rGQB@YH3`ro)NWGAZ8$~9G zi?C4*UD1*UO(k5~igoHe;&EWRr6AvQS-MW9Zhv~w3Gp24adi=~C3b{!H5~Fl!s|aK zaZysvBaLV*!Fz(kl8?1ig*y>^>xkg%O$6V@3aZ)emh1`L z(HhwTbJbp@qs+uBIhOpkvhx3$P|a7ge<0hP-J`c^!RuX-45K36QZVc3hjbXrp62uY zh|JOZFk^djm1vP4M%F)B;rCrOq+|`7^iyGzj&!PHiIGhqM)pcEJ_wXOAQ^~qZ>o*& zq>Yc&*~T?#s&y0kOL_x6`f$4UtU&}>Hu_eX;S!y+lklj0D&Irz!(^4LqBkQ;rHE_t zTQsp*D&<9z@%s}W^{0x5();j*2rW&@OI}+UN=#5CVuEm8Hy{Q?<)-HkIh0#iedd`| zX5lH^y3bRMvio=&kml`9N?XQ0hHLRJyVKLU<6mBff7t{7@_J&kJV#4)YVZ##({ZiN zP$3mBUxuIg|6G7nfg`Il|5yka@MbDXOXr562aTlJQ7M}4HHbY4x3cwfvb9uV(x1|q z$264A+^;tiWh+MRZ<#3fBXr~kLPy4^Z4&$GY~?CSt00;5|NQ|{`h`*Dvs6A9S@a22 zRV39PS<{NLPn0#?s*2KTqLVrqPG#Fu+5Qa}xqDIBfwtpir*L<~wM^R*sr)r`>5{Z6 z>_O>|a?M+(IWOV?@ze&<`2b}}NY{&?EP8Tf1Q(^*Vz6i^WsGQ>KZeip&|EP~20Bq%*Xq%r z-lVB@$3$I8`a>tuALfw$P*ckWc8U?pb+6uOF2bQ5K_jmweS1r3yf&o&+t9XIHZb6B zf(8nZIzC;^AQUT#PEmDCuOQRoaPm#bg*Zti-X_-dyt0cx$&Otp4?m>>AKy~t{jiIE zz%KgCMKTF@ystCt(nic)FD)CGG{uKHjbN4OFDost#wx)Ml9}Q^aj6v5Cs^0?3qHg;+mF0Z6hu=_=Z3;SYF7@}pIP#&mKw^gkR=g1KI_ ztP5I+|B`afnptKRI`3fNWcy~CB_yeV7|aukRG2C7f((`)*FhSkEGTb1s57rjv!1-( zDMko7H=xO$fX=>NW&W4K0Aj%_=3D9L{mwCS+QH0eG^2RNzmUqPiLrj(*!4pOYZC4g zS&6V?CBpC&VZ$SXGq1=%HkzNEUyATNUs-;-q0%o|<3#gxPE%{G)!BLZ9CistLUmUV}ElPTnP~H!j1T7$X`zKm*I@);^`=Sj<2{#{(nvu z8;^I-;AFA7I1`VJ7A#8_TH|Q46A`81AbWKBIt4MzNS2g@Y~!SQewF*se$Q zUh@#!slLuN4@Vxh4%5L9lHqgEGq1?c9!`xHaSr-omXAgaU_gEDe4oHF(_@l*Q|i;! zda}$UG_06|tC<}C!^z?=iYvOBoikdTnH1zJWRD1)dBw~{vwCU7 zItjx%S)i;Fy${vATK@^Mnni2jWMdT1>Yv&90n(@UDeFYkh-eiHX1}mx&DXxnnq57+(~r!Oe$zB9j{Ivf6M`?TfZ=R*dW`d-hI1!hRC}R zQ;v`I{K=C)ZN@SlgvW3{9>WK?g>dmlCM^}aOD8b=MNg5u-3D@;=wqQ6KAk-CiiMC) z4%xl?F1<(7Xpdfa<748f&|oSwiqX`K(R49A`(i>bnlg}oLMDIGTtM)Pw5l4Hf4DSy zWeyc&*ON?B0V8!QGbw{f1vXAz{vTWLI?j>KFOkKd`~2)&r7wMV2S{N(6F|ov7E=2Y zoh{p6#a_&%wwF`e?WpZ(t>I+BZLm+2H^P4~J^Nw${N?oQ+?|o!@Dc2NTP)e~1(jy; zj}mIt_XvPhTk70kl7w1$5NcJh-0+wB#{_=1gj(s`NW^tfsw@ScWps^Y>A^ow2SWD^ zgVllrm6JR0Fm|qrzG5WzS0i~3YSoNusl@Ukru%B=dT-z<7)tst*!xgnuat4}J>BW| zbf?4VPS4Vv#%`rjZc68=fud!ENVzeN>H`NCM*L~5MUPuxo6dr5iltlmi|4KJY-}l7 zDU0KT_uQZ~UxREXl9^N|3e-CVRrG219%PYl)Jh0wS&&N38(cbXryKxKckNh5Z z;Y#}%7X7cZ*V&N=+m08ffEA7Wd5G+Az7SCL;)a9bT!>D>G|7u?r5l5#zeS|&GSH5t zdXRw+&Yf)~hMNuyRx9pb?<2axzJZ#7&}Y1Z`27B;0+b4Kmj^pjX4b*rBn?4rS+}t4Fa|R_R<}lzEbvLY`W& z7ktqfdXZ5WEO?e|laJ}iPcm!!)}B_X{k#er>8%S zo1G#=D|4@BLbN*n_wBBWFT%D;x*=?<*b@N(eJ!^>79dvSUxLAUnk*QsM-}}le*C6) zwckf<+V*Bm6aU3>@V#kGlP^DzgYCvOO@e3K*?#J5$vHEQ`~}&nSo(rD*ST<1S{PUT zI4Ca%E##nI$?c*0f{Qgazw1+c=G*;C#)WPVE@mB-?DNyicn8zg-ix}FOblHXT&!u- z6`!AGIoX>|_IBt}@>1wG!Nu&Oe)susc6>9_W!|UVO5OO4O59h?&n*Q!x)ve@{(AL4lT16f7`F)O)jc}-Tz_h9d)9N?jP{lV9 zsjq97^u=`^EEMf$(VX5B?Fj^{N8qYrAN1DmW;9M<2s*UuuNRLmujyPJY`Ql>zg`;psI0|1>tno%QOB;vU9sBh7qsf2; z^~*Zc_U#igs&(>rMfqkg))4f;usv?k>v<6aZ2Na^23 z%?)~YZvA)62Gu^+*11fZsITYG|H8Fm{rV-t-tEz&g0)*@WNn|doyQ&)5(B&zC-dNr z&Oz~8<^}m!j}Y`#V($S$u-XIE>Mx*H;{wmdjslVnV}`(6uA2+4>Sv%W>8asyLjhsYnBn`rMe+vi~qeKxzMM^7o$aPK*<>)uNV{ zg>2{!N7qvogIBsqN z=UDu;@H3h=s`1`{Pj6&Jax_1>u;qbD7V=D+L)n-ruf@0WUNsTmN_!|GnVc&SK?;3U za`)s663tO)6kDKC7>siTcO>JAlUjIKZu;f+-sxszxC4W6uAq#J;)*R`uXGhC$I(B2 zs1{dgJWne^2rR4eocGy&zo9TzCg}de7>`H2z0x+ zcZ6;i*shCI>$ESVS}WYU;vkHwaT}pr{n)3o<%ng?6xnK>B3qqPWUG;ot;YSJKv?}1 z2&=I`MOrt0JO7-klKfN!$bubZ${X7eDJS$*-1p}L&1Un=>Hspy2h@t{o|(fxR_0tl zZmg*iS4!nAJ#zNQc&`h>xiaTRs(+N0st4yvQ|d~@`31v5np2}d%>dxMdBJ3ONax1o zAX_z4WUGdXY_&v@t&S=X*2fBj)l`A7swogwh2FbEMn0$ESV6<_f`+sGEwEPgVJx+6 z6(o58q(bO`Ti1ac^3a45m^07nk$060oL$+ximvC8D>hZppsyae zxMbXkj%)C$6$Rdkck=~M)+3wA8MmQc?>bWRNpyv}&{t1dw3a_SX(ON8LZo31uOS?x zWLkA=Y1N(RWNFA@@(x%5L0UDSik-_$j#df*3BaKveKYt$3;D8>3QKJ(9II++?Kkwf zG<$dVhB7M50fBXFqxw9gK5whfipNDS63&%|nKd$#X_YoO$RahclYBJu+m-ch7@3jp{q4t|e?JKC=0vd8dpmql1Txl>`hUZ*qu4p*U71gT9 zT9aL60u=#e%-6G{$&Ux7hFd*rYEov$9cvTk9e0LV72k2k+p5>7i^HrEM_rr~d-(9w zIkB&`-{tm6{N~w$(|I5yoRNU6>Il&&To727U4?&R0&xcf7WkcF>mDvVeYuMqRTMdl zGEVZPv3zmznYhL+$TR9kP*#7#x{6ZRtJk4gMJeo6C3UEa^0%a8h$|_1>uU4o-g}vIW4i)z5XLYEs zS4TMv;0Mp)2gBWJ$-~HF`lLfMrFK1Yl>!lZ*N zXF)a7^4z55)dFGl1$eB};c%@=z_oHgEXjw5aLzVw0EKl%p|Dn!6$(}-`M>|HpL3)6 zUs>^H@nKT^R&vE4y*O7I8rF4QfCAyFUj82=xK#^z@2(phePznsm!uU;k(==2<=0dC zX??(?HFIs)+I^%%Z-huz*bkBwR@GNFhz*mhuw&xSKYc~04b3Y{(46D-ubdrz(L(b# z0o&k>e{nAn*0V`ss7?|?b(O?$VpQ8bOOzYJn~=-BT5)*MVa{-_szR{(4T9C*Go!=y zAvqu&M!F}GGn}iwNT-k{KTBNFQuKtDex=8zw9FX2XDlU!z=QcKSU$Cj(21Hd-qo zQVR5y15!7nw?uNz@J_T=gNG4}aR#921o$N*$1 zrxSbX_;0{P(HE!FR-8^n5-{~&5FLfT#b6EydChc&L#Yt09CzKw9;%}<0w3tT#fsz^ zKUK-%r}DcEWVW6(K@n#MzjtG zes3K38*$)o#DU+RD7>9S;f*B6dsl2F=%b?euenQ z1H?aunMk$TG$yCFrgW!%{fW~Hw;eCHc@^@}0e032V`rW0ZCr4bC%{!o9p7Jd!jvey zuO+2LD`TR&;#?)WNILgZfK~ZsU1cD$Cb3VuUOC;GLONozl$3AQl|*a_7fU-rOaE;C zteh)N21lOR-+HBpYZsd9dtt5d)ZFtw*ORW~sSrr-Cj98$aIG`nOYi{|Ck85x-*JMT z*AkoMo;5B{YFTm+hw2O!qEE?tpTYmh04W^eC1H7G#!Tf?dZ|7AhN>Vb6{R&s?_J#` zO6w_=XvIXi9~0#tm?)27qMZCXAB2u19jD4arqy>+8xv~r%``!`+<*f=IlsYH`3!1$ zsXX#%GD|bVsPqevDwJpCy<);q;_mNKg8FqO9pwofZ+LrOYDA zXjw(|sqCIq_G&7-3zZ$NHa%2{r>lY4b)icS2WDqaWkZ-5tY0d6o~2AVS0NFs@_DYl z%nc38xzb!w2j?nNk_3u@^bf9^QPAbI}Rl0`C@0(39Tuo9K zYN`~5q4LeQp674bSwtP#$eA3!yRAUEa#p7zs2JP%`c@c}C zRK8hPGBXxLR!%eH{HHTWaz;K`SHgw*t$U2RgZzMiWhLoZkDIi|6uMijwl;$$h$<{W zSh57+$r40N?S!-@f}mpBq>F43c6pr^rB{TC!|p7Gzg3ca&5Zk98)8-vufJf8nM}q;r$;{~lqxgD8anFCYnU#MLi&+Q7fn43={1^?? zsu!bHPEvV(azQe}3*jHR)vesB!BWXJSIjTxiiOG1+-eQA{4`vr9hwcQpRrbTi^9*h zQ1DyI5=To?5hoJV{*-b20ps`s#_?pQ7_p=8Q{Bl_caqlH2eYY6Gov6TOM!7!h47Eu zebs#0CxryaGN+$lx{|xSaWr{V-y?}xr%pLrMN+r2slsUtp_~!l_E<&!SVey7++K9q z_O$X?lF|I37hZ*4c#wBXJRLeS&&3~7FdCM)NIY~UaM0n2*CcCBM`24FIDL`$MDpB6 zL|5vDT0QDR(^F|er>KHcRK_WtwVeUT(g}>rUfWJ29A3hI@I8a~a0c(Q4BoK|WUTfF z*L|9aWK&+kqC;O9o^z$SqS`my5I&L$JVI@keWLiS1fmj&g3@S=KyKqdn$V!WEot%|jcJYfxjwu$GCoEuZ%L&L!ZO~EWxOBDI0Vbs63f_g zo3!_sWU1yX+>X@8JroB?li#iJ7{2H!GMM8;A2TM`oji&rot!4Gd@4ifato3bp81dF z39_VgT<_6TmLcymnl7fUn^M=GFq$SQQ@Av>x`vLvC#xe-gkF>f0Uv!mYgOB`+`$3| zGk!Z7bAIg=jj8azWSn5kO_NDqVy3;4PYGM`KF=#x&Q)fq!4IBF^hBzj_{dUAx^0N= zs&nCE8ns=4+OAG*+f&>A|6+AZaU0q(Rh~xAUV)yyIz2lp2e!1I^4zcyv*!Y%uME$* z(p=GvyJuy!K)K;B_m8=n7Ha>%1Z>f8Y*BkHTU6tr%i@QZ?BOd}!!NS$hojkUtgMQ@ za$zK2$VhI*Nbbc*?!`zRTiEu<3+4{3`xTieMY$VDZt-Hnc+Hgaq@&v6ZvhRgEFbGw zZ1$i#-9UHx0db4pYsD?91+6nWAxPPn?&3&t*}CGdtcxC3)fQ(hSoC<6juYOg8a#ze zUrNzRhE6J1`vJ-Z^2q zxm?$0p_T0;K3`n9M8qTSF7rRXQ!Lem45MT@ zdl;4}!CmNJTSXa9eO)&2sP`83%k!cyY?Gol_;);kU@8PoIejpsBtonkTNqBob)ti9 z1@bG9$Ksr|=u>8<$_|5^m5m7;necBIW)d@yseDK1Ull#$eQC?CX7 zni6?o%EU>4TI)RCDk(>rdGbNpJ0U*wk9s>{{>KfI0*8bZI2!96wRxc4`(;P~hn<#t z@C>u$ZOSGpE47(K+(iuG=rM$&`?;t{s-}D&#yZ%UtgD;!(9tgy4t9e+u0YXPFaM7P z@pcpvAgd~OpSJ@^Da@O-j=ijP>}9QEHftT# zS?jQ8Iy;M&OWH_bF?(OmvXHcqm%#X9U?%W`3f(7?tHr|=GdWk8Hpq|%owlw}BwiQn z(1qBcR@k9lx>pz@lf)DX(L4Wu!pz#TWScN+^KZngZ8}aI1K2Aan7d$<=4M0`L7^?I zRb(0`+FJ}3aj@6>tQ-wK#AEJ{OK2Cq_wo4Nb4)f-!BkuHBz((2E6yL?5tG_(3>}`0 zqLZ9?&x<^IOOs)ux!eoc9~zUPkW)|wcSwKSD(z5u+U~U57oIKMo%YcG_QTz2zwAz( zlm6sF+F!e$-CUY}@5%j}CwHeU4e)+&JN-a<`UQ(I;pwSEnq0gjgsb}@0RgAWJ(Qya z4`E#$*qSD+t2GJ2x~elQJ#EV=zlRT3?+Iu=zR!%e&%8Eg#@1PPwuhc6K4-?Rgge{c zKKuHd8GAN};`Pj}+$Mu8jC@^B#J^Vc*eL5|zZPFo?z<*-7DmHe_ru!6$T3qf_ljG(_pSf<1f34=RkFDqKjayXiT9Z}g zM&n(h;$N$EY_Rp=y~P)md(>pKxlw@YqWJ&RIyPwJoxSbDsy}Pe!Ms#}>ujWfBcEKT zzG=5;#%N!l4Ul4S3q|_VOr$YLULqAo+KMz3$&-_Xh%^qJ0%4#THQPU8GJT z#my6G5K)4r|^c$o0k% zfnT+F)Yf{R>dC#Yt@}X*C^yAh31xxzdXrdT7~FZ z0n3bTlsF=&tV{DNM4w!Cq}cs;YdI{d`CzrtjS=p0Fl71dvC)m8WNrP2lGVvmPEcD= zE<2puti%4@L+~KsiE>jGc5+ilpCd(x6p!=-X)@9>O4SposYXrGcO-X_Mj?HK zJLOKt)D`c$YjmIwj_2}V~ zJ0WAuP-HB30Xy`4@~x1u8cj?RGFHfse+fv-Wxzuzz5zDc2M|2ALGTy`!Q+e&JoYYr zT?^eZ?%FSwBOr6wi0ma?mP^j^V$_i@AdrSQ2@s|)bf6FbP-aMXi`C5_4Jiq1%yqCa z4wRZrDMLti?)KRfH~El2vJ|taHFO*9;&rK4m)deqrD2fczfAgynk2pemeNjX7G@pQ^@ z$3_4{ctm(zd0@Fo{#|eHYwA*+hSgab7CgFdZkKK55^18?Sk)98Yk^{89aL)((t!sc~9R;SgYL&btE}cpp zX#B9aTowY!eJqh4ZxEcm zBzo?`lqzugFXi-q{&bZKg(-YhPrN8R(|E+yHGii0f3MqZe$Yw-c{IQ4zF) z`MvZ#_HCkS9qV&2NSa-Qu{1l!kEPjt-V|2WCp5Sux@8+ESP@dE6&SjGo-~>DXE+Vt zRT{ntU@T!z#?cEj;|sLAFQu@#eEFB+Z^1piE8NpSna{cGwB`zbas_^7EI-}z5JJy#f$}sID9=p!Qt7*K0c+fD$o4vWoKqRfs6Gc#47kz`$sACRVe7I z`RZ^Hhg;NPIERVqFoMH->TsDH-c)zM#dAVs<$%M=&deG#9p06>Vq+~*hl-80Rvjuf z)(&;3*jW42;W|jN?2`kEAbSlji3xiHoP|{T+{?P?Q77u3&52xUgLS)UN0qTLsngSwg2Z*dOAhMF3 zp<}u82CU-^ILRCEEp)7YoutNp0F0#&S?6*_WYvK?r5D4hG(Qwfl*L^6*~N1~rxk9Y zSA@n=Fs=fju@qD5y_>gp_xjCLTvQ&CKxnsL7P0$D0%3U)2oK1X?n7>U-ga1u?OfvHn}a;KgLzjRPnLkJ9tmaaA#=k=x!Dv@iDXf zBv<6JWD&cM?U?8~2x$q@HKcJOtwP#>l#Dc9q(6~%`AOX3ov>~;?i0)tUCoxt8fOC1 zJ*0^u4MIAH^ayE^NUMmsYtIa5@|B$S|(C?(npFTP2pTfHIV*=^o6gS zYnddEHzEc!iZlqRAJW@MUvn;`VMx`Hrg1K$ ziAc4PzTsReM4B~N9FleW%1s1HBKn{eCFFS_)k7jTeHGG%!S5ubd2AS5T3o$3<5V;W zgOWoiY@W@Ku#6-i1fS(tqAJVE7fl$~$D{_IWXFhaBa@4hFIAo!bWmupp^`e9@|?7DM#do3;3hKnGgl#3y9nwTPf*W8 zc00ONL)zR~BZ+lSCUYTcgl0yF)wyr zsMro6GhC~xGdEQF@r*=p>BmP)KTax)>}k4y!hu5k(4sV*$4O*(G?uzz5u}%|HEzKV z%9_)mLlQib+R{9N-Ocqs+)YOHM%iBZ!8%>xJkh!2Kn!{C#AQQD))CZCMN2v|f{tYb zO<@GR!U%eR5i~5=R|32K-pLR;mLW8Srahiu9`=;Z7Q80_t^q@rAP* z(5~_g$x2qa_T;Yg=Q%*z%5zJ@?|E3+gS#Y#OK4a5hGe}E&!u(bW9StTmrO$Qs9+ z^gO{yvzZ>Lw`=)*nMoNkiFi>ea8%RF|6^aCdljDhO9dzm|CS}4Ls&g>yLOgc(NNLUX#>|V!QoY(9p4KAbGwsPx z^&g5T>E|&A>%%pqX2rtDBWGQ&Qer4<#ZY(^j4V0_u|r-3BP&-c!z^Kvd&9mYwg?$Z zo<0e|Ih#e&yY}9?!VUxI`Q!;BSR10Ffjr1I((VnX6S+6D1RqS4XEK7%BxY|W4M1;O zLob6Qvyis2pu>JBLW$m2mwCe5_kzVz*ivRRRp%Hk-ao#?LEqgT;biPmp|+6GvwH4U(f^Of$}I=Hpm?kS zGLj|h%yP)VEOLt3E!%zP50BMU@K_9_p0-l!F(B~#1c4WG@Lf!zY%KV?32A9P6aqjq zL)Nf+UQ7i4k&Jn=JtTdk1Bo2H)c)mqAL?fgDMIn{RDYHIFCB=%OcO@u26S1uT0VK& z4?0YWoFoNkzoBP>i{y8&>f1e7<$DvG>qh6knC9M;&ixZQ_ar*^7|8+m^s6kbT+j~k zFE%<2VvM1o{N$?q64%t`&}9gD&KV>- zmUIYK^87Sy6tcMoz5Zo*SWOQs`ex`%LrNi`446A{x zDSP8UP+Qk1|D3nZ+RjKIG?6t&4M3$CUv$=X5NP;40v+t}S14h|(CH z5YIp^&V-z@!374TGSS0UivK|WLzT#_aTw^ovxYV;3kOiq^RZI%$Hy9QZ2G>VhA^U9vgqZ>qE}40tczZSl~&bBhQ+?C?=d{6BR5XseR=t(Kb=?wjr2j z6ium|ERDjnT5>p-es)BzrQQLNWtSgBRs!R+&UA2<3H||{`!;Yc!@#+Ga5P!^^lDj` zy)>!+^qvL6@X`rpKyk4ZUXDAJ&vWTbC@5r1bbioSJd}!yQXk8_b`rCwI@m<4K+P1( zNB7+6O98Ye(g3p$rtRq2r_r-lpl7d6&u-sK@v(^eXvga?jku2r#C=r9S)^=<+$@fK z*f_7oE>V_H-gb$8)=NQ3(W@+?+52J~z2HGPnk?h*6`uJ)o_V;=Set{U;(52qh_w)3 zl4^B%dl0V5R)#Y62GNRFvF72zn#V%cJgivr@Z!f*;ht1rSE2h@_{koe{^et|`sVXo zuOJ0oWxQwlMd~E{C|TPyuvm8)B>mShbvnUBc>}KZ4{*JI|AOmX8u>7tu6NDCVnu1z zVb7PQj*NlKQB7WrmR#WwPKgLAyNKN+I!>SIIpLi$L?oByikif51366;mf7iGw3 z=E=&oi86LqR>=aa68#VLH;G_ZX&}M6xxs4zU`03RCLSEU4`1L0Yg;>tPMixs_^G?h zJto01#`z;w;aWgpYZU=Y@54NNMzX3Dux4~esi|xP!WZ8F**YU5_=?$+2eYU3bnZEA zI(Wcg9i6*c5?ibF20V|eVqqgc`-JfRALsqoZ%>ZGER|pEEvra&+-f2GV}T8eAYTDr zZPnX{ARhVCTB{)am@EH4ZI4kt1Zq2pp*)76{Ga^>xAOfa4kMGSW)b~#!ST6tw|Tlq zc*aFgD3RAJzXr<7hjXbb>KV=jaDDKpov zke#uUA>+8e8pqW>51IS0cVaSI=~e&v+TqkbI>fShfcHOf{KvpTZQhMn5x`8!9l*eWy6w+*gXWu#Efv*71qzo$NKQy=U}CBAooYSm(;gKE{e zo~Q|;%fM;rUh*h~FYeX2PF_W#3A`)=g>xOAo|Y2uY-xIGKQ?$$b3^TfNqHvMVup3@y40m-Um zGJf&JKL-B0>;x~%;Zx_#i0|-d`>C@fYniM(Bl74{&w6)UZ}lH2S&z2&Iai{V$+{oV zD^BoQZ)N1=`e*!Pli<&-U+-A1vC%-+v+=K)_8epV;jcbR$}MZ+W??kc^>F-a)q46{ z|Nd)ac)6dN)UYrb;Tjh|xq8okTfevW^5SxboBU;NG}?80{Nx%vhgtu7Z{5Y^es8kN z+-R)p`uNE;dk(e!Zm-Xxa(9}{GB=v&x-5Qjt)70?clJgC$La?NYrep%din^w>T;+^ zjm%f4C%pM|zi1zcRu?T5#?=Ih^%uzpI93AEzmYx=DH1r=5+om_KAa3V)-a?#NbZ~q zsRfd&@T_|F5T2C}aIEt1vRWf`6)7@Uq;pWOZ0ldEcqT4Qw9CM;HlWp`n3G6#ktQNl zN9xGQfMdBKy@AwDB*&&b!|#D$@qo!=7Y2KAVG{T;JCwR^UA-q$87aQ<6gxf<86C~$^QVK}@S?{gH?RZ~G- zna`dtOsjh^t$q}y)h3u$_k?NH3GmfVfUiCi@YOF?QYeu^JETw(3SDk%9lP}4a-$o2 zYh9Z>u8nPtZX27gGP+?mSio1m2?lFg>h;OvycSf5?$r0%_?kCdl18|$uH_{{|P*?TgT2+E;^)(Wxt2Id0NVAb5 z6Cagufanwn*Qya*D_22X^#pZw8L0(QHzZJ3bs<){L9FT}#Hya4u6&UCA@xB5brp#; z49N=#)YWCAiAWzJfx4<2BGRl?N!M;3_YHhskSB4CKVNKiw6|hhxhTe!oiMJdK3O4* ztMU_%E5_AL#khJPjH^|jju#}>(UZFbiPcc*{L~4dWo#M-`RdG3p*d_@X>{do6ri*5 zQjN`_bIhyx+mQXC}l9zmAc{tM-R&;zo%>( z7+6$Ht6b<-Fs%a&J@&)qgi57oZ_sW6rT4n@^yh?1*QYAR z)vtTscGeX1B&ClwNFyh38_xp?DbkKuBfM^w8RNF|pp0z6yz1>`F; z$XC}o1-W{A4wbiLyDe|Y5JkQ^QY>YEiz%wp%msA?yX%Wqz8~p9#iD3-3{{~@({~H? zLh-qHuhvsn8k|-o+MNtPRf`^c^-U|I!Rj{DHJkFT&656k5J0~qUcXFfE_SEF>51*E6W#0zI2c;*G-1H zc_-bmfOPe2R^Lr=OD0905TwxGraA^Q0kxK!n& zb~k}8Gm>g79yUoZS@7*LA!qXUCiDWcq&b4KybBbKF5wH;R#BV6Wj^O3^SKP9-A0gh z{XyF8TntWD^uYftsg1eBTr+vM-AW}m5^)9?s=T=L$AsA<3}N1t%Q69zO02*Wp&Qh zSZ z`W56ZKYp{Rf>?1A`botOJbBvKc;wdtvvNQ9dE11M;@@4^FrwQpGe2+Jh;3mP$+oa( z9PfNp)ej%A#gcALe%o2voFz+}wPf+r-j~JC11xvNrv?(rqDD8H2hq zhFBF3u_^@#)Rj9@64FB?P*)3(t|L7~0(Es9=`m6|5~wR zM;eP%3klSfG4WS{NOk(kO@O*`C;TZ4)RhGi5m5_})*vpI3;v)6EtC2{(Gca zp`!%(2CVbgl1$(L(H@F!#uuvnd1Cj~Mbx1kxxNjDJotWShmTnfKgn|Vw<;`4Er)O8 zjUWxIZ$3kx@^oapi{n}9y`h0!5vTE9Wd=wYlzycnWNC@*(;gcJlMi<;QydoYo zO$3uek;P0IC?pD3zqIWvY3r{Db;Vn~qjQWn{`(P@wX=-$tz#EZ3u~zbcWPlBVOhNi z%i35$np}T^Go;zdKb90nq9&kO`tcm%bR_Xtcv`x%RSX&pr5%5DkBESx4v^9re>J4T z*smq0dA=Xn3wj@BqOMZc=DLqv_6%>QMY|;RdS})VG|W$G*@jJc{M05qI~hU8GJ>Ws zf?kPC+P`Imqe}TaPxtGXbqLislr`C=Y8ykpIO(;k(ayEEjdGrg_qbIXm|HI5Q746KGyaKa?uS7e`L|v);4H?!m z_WCZ=%#5SS67D=SD{d_N4rezB!#qKIU$4TgZh$&FVa#_>XP(XE&4?M!n{kescgR}v z(y4oFh>qY*$`(-1xI2`NI=79>^N|CdYwiY9jr^YL6``(}l-yv*a^T?IDs}ft##(nsBVWUct(`*v?Aa2BF3m$x$Y3ec)f#p)BfF@Bwgt!^%CPa^PE6M@%-2)uA2@a*T2uNXz2-bE#L zlZR+OS}NSXjEvaSEEYy#1XPKk@G4MOVw$`v)RkC1c_eE%#SAz;{RG)6-;%B3m1nk! z`-Z`@m`RBdyhM!Pn_>j_%`k%Hi`EEks?I$SFsx!etBop^4eU)yIqzOkSuOuzAA>Tj)o?i+28xZ+Nz&>^A8Ihvl}g%JmUMD}7(+xo?j-7QELhMK zD~zFj)b@ zwGg%B3OZ9xUrg-I$YJ3r`u6SK9TcyzS-uW)OWn^jhsf{$kpvM{9ptbW(lnuy&J}gV z6gf}(A#b2A^MQ;~3efJLCq1$qD^Q8dlVj@B*Y>2jN73BfXzq(??oDa#pU}A{(YdQd zt3JglLVV$0v4ddKlb=M#0M{;?$g zn2$7YesWb>MCSB|Xe1Nk~sAX)v1uxb~L3+$`*{IEcmXW67QLKeE;QbHQ0GF(i#wypbU_<+<;)BsPaC389V*&a z)XT+@9}|Vs=jJZSJXfB`+`O#~1!+(CLT1gqrMa2vM9e+U_LW()u&YuSr<+pU!>H~v zn8VvJhd*h^;jq(mXdpmmeY4q$BjF)uV zFgTh?v)UYGIdLEDi2Im^vxp{92zH6GabAsGqAa1j?GpX0mx7eyXZ!MxIy@+0wok>Q z8_P5I=b5W5<#OA1ip>TUJtc1sLabn;CHjgr4}aD?uJ)i6uVT%^g*6Wo?x|={S6H(i zoIcO!t0F0txpRks!B?3Zg>;T-e0=&g8rX2APG^}q#WGR$|CpwBg3+|m3$AxDUKfk0 zl->27jRTw!Pt^~@I0MKdS5R5}tY`aY?qNt36tsTEW@eMHz)-byA-h zSCt)PSg(o3Dp6aKVELXyGJJ4X5u&d6K^0j)y5>ZyBGkzQmn^fWFD>F6)>-~ixz&~S zvn|eFX+OncQbJ&*t`iQFKAJqJZ}$bqKfm;;|BC-q9&n}o42!hT$~7WB535WZ-2*w5 ze^yMTU>u$lWRnbcWs3ZXRigKy{w7gws4L}6fHu_{+Ef_@p3?U)Ss5dkCX*m}DSJzA zlSqTQQqCW-3LA8XwN*)BxAZ;C!)Fwk^l(59+c>`X1{`o`sMfa{Fne-m_Oy=9-Gk13 zJ)OHJoqG)1jrkp?b8jG>yUenQ*UI_^XgYURF?z9X<<6^TOfN?B%1Js-sltR<<>OrJ z9Gb|~*N&Sg1c;UX=i15@3u0JojZ6}^z+Za%5TsLokaZQrZy}XvMQ!(^wtt|u$57kJ z)OON5!l_2%FiKVqBNn|hW)c1LXzskgmd*bPi#H!;OkN}{Jp;8`gIlkf`=V2p`~z95 z`a0{PQ+AGBbtX>s3V&2L;k<-)F^*Sf9Jgm2_gCY%TFfpIcgiB>%6j@vm|PX6C8NV2 zF_hGopREF{GA)qKL{o*}g15p2?}ZCK78ks~Zl=D9kP6Y;gRpUEhy5&Fog_f^TLNUg z%5sGeu23YYB|40o|BKlsl3Eh&u|=6CjhPhpXHvWiJ9IpD=tF$(x9CdGzE6D+VIu~P z;DYmrwRvs=*9G+cm+mExSA)7z&KkpPSg4(7!v2Vc*}2ek%Zl`8wbHK!qz_1c_-Wdq z0qIX;A6^}he(^%u-hk9k(;o~-yZPAW8kMY6THd|pE760o(*?KG>H{?@fndvy)Q_sTa(lGeRJFl)KzIvSE7$@hAzdA z51KqYUHA*`=GAe&@Z`t>mpxpWtGSQ73(B&k3|M zJ?!o5R`NlpYjClaQAd21%_(hbddK^QYss`w+u$!-MeV=*`T`Q!8R!7=% z`QC2(fdQg5Kr4>6n_`Vc+UFuta*#-|B9*ohX(&=6QVgXmMJj`|6KMmb8j7^mS)@p$ z)s(7V;*qzrbFsA0nLQ@Aidz1bl&UAv4JVOCAuSdu(7Z(IM~hDl5X}p10maOuSObc+ zN18*iIwI}sERrQsAf?_FX(-ZO-|4|=KP8pBv%<)CO0yd8Ri1Ed@~IEQjudP1b5PYe zV|zteUYi{Hk*5%je%ZXjXy7-4+yv0D|LfCJ`wUD1d$f6_k@@!}1jNw!@m|}xm5kKC`a8e z*Q)h}iqO$HC_ZjpkWY^}psxM{#p;2euBL&y`VG|8=YqQW1Juhxm)v+!j#Ub5CYKhcUq~gG;N&u^B zi_}e|_DIG^9g(_ouK87WxAp^bGGFLdQL7T`1_#y`Al6WTSm8*kMJnAur0LG>tivLY z3jSw}t(0m|KHg_7(t4zIB9(3^(mtduNE;}HbOUK8(nd;Iid4o$q&TEaw$&!?I&C=u zaK@t&pT@L*GF{QF;)QPY^^aGCZq;tUJ)v7I-zb=dqenl3ZgqXXz_7O58zwNUzE5^Y z@nJwY&H&}u29)Cypd6>hjQYv({9D=}mUgv#1EH*h!`Wynl$GA{V!SP16jH_ok`v6C zEp>%B(g@1TjEc3x1UUAOR0F9Kr9cLaqLd+|X>;~YH!C@zr9iKEV#UE$gOp<8XNBJi7KpDDW4enq$Xiz4^NDHzsn z1;hFf7#5HmC^n`*RZ4Ql`bqjRtlqpZ&LX6FPB1JUW8TQD?4=3>tGd|GGeL2S^1;Z` zLDCB2fk}Vi9Y(GD^1yPH#*gd0&GS-gX;_^=-yD(NYr=r-p6~8@54zR)x1n2YEZ1z- zps3Fj-O5GLtu`na)@cR9`c%QNntP@8-RCB!fqJ%GQP1MxS@i&awF(YT+0@QKLo8kB z>=%A5Z;4eSc}u(;96p>BYXRJlTb;_?3t`Wjp0iICZRyTl%LD2Oy`bwT%5V4JzZY;q zGfr5T(%pq28F!-N8iqk#0o$r{*YCBASB7iu?XF z&%Q1#JDEN;Yt_ev3ERjD=GCeJRqR}5a5bTZtZ<;tqXTsh|);9(CVDNRNAB+ zeJ-_;^JmexWYI~l0CiT_vFPr6|vNeE6Q}|*O9zIXSt%Gq`!I39JyjeZbBwSzZSJL z*;S@Z5!0jweLXvx{CHq$xYe^JCS`Wqu{Lquac7uSuTdBGdPQIV`Ha`#Yd>#{J$!WP zoY>de?{fPjesgQ#>5Lbij=fF*j@Na8TSW>DXY%o#n@R<}r7h`&x}uO}&rdcBb}Qbzq5N8Pc!a~A!%&lystzwIbvWvEIb1&g zs1_I319hbe{b&7!-HGOv<>5cOF!S90Z!h=x!Qxfun%O<)c}f{=XjZUDiAZ*oGAK0b^M{0nLL%y7+)|X2a*9g7ey~gVOaIktGmU{m- z5@1#bfLT=b7%DrN%1%<1T~_|D(t#(@vyYXRqmeXx-o0?Dy{%j^-tzbe2gpye!B5r6 z3!2qh9$IB+Q3mE^y&^&uOs)bEvJ^+_wHOJ;e8(?T;sX8@+JdFzl8up#8|)59nz*%u zd_)lhkYLm`dW6acKU#XhsIRrQWbq~xelMZ$vrFK!aKUHc!D{w;VoXjQE^YkTuf%E2 zCQh@uR-9&c3F4N>C_AuM^T1yHDI}}~@UliDEl0YJ1TSkV(k7(8klO8XrzlskCEVIZAH3^l!^o|>poI3(ngAjH)H|4EIZ&>Zz7dI zf|oTK=^dofLa$ozg|D0oI93zrRppW3W!*<=gY+g6yevDgSKX0}k>F*GM*0ZJ6bW9| zR-_R~HIU$C-A9^&^bQidEIR_G=0UjVzTZ*fR^eaxzPQ|f&f^*&wJfVbd+EX@3n4)TOn z7&w}W%WW}KYKM-@5nZVrLmsT^d!#?$q+Qg?c)&>y0VmzcDd0oO|CnnAo5m%Xfz%4X zMKTZXa~-_To$x--p|We@Q7+<44^D5$XezDC88o}&g?y5E3VAhBTGCi!X-O#!Xi4tW z!a8E!d*e9VNMG8YzH}%4=M3;wd18DB7b4j>oNytX5!ge);3bnTp>N)UN{*1d z1{c1N3hqb<-&jKUQV8L@g6sbPuK%!;@)FosB=nCm{&OsCJcTxXMQ0n=g!Bl9OSUYm zBk#dk!Z@>TSt+-=N&r_A*9h86LXH%kY6^HNlYAW})#8_PChfHE{yY^nNmSV_jkOAC zvca{(yd$nlGx?Z@zmHItwk_=>{7%BUZc&r((9l)p z!*ZyT%faC-CjwzPz58;CsKkdUD$`L5?V_UX2@T_C6d*3EASvVp&OO)u$Et;tRbG$` z_521)ImJkZ?;oU`bdvZFdy)m8@A9n)=Nisf3;j-IEjH1yF|A;+tg(W~RrPPcOsW^b zCV^xj+8#$7ikOJFhIgVT!I{)-W$B%c5I$kcjMJ^4QUd>2=t<@?xi5N^Tu=Ysnu_kc zC{?&u$~HO8jLI%+-b41elaN)!b^#x(sqa!Urn>5!JJlKTp!e1lYPU*-ita@F(86c@cN1lh09QciDOY<*@>l!s*T2)Fkt*X1C`qGznV&I&^ zz*+N!fm1qUZ#q*OsZlRxNjbuU)s~0Xw7B45wCyk^>9TZie7fOMKMWI6B|V1@6X+G> zdJKMW-(~BHo7CiIEIZt0+2K5EOgmX)8rz#H{}v1B9EmVLkiPa=CkwG%wAPq%>BvX5 z-MV7DPL8Q8GG&-RHECH{)5D9{Akmy&at(gND4DL3(e*xjs!4RvOp0HSbkB^FAT?=E zpCtqRGIl`+mG+_cVJcgM>yZVnDI^OHsV*CAbdIBzv^7r!OsdDMSkdsluzfmA5LSs& z|1pD6kI>z&U?AHxd9*L?L5^gYbU z09uHl2pmgeC23ni@|yiWoQLj2BH|6|BU={XSlC%wE6U|r-s&DqKOV(A*$ou`Vo>}| z?WFa8QdQoGq%G9`b!xw|RJC-|@-H?F=?vLjn4*!BSXN#I+HyW9zI|!&uLzX|e!mbX zz6C*Ly^dX6fMj$@@9ovFOzz808k@)o3j9>9%AQEq{*3KN=bbVHzK2?Fn$O_bi)pc1 zdFVyg*$XWZO)WemqJhAZu~R54RkKc*vbAmv6ip^;0^!oV&xQ`O!C(^0CH<&z!y76F z%Rmo?d38%`^z2H9x|9yJC8OsAXK8DXdr4bMSwmZEN1Ea|GT0uELe!nX=104haaFo- z@c>uWiR@wU$!ZG;J=caMd+T<9boD+=1D~ty8OS~{)^;CETqpl>0oQ^yDogNG_TZ_) zRzj-M`;e)u=_`)3yv+Z@ux1LSXz!q{FU+ES6i^gWDGAY(mHSwkK?6i-oB|BYrR zqp=LL^spiHu$KN(!Je{Rj44ahsCDGokvreC+Ek9kA!y;#f zgD6Q=4xS##3D@{bGF>S8XO0)hg_7Ipb8>3Htm~Dh>*J+L6-E~NkOwlY^`y_uap_4@ z+bRulXicfkB(|iBNuWAEpd;VL{An2Tr!&l-wlRPDL?LAr3jTDC8*N0BX*!ffoey)T zAZCRFlgyX@$1-&71#o*5l>Phsa?$yx~+hO)jg90(I}cl(!&IOykDV z4{KU>1zL7>=1%r+Nu~SOqd)Igx3D_Vn!j;K9{C8wK%_=)eT$*KuNa z<3v9bCZDAw)GFugMT9CSzK=%o;KNA~wkI(-iJn+zZOgPuup4UYvhwma+`@6df&qzsn=NLq5BwL!U+}@H?XkyK~}p+tu`HLn!9)Kxwj}Ip6Ul0`SYDcV{!ZY zAEL60*bvci`d4Y2P_cM7=NraxqM+>8aUl3HPd>yvIf8kzqjDe+q?)3FRFi0OF*p#U zYQ;IE77}YptF6F7VvccD8HJTE_<3z>h&`-2${g|dbSr*zS>mcBXtd!De!0OU!$)#y zu9($WD2hlfwcHe}W9a;5w1?-{7LyJHR`0qqA@KFC&+IIm9q%@=ki{(FR(bppc;QO> zFD-sN5Ll(_vnCb}j(4psbaGt88oIwK2kifgvtt!e6#%DF;84}E3HIgdFeWb}C^OJ1 zhwTP6RuXV7V!C=60jbJTpzfgA?;U@CL_*SJ30$%*ea_Ltb7PB<#+j?u}ye23Mme( zBaPhA=@N1y6K0^`S5=_RCPL`cV)kB@Y{GP=-2U<9BeUE%eL_4%)vC~?BDXc!IAiWT@Sl)hrqdk+BBv zc`2HtK@AoBps!+Mb`|wmohAi3{~!fU`8|@qrT_cEcU78fE7sELMAM)5?m27zX#1%%5}}h!HFiYgAOEsHiB|5-FBg z9z{*8sEHbTK@reckqEXZYGO}(RO}5b7^8+HDux()M}Fr$#D#@rSr9hg@9&#`_BH!q zxcBazJ9FpEIp;mX#cF!vfL;I5MOxT;d@A}KTX~_?%lti&ipM3KZ8k!&V?(b^)DA+x4N^`3ipULwFH88*J zo!`~;Rj@Nb`NIR$nAJK4nkwC4i)(X^W5QMD!NaK*c z5-Gt-q%}?-23)p!(nGYRRD+P!8bVe_sx71%gsgaQSawLWsRbcxDpGloZf*^U4{Q0K zMg?GL+z@g~K_RC!>ghMC)tqm_j(AsIQmdFlRllBsbV&S0kPh$lS4f9#tH)Fe>bX-m z4_gy&Pd+vjq=WnG`X#~+o2PdmQ2wB^OkYzU_tVT%e+IoV*x(5ntpP;Z-gTi_M$qHW9 zckr^t2rp|bysWcS+9j2$m0NTyX;jHdom;+cRXDcTnuN*Y4%e#GdCP}u3*2#RF{)Mb z#7>1{e~FaB`PSDTcJ6mvI9i`f6SBlYIlwl6Tf%c01rFs(l#UrS%V;C#Ut%T+CnX){1CDZB5kFX&8c?%wls3S z3aV<-4?o&0+#j#dSPv8$YpkHL&Xxm>b$f$CWA#yJtZjnEsyp#VA!!Bezbn;y0om9Y zE|86(Z2)Ek2?SzirAqJ5Zww#pa*Q-1Pr$rKXJ>fE)1Vnx9)M!f5wa9CE51MnznNTS zUBOuV4TLPkX1@6`Uo*jhH(paIfHYhaKPYR7SQlYW-C^S}I&{)^%34o+kz4vlR$Wk0F;pBOn zgGOq{ug?scb?Dn`GcD)QL^;7>&B^2+%>byhmHTf8H^zlpSxe74dZeJDbg-|oA<1}Q zC?Sixb92SDB}0W~CXKjI`kR}KUhiBlH!P?_J%z?6dLO*g~mFs&{&@+G*%-; z(y9PSt6s?-2ZBb@ZNa(NnnS=E2{7wj8PP}70+`jh4r> zi>N_U4E#mIpw`YA$VB5y;umN8aU6G-32kWuwX883l$(cT^P2!cy6VA;ITG{kgv}pNoG( z!u!mZGaRR58*?ey_nCCr=VppI?}^9IU}HOwq1 zJJSTLvsth>c0$>4`uE4FO|m)3bWXzr64eveteeRWZKXrk=F>*s9J^o34Ho2T_bs#Suy! zfI3#GsyIc88x^CAlfUR9N17CCbu6894Qv;u8V8JPI7}4tgFLFewwR!<+(2DT zg>PjE-|BnCuWCrKJgBQ3pswzK$0{T3?$b#QP?&ZHs5DdBeX3_b_vnbSBJDy-OJ8z= zhcpWwl7;Y)BETKh)<{-JP?H8Dg;L8{QhCleoikRGix|Xp8BMa}jQngbE+UAF$gxx? zs)fL_7D^)wgGmL7ECZQtFRk82nz-rvzpr(0TN(rEYL&EmA16>(vp`+Z*oicDoNDaf zY3y>+*fkU)tAft%4!3I*+^$M+yV}D518SC;1jor5NLWFBw(;m!kGRC3gn?2%zoggeTAzMjf;Wy!YPYBDXRZGjdDv`lu;dN-4*RUNEAISd z;?Dm?rTT`M)lMj`*VoRiG*j@wuH)i$duwUAmPxg-6xF}Vu4vP|pV(;K`Y z@man)(?9>(a7$~K4i){iN%rG7gVBo9&acpUCdZx=@DGAC(b#cD~KFuX`uPa5deS|Czvre{DZgHzNc*@{~$ zX=Nk7F!57w_W3?tLE@`gNCQWmCMf4Cf^tF|y!6<#-j<-8 zJ_L2_W^^CT=>9t`f035osMYc+XYo!Zo4R-1v_8wItG_8M3b}ZB!M4@Cv95L{b={ zn2yovnixFdA##wLp55)u$ryUfVEp#~*nok(1jj1C$V&=}(Il}L42@+XxTV1&QVNe4 z9J(QJEXB>q5W3OCm)Y=fqOnxgX$0vDW-3H05>cg{Mi3*^l^CI~-)!ohbq+eyudHkF zl=v~N(VM`LC$&;{4&+kHauG(8_(2|=QHS-hL`7UF+hm6dqN1Z_p2siggWc3m+Cm3eVC(~4+UAy?691DZ3B!4uO-X3Qg)NxgY#+tau0nWW3oL1Yw?%8ICVS2*j-$l-594*!tB();5Y@JtM%^f{I zmCh@BIj?Nly}c*nVbh6VuMx zh!gJeR-2t0%@EOH`efHO$ub*5SulpxVgzvIQ88n_#@eSY!0tjn$=wgvIizZ6a=j%v zYycUd3Sc!zzx&`8jeVNNUhV`-%O4B)79_jVknEOMkSCzYxAFw|vv?7j+xCfZjS+40 z$5>mL>o9+Gct%um-(fQ8kFch!_MfaHatu5Iq9-C^4Yj9IW>a(~8wJE?gSooS% zO4{=(w8~w~l>O^4S@WP98x70L(=&!qEuHhk2vQ!qM)V!NqgrmN#mh4SQ&g=yL|}?W zU>HR(RaOfR3bb7-<=rVM-VIo!%)pA&^zI56!qU~nJ0#<=?j18aacBP~&x!GK$u(yj z#?Lm!Mj=+Gu0@vlN$c&ok^!{^1L_1aJ)bX@zVDGgVO~iarq*%dh`77d9 zdx%>G7boGT(ZK@F1Zf7-ndZo9eyyqF3a@qys4!;82s$)W`w8yBg;x% zq8M`xO8;E%5!;OBJVkRZqigSEa39M2=||>IJDEQXVg3}ilZuw4E$(0;`w4IDw1$zI zHRr@c$%$DpI;ZxC_CLPM-OhpA(5uE^Y}38Zg-NZ+?Q(}!2DF%wq`O}K|M|v=VJ1vA zYe}e;7ok=<_w@+$JJ7vOXfJO3r`&j8I2j#uZ(3WHB*ZJ$oHJ+nJudl%8!%bNALZCKyM&a#PahIMLxt$xR8X^>^ z8pCm-mYb|~ygL8=`^Ig>JG}}vYqH|AWoCs|Jp06L@n`YgZVUYC35;sv5wioQW}0@I z5Mow$#WQcWQJ=;8y6N6oOm-%e*|E-`$@H^h6;Y*FzTsuMEA;LXD7=Oj4MzZL?4SL_ zpegf2OMn@t} z;+!ro&QJBnRiy-9K@0UPBV9d;jY9{hjYA_@1?kS1umSh5hl;C8**KJVEyB|kqf#rb zir$mz7|GIo@>Vq6Zg1sxX~?B!>EpS}+$ZhmuB@TA^1J-6u}ye1-aecw zmgm#Ja4xl=R1GWFAb6wztS-~RGoL2cr~SN%plh#KT54lC6=>s42wgOb+4EGg2{X!e zO!0D)+^ctY5a#1qM`q=?7C-2JPDq#7D}tnQSM~~%Cub&4OYtDs>RxnEI|BOZe4937 zRWhynU#85mec*2#H_Zm?#76gaW|q#hY7S2>KKdKg1}8A~(GH>sfzSq3h7q`)!)jew+MY%k|_0 z!CeUit7Y<$#Oui+$;k&gC4P`B467pLgm1O=+JluXhfaTaW@XuBo06Z$^xu4{Wq_B> z4ggpS$57$SJ^5Sm&xs$`?LVZzgx(v6eldUcF4ub_wtj2g!q)WL@1qaLdp!FtxVOls zhTa=de|IG)SKkNt9=cOns^1m;LLaHVyMpLXrTQJa?+56TECEW0e_eM z$MRK*8D`fx`io`7FW0|dRp3*XZO8Iej`_rHLG+=};vDlr4?&PEpu zE&ikn6}KJ`tqj^!w0=_U&{C0p zvlM9zQg4w8BJDsLjO59|f<&5z)ECJ^q%W3;)E&tksVm1?oc~pQ%XRqzT-w$8zDi8z zqH-*x$6+ElAi0XvHgM|eZ(I|%h-Qn{QM4}>NwpOiMpm4rlRx-GVu%U*0b5hV&A3M#BZdSW%*-@=deq)m``SQn}=S=D!+6MN> zx6L1|ZMF^(enS7ab0&d5<`>jL*emby9cG#wwOLqtK|)na$EsahcRb!IeA?o7r@EA= zRjW`)Wq0@Dc8+0T6@5ZGIDL4u+rkGR9cBu$L2yuW7Yl)+x}_kTIyl)ywC^Wis~do= z#tYc04fLyD1#DGnuW+eGK)*^9`c?ZrQfU>H{HY}LtCtBC9ac?xHKpYGa&2Qw9?$CP zu&VFp?Fz@vo^X5exXUX`u8;067_6{q`){q@zu2{K?4_b$pyU9)a)8fmgcxNd^r?eR zLTDHXkm{>gxhQLq;*rK7trRH%DL;&=sYt7-RZ}Djq*+L7sfEML4f;;tHf>)`{npcB;$h)2OyB>jqFz0OdR1>6 z)TXomeUhP!WtDmI$&Nb5JLtQ~#O$T*VS4bU0nmT+`d3aIbYi#{mny~<6 zj)c{vq7KoZr(tlc7P*edbL0yMqji=78W|)%xu+LYqadWig%^N3`%9XKR9$K%aODov zGKTcuXz# z@%E|F;aiJ8>I>3p!qx>n<68|cD_o;hJrwn7kD^}vrl?nA6!mJKqF(ibde!%R0o6eC zvV;0joGUH>yT&jH1d!b#`Nui@V`em~FNg0lbFRqKq8E#07(7c;%ZmG-4Mr8XoRE7< zHl}devPNU^i!!U_!tbVuPg2XC8>UxkzOT-YLLrkztS%jEIV7C@^{(11?E4-VtKo`z z)k9IQnkwqmIz_#@sHj&%74@ny)T_P~H&3ej8@QxWpswsdUHz(1S1@WmE1@Iz406jYxI)?~WXh z#~@dwXU@(kSEAz_j7#$R3E$e5ryx)1SI_Jxr(A}@xiQMcG1@fZ#B=2`d{dn)FAFEF zzStnBM8Fykn-S61*Ow6jV*A0a-f;;%)aL;8`KkJx!6&_J443v5mj+ZXH>D>0@{%0B zKtRhrHuo8AQ?<|Kl)vSj1lw*A7f@QBIU~}q-1xnL{I-H2ljQe0gSzqnM70qRRU8Du zsCCle2EaHwla_JTc0odPgCKuKZ+q$Zyp8N86o@a;-MPG8I2{4;zN6HSQO%{eu_Z7mg`ApyrAEkOcR^0|MbZXat%ENG ziE61f~$X zNJ;DENZL|HuvI4XE1RxEwkS{Ttt3vRtI>NV_ zqWD#VDK-RkH8?@&M;Fe4$D-X=$N@^y?liTTw0ps**OBwO)?(rk}vgWb$E0$pjv%&vHj@fwqJv~`cT?^&mzP!psr}_IMvvn(Abw~ zY+Gq;Cxysrth2k<5N=ljq%a2nR`cL?Ro5fs=Z9963Pt$Y#-m>)fEF9aC9dESt+_;F zN&LzI{AP3RlPMQrm}GMDMUwNh^Ad@AjOu;wiz~m$o|ErO-p~mN-Uz)Z34x7D zHCufogd`#->u%@GZE-ff*_6VHU>3RzxWGC-u8NMl8shO`dp4$?T04kPVAx{Ea4D%PdYN^wIR9w5Py4?<+I zbb?5ZNEeWvAWal$8q#k_FOVjQbQtL|(rcsuj4apa&JkoTIg)|ze zGSUo=MdJE2BnzZ3C3C}(H1Z__CG^S4ORj6CNYjwkA=O5jRaS*uIj42+=?&hH_^cB; z(?2zhy_v@DtyaSq5&h+*{0|;9>?Rh*uMj1)gD9aqaYg8J6694}6k%BBjI}Ab4!6c1 zI6u9D$?ELZoUt%?F@iY9 zF>K}a)_^$E{yL+8q}1Nz&Df^g@SSr;uo21gttC*!)~=Dp)kHw znnqtTHViMalVLXUx)ok4)99=RWRlmcr{G(L7Sly%rRK0?wIyL>nI&{K?acD-NCt#6 z#U=YC_Fd%r?UfxxKb`ih>EwN5HZQ4Dq~`5OD;I@_ML5qbneT^MXD5D8ruL0@*7~*o zpkJnitX`N{Bm=`mgGTY4W&BH2H9HU{pr9B!|nc z@qZFBM0j?4V)q#9`NCK`j@y^b9sbI5<)-{&y1o01AQ5jekcYB7SKp2^8cPc0XIpVb z<{`}f>*$qcl3CbbE+KnF?hx~HnlCyVy9SAit~xjR9&nV_RDciCTn51L8Bmq_)0hEF zXSz3?K+WmI7EPyT6aAA@S^*Izn*Av;FLFQ0T&x!Zuv=oi7?F!b|kQXdeYBT@SfVNQjwzbAjdyBH6#x@ zk~~=KeBy9{cda1;-jRHV*}O)}lJ8(Mj+s(g6WU(B$U+DS=Q^pTX`sQWIpHr!Vwddy z#ee`DvscU{*!6n^bpt&aSZNJupb5}_Cq*>yDNkHG6wfX4DNzv5nBc}v}T^HNmu3Nm<<~x z$D5nK{XaTzskuP$<*CW;vD(X&@lH-`3u`!8u`Fd|NF&Th+YtDuoJK3hrKEB@@IGzw zt~9hi6Xjc-iOXJ14;N&x*jlTxf!i=|o1ryt!{FCJpvs1n4Ym~T-?^MImvYEmIhI~d zRW_5n4L?>FEqkFR5IG%|N7Yk(#az+4;Ta~%ntUdexA+atqyl2gz)c$qa77CU@6S5) zE!Lq=tLnR07WHRY^cF_ZX_iHoD;E>FIH$NjdK1^PSxa^j@j53viFj=12iN8BMw5({ z+M&Z;gQ;DU^QU@N6k@$Ueg|*fpx%t8-gGbT`Le{IIx~%jWlQ3qQ|QDE9`C{&+=cw5 z)M?BYovodM;3_QbIgGA-m9D*u^fiCd*KQfh1M>&Xo6g;0EXk-lniuA&)|}B&txYXv z%A^3@-N+8?#&FsVP4T&7(PGhJr3Gbr1STtOduKk9%WSR7rka*Id$;m@8-p&4~DWFj*&NbAlKGL`bT*x_$6yr@#i4bKT*2XS|UER0>ppim?$EEXjRnMx(3 zhmeqNc=4_2!Q;7}19Ck;!lqy*l+9K#8+K8Wr0MJDPM*Ny6vR~7#wn^_%&g?%Bp-Gb>)cBsEzh~G`B`q8a%S7?A{wB+$sJzeCv&0$6 zQ<*m;EPaPBpG}KGho7YynS~9DiRGf1KV{C+Q43b5cu)UGbMI7^5e~+u8QP22p6OMSd;+V)|wtYNPQNDGdA{T8vR!1-~M$Y7cQ$ zV^myKZ49IfGi4upFzZ#ZZ)Mr!#HdiLski?}jDSvh?x^2&3e!nWPFBHtnjLZ#UN*)SC;C1Ouq|09%xd}>b_6G zIq&r~Jrw+1pov|0qR;npjyagO@(y(~jSXHEXwoSBrqB0totl_W_I7YHjSv1Z(47C&J1e!Drzv6Rao>L?9@4d&lnm!2b8EDcxJl5x<`NtZV-|#N) zYWgC$RiH`B@Y6mw<~!LpdFH*_rR3}2nt`9U3_tqojrqswi{$0vmb|R`lck~^6wT>< z(Ox)9wP%Y&+DkQCkwTGfAnl}9U6CA+jv{?StvVuI=_t}SNRia4Ez&roVE4%_!^7T{ zS~Uwj^Df`fBWhIeb+1vltWmA7+&NvP6)1rGHnqiMSu!-uL*_l3$t! zSyuXYQ=2*tRj2p7DAa|mL)Q2C(lQ8Il8w-kM)v9?$c9?U!KUv0^VvCv74&iF;PlSX z#S0eMEf`eIa$41{Z8~=RFnq@1cRzP|r&g`PAy)40|F-KM)=U5o{Xsv}2y}vwbwvnS zAs@Iea=CL36xK6AVMX^96xLZ#SYw4`RRCVrRd`u@gqPKYO1G)hTPiImcI?+l4l_!w zuM)7Tz@0+pMzz`(zqsW3ORLVAJhrIfu&VNtuM6B6(On9IR{uG6eLY{{Xzge%Xps&A z-13wIR281fZg5!t5ztlm@>sbja9CH6K0{g|(lMkLNRyFPQ41Vac?elwBCVkok^|BL z_g~801_TudA!|E?EWxscxVQ=-D-c4~BcuMRh5ALo?}j$SrSZr}%J z1<0{bfE;d*&d%`c55y+}%L6D;IzpC$X5BZb5v2$<3YuknLY6w?z56}49;&=@ei`RP zKpx|`Z7T$;u?{*+f)ONB&Ipgo_j^cLCE*5T12UyhR3~#r%JPPk6}?T+1g~n>A&{!29Y5iHE@m$~Vax*sc zbKWJ0z<5Q#ngao=3BatP0J9bY%vxQ=NiHS=e$RRMJ?r52IJYl+vfk52P?xw=8ECv^ z6hlB&vQFOW&!u8`I)2_`E{23Ip-BNgWhoU>w3lMig%JXv%K1aIvnWyN%<4gTXv}v^xZGRV`o|3eN=r%_}0Wnb=0T5`fRE`+wjSy zHRaOWxHNgM<*HPX!x!f8Qx2@O4f+h$TB`P;oN{EINk#-?X>+)&`Mom3IWlspOUv-B z%VkdG+)UFZ4!l;fK6SdwYbk&!$>S2<&2 z&S)&D8D}iT8QaK3Jm8tiYpH6COrCBrP4WynH?5w3wXcf>oSZh*cJIk)i)<$>D^{k@ zv-;%*@4nZlT>0JiKC#_C>Su4;d|if{_1d=aYoQ<&5GGGW0b>2yRxmt#S<(39%C|9g+o%Ok`2-Ufd5g>wUg9w@hr^w=sG#Duq$qET{khYiS9vaCIu~Iq$%``vaYjonf}fpp zNl~mS(7D=4`+iFMg0#}z*af0mME)|W30SP6V6m3)1Z?05=)n`P8E#r1XZTt3;Ab_L z_A99VrMi@s3wg_Dl{BlpeCaJ;YJk0J5AqB6*(lgomGnvQ&>m5%Ikh_RkH(S;$Qe(! zk~7-FLo3cj7)^qQHit7-=OQ|A5r#=Zw@Y5v`t*B}f%MxP>sT9!Yab(V?F~;#T)Umb zwTBbeeoC?!MyM=?^F@}7I-(VI+m)!>ukkLr6~fVgcd-fHMSr}Dw_?v0Df4MKaYAk? zPDm>$ZH-^;`!2Gy*-Vl(EY8RV<;U$;`_+CZ(jBDMNav9rQ>(d1{gJL9J*8H2N#Fm$ zS`rwZ6^wPUTq*vDn`WKu%S_BaI6ShGxEh`mkxDJ3($7?SC6(4u=?Rqrq|zNKy{1x2 zsbqqyAzvXm(kiKBDqFsknIe^Hca}<~MWs?JsZ@G&b(7-wZ4!S@=7lhahB z<4EI>sv`Z1TCGJ2MXHHZlv+r;k={otPOUZ~T|xQ)sU)?KULdtX`Zu-Oid6obByDsc zX`^&qsnu4JHXM*TBfTq9$CNydlpw0}I-?#lcotLQvwZc(*Ipvvax(#!y`7@|!DMa6 zQ96```Mlf2;|~s>E^i}qOqT9k-+wS!`nKlK4#Sc__P?N2dEj`+B4It7n5;YE85SS0 zWUG8aux#eJXm4VvQ!4+1$$DE%mL|3*u}3xtSqh_dKJoF=bX&qU!-GE-5B@{KHEvqU z@OlyqP6!wrd+Squg<&<8F!qNe_}~Qk98n!CnLRK@Dr6m z5+O0~!s;STV=NgPi_2xJ7^i4p94V*C-I^^8B{pg=u~EmJiH$P2n5c5;*)(I=cactQ^!@=yzRWqx7eCdk&BWjyg>UmMbZR-InrwGYJfRNMP7a0>fxp z{&!mbqE^eRoW(mJklrLLY4)9F#!((P~OyHiss7U&A2Wx9XuN7 zl~l}Cd19_WaOjN7(loY=wX#uoX&Gyq@ef)-cnb*rSwJuDOuMRW-CI$=D1jrzNkl77 zSXOatqT=*yV*SO$80;t}#wHyhPhy978I-7=>Bi;^38y%N7!jFofBsgr>T-CaWsx&_ zrJhmm)_-AfTLwFR!dQBVv2?T6SgPYKniT1=9e~CzKy&)Bg>%%g>qkq^-Aa(qR+0|Y zW|dn(Ht5JVCsEIW=6u`y4r5p#LupbS22MJogj&XuM$zyo5mAGl2$4!bGP=;?)^f+& zlN>mo6^F|7u4Y;*4r*hQae*nSrG6W}d7WV56!jcomqG zI0#5lwU``taKIA302vCRCkYg=>z?Y_Pgx89IF-GO8EBi)zEgtS+*lZI~ct2DHKO+u*EM0xc= zY3Mfe@WLvmunqIJ8O+;CYR%i2N15_&V#+*_#DemS*x8Vb#og6G`VHk$t+;x_QY~_` z7KWWTH!jT5XHtT#;^i68mwDmEbMBGTS~?7k6ebl!lq0-Bk1(1Zp?e+C z%Iki!qAb24k4-gg>Enl`+k$c!#uuHfE$qSWb!O4EuhO-5F;(`jL)Z2oTg7NxUhdf# z?wN*?d&O9iQFk;~*k8>VJF2y*T1=TDutg)VMO8Xj1TW7B)}bO;V~SwaIf52c|1rp5 z4}#F!J2HT0;B$21W^3CGMzd6mW|r_9wGE+RNENV+7_@ftjOC4F1ugw2EhNfH2GkY| zs1u4xUwgh-`r1R#ptlqnbO!MDN81q-5My+%C~926DmT%Z#H9>`4(6uKnV$TW!Y-I6 zKZSXk4)Mw0ViNX%_B1#v`qfK}6^+9nu@?>(B*AR?V;kAE&sI^}VUPp6=m{ss0VKA; z@%-2ZHl4Fm%!Xa`QanZax2+1oGPc1o_LOa_g!|>o8}$Tl)F9rdHoQ?icgh10l_(Fu zfVi{|fQ;%%?%J4l4Sgy7hAJ5>6CQ}a$ud#4P)?G;by+4X!e#SV4YO%c= zUW3y=t6Z2B%0kFantKS%9aok%t&3&U3(IIHgZog$#Nu7PGb~QL!aEt=S;4NDb~&46 zq`{0*UJP8u-6(`J<^+4;k=Q%uNQLiif!FTseGfR3CexWCef109WSu$;NW~FN> zD_yo_VRwCH9l7_ytw*v4|0Y-efb4_eq*DdcHfG<1G| zym{^-Nf+hSA*y9$nRUE4SMcI&raTC|I3KFLTs>)pC|;ZccyXTL#koQ;vQF!?f-|mf zrBu$`g}|%UD9#dIkJ?s=Es`;;l1z-Ay!M<3zG|>zCwi5&ylD6G0!`VGrrJeMU-K2u z>RXR&cE6Ez(PsBQaa;UZytmr|zj`sVA~zl}3s`1WV#PB%Yp-VaqnF>lcj(0O+d3Ua zPEnU+{;e~}Lp&UBVyIF#9#poCV4g-|mDI*6F}!HFNu&+^)%GF$#R2ZFwm$66)`x}{ zTjGsSE*rR0`+!#&>?%?|pQOlC4sdt1N5~QkM1zZ2aDZi1DLJ#XaQVrH0YBLsWED! zqtYqnZh05BrT6eU%neB`k@%=s=~MoLm@}VeX@4C{%Fa4jp~6;|`Zk7o5ZG+6vb5nY zKhAK9cn>e4=ytH0oyP`==J5Kg2S*Y*r8WHp*ZymYs{YarT7nIt!bjc{(~-?26ocvKPbgL)i^R7c+HkHl9bMH;MB&UUm3?;vZ_qd zt>kAdlV2vkI1unK;Ps2^XOdn&zZCH7+vNNGl7Bpqv@{?oX=Pu*U0pixdS!t3lRuMB zCMRFF9DUhq6D?-6K++mMYxI7^F%*wLK zKUe&yZvP?GC-mMpR47)v3O)Po@{h%5Aw(62_+nb6zC_F(kkn~k1*_ufw>tCZW& z^u__Z{-cY4xf1=3tzfQxDk1uKsXp5LM*rHKO!o#K3Vi4N{-2ru+dJOP^l0$5Kofhb z-+l7U9pqr%*?X#+>E+blS5d4n38ulGLa zYMK~4IB-f+t2m#0^Aj4HANB6JQ;+kwB@e)(Vtr5YVgqNaK*c5-Gt-q%}?-23)p! z(nGYRR0Dd|8t7F=sx72ib&=vBT-hPbrWVkvsYvBTy16wZKCI<`8Wn(#a6|YA1%;2$ zsHfkkR&%}yJK|k=Nv&cIRsDJfjcS$n&Boi4-|O!Q_GsJcG1Y>4?gV|6czg1(q0I%g z5cbNue21APM{O3CUXW1L(y?mS)*X+x3ZJ(4-Kj1mYSk(fQrX?TxSeBISVf=E4o)8) z?Y8g%Xe7Wbi(IVcE*3Na(5rZXUPZL;CjhD&V6Mgs=Bf>tt6#xf?G?<`2ryTPg1Ktn zM=GtNl0TJfYXrVbsOYe2(yJ*Y*OzN6IICG*9ai=Iyj|hg*%NM09(Q?V$@S6Q6DE%f zo3{Vf>ivsd3&&n6D$ExPIe?&BVn4U35tv{lpsIu5tVRmE%IYg&R}F%26^}FyX{AUB zNcq88O+{KwEeKZ@NVAaEQVXed$GQDh**gpFsiP3CVt`&9f^gLk!j&5m(5r$=L~;aF z>eCXAGqrDH89zUUlhs{=F5w6B@2Q*AAa~euPuS~B0 zR5j=WxE#enbz}p2^?uCwwkJ!MlVMgb`Ha8JmM_;HwJRTW zNXT}U^Mq{YT+v^cC?AxCa}?J2l5nTakDun^ZGQi7>;5yV@AFhJtGWUW>F{S+p%R5H zEk>0esgm$mv9Bg6_SFxtuYil_z*%J}Wk$G4$HChF*v)2y1(+!ASuR1Zig2$1P+4;4 z3(__)#7c9D%urSnEH}u|;ZxqZs$5J?4!~KmBwVHAU=<$MW2a|4ZEG#f`JN2f7W?a6 zwOQErJz!SDivzRjq1abV75i$PVqaZU?5m-Qebrd8uPSbyRQESfEZX;8|Q=s1UJL126{c?447R2(6fSy=Z6N*OPYljL%!b)d}sx&!nS6e5ye!GrlaMqie&d z@}Sak9x(;IDq@!ud}O4|sci1coT_KMno~u=NE!f2^2|KxYb%&jRRmf^cmFWFN=(nw zyl4k7sMGpOWE^kDmvi#vEBR8H=R&@uz_A_z5^XHUkhxFK_$BA0PuKZc&R`6}l{P@j zsDvwRrj}6%S2SxXQ){w|OrBQoYW4GMS8o5wY0GV2)h}0c_dUCE9e3XwYTIqp&(Xct zCmj5-_rTi+x9mE5e%kz9`P%Mt9dc~j3gIM`gl7~c;2Sdm-xTLdxO^!F1xL6$KKy0! zg_q7lM*_zxEV7H#d4OC_zSP*ZKi2A)P1ku zO8pqsT#6f83aRR16^K%bJLN7srM^h|FjtyN-wLAVu?Bh-e!{0vi0?rcj|HCLCn=s+ z#ZwgHRq-^%2da36Vt!YttFAyF^eQXNm4=07({;$UMJMf!S=EtWtBU6+b{&cur&Lw^ zS*gQN6QsDYA3q=5*F?FI8`Y(Bk^9hs`=C%@=~-AmY`lITR+~CDT);@r&kEzH_FAY` zZsmk(H5ICrB~+{LH}<)4iR%#_=rS^cYAZPLA2UUNXJR6&( zsqM~-JXgNll`o652v_N#S4JgVX*0EqO1MhL)OtI@l{PKwhmG^^d@z*GRY5wJZp56X zu}cakZC=c8G-Mq`xjGN!Y7LYtS9t>VOowt+7aW!YIIPFgex=pF%$3r}HFA}1{Tyt!6jmK)Io%SljbQik==+N_7FJ%v?_b=Nl5 z-L8fx7sP1(45mesk0@w{LnMv@y_yB#sx~;QlSn|XibA;Rh!l$i^lBE;V5F-^PlaGr z2!d6-5UiF=ko=8M2v(1TU=<1GDh|xmOQ|%CN)Mf}pBh2tNUYtNu`_$|DsP=?>CVBnzY>)Piue z2B|huF=`Gu0pPKJ0Ns9n`HaKAf3S*n&hN3`)ydBdM%r=5OI0Si>2=!1de<{;K(HcM>fl4 zI%-@8+jA$N>aEkmbLzs-k?n0XNfW7*8XFbpClQr@G{g%*Ky$hcH!^PNx=7X6nedr0 z22TZZJt0b{vWgO-Uymj6@S(~o*X$&ol5YMcmPto=)7we8k|Ul2KgK8?Rbc`B9nh>WjB&FHw(U8`27c>2eq7avM^-P2&IGY~XIPDnM&9VFMY`OdnV7Sp9)#mxy=W`TSqe zjUDLk4F^5hK@9!idUZmwW((;~KEuRvgr87#1u=lL9II@uht|MjR z?IZ@-9SpL@hhF7ELis{ABphw<`&0(#-Mmkq@IFmc=_=)J%DybXzH1%PSQBudD>0Uz7>7{v#m4q_kP26L4fB_$R^9^tG`(USTO zFV;s|1eK0Zsl1c)nj4Z2C^;RBrM($TcReBYiji5Y+>D7ylC84A>zu-#WliX?SI0g~ zz~vE$l}DJi9UwdH_hixBlV7A)w))7U+Ih|4D0KqqX<;qT;8cTJKo1M`xO6#>Q@E zEyw>9EajV6>NiG_3UF7+B1C%Ub?OGubr~!m0WD#ZtUro*VsJ6jiLqv`e2u&YlE$-S z!wzzEoJTVIucR#)T#VadAm&QL!jd$?fQZowrBAB8RwTP4FVWcytYwL0w;__lM&fl2+EJta`OgxxvLm zgE_z|J4KVQA`^B+sbxMRi6VbNud=bJxGaU{C;|P^0rNe972`II*>|vO{ntf$9ybeF z`0?cu9?O39>oc@$^G@G4nowcI{)tWRUiRwQyh!H>clMqw@KqU~Zd{|vJlDR)+=~aF z(%_~0rkWdhP5)P3(^-&%)sol+jOdLR(ViI5DdgZvJQ(Tm!LpTuWKKxd;++hsZ44BK z8Bm)1`B)}BxsV2*6PwET29)NEIbBU%*x;o=Q!4WIWhv@ST9LvvXW-}vl|d?}NobQ? z7Lb!sC$OG+@IKhg`=Af+gFTbwqp3n<^}(9jgEcjV#j!E+97XYB;JJM}6EMeUu($t5 z!_2L`sbyFieFqp><(X3pV8d%b1`}2TSE-|N%=(J;roU%5p|Sms^YU-Yu|s(Wr0k|r zl)pssmslQy+~k3!9*eXdKf>lf)^mzZ{K zX4=)8Y1b~Y1mnmO)EZ2~;w07S_ct7V1xCxj(ODtg@*!EPDV6E7-?AJ!jFJ3mQ4YR@ zRwg6u3KOM9G)3Mqv;HPP7D%q!;QEZ3<&k>E(h9InCmT?k*JW)=DnFDyW`BVXoDcRp z_;6H&Nl7AHtOXKw<5iuOd8mO~O16_!*3AX~zh%|%2pcyQT_qeo)v{o%$xG|R($q?p zD_XF@#)R6^*Pa*TV}YMIf>*Hg+=Atj2^M+>^FYPa(mhS%UHcaxE5hRuPKG7sg9W4; zvN~JET=h2`uZUT7QsJr$EoN#~W#w-ezQZjxQB$d(d=s-`TPp}%#j;g=<37p?BP>1b z^}36@^rwvaVpW~MstOWP`yfYOPuvdMa69uv57b-mt>({KEZ zTKzpeJot?jqixveFdB>{{aqZLtbH*WQ=%JdW*6u<=_IwzHBRU7nsNOCOna9kCPh~C zbyxcOGWvQW`uY(1dK`T{E>_0#C^A+Dq#(F-_I0%!Vk)nw^@b(BYiebesFmZ4`HcTq z6GJ*Lvr;pQMaeGCt5sCX0P*NN=H;1oIa;%Uk@m!Cm6>>+bUPDQvM|{KXW~RW4lh}S zeo{sV@IoV&R!+C4ib_!BIctuy@c)8oVweGw&04P9LNoj=Ivh=HLz5(dUl}KgG1`@+ z;7Ytsv3<3W{N`e#$~x5sj|Q7~60%Fx0Mcjt2cxAE(URVj{LsT=cJK9 zvbWv%M8eIy&gGpeNAKb3+MBrVdL2G_QY$s;YauaJLm5u5GMw%z#0L{)|4(R*i?l{v z7Bovr%i?U3g$(yi11lK3>LHc)q+)#J;H-lCpTXRnCys~hdFNcwarjh!3-{fq%q(LE zf~nP`1c*2Tm?xcKp0tA1=Vt6rHP%B~;bCz;HqsPvykylH)j4x%+5t0UL2EqF9DEA8 zXGto^OE)W8v!#i$5p)o&j3H^lvW8)68FAPQj`r}J zZawMb%!-}%o|>7z)2mQ3%N5Up&BEeN2)wG;XYs@R*BmkHceCy1)~|!j>aO@K#7t{d zkuV$ zu9mI3>s;kzVPm~vfGld|%1&pgAs`0(Vb;^#|JTvE&L;|E#qSMcMR$LD)6ywB4&G#y zv9Wa130OPJm@7A8t~`{v@{i1wcM@njqyQf&P%SLromjv_v@BqjM&Hh|$)jM9%uEu^ z=^Pl)vumKRWR(m5n2{vBUWa52)BUl|p*5qgXb}rlFZ5?Dq}fiTD#tFtjIAOwwk8!22zXf~`SF3I9|N9Wx}Kcy_)@=sq~DXDH}*?@edbki^2Gkp&szp~xqSCb&{&Uy z1dU~X6&%(OzV8B+wKW!0Ry&2tYVnKIeKjNM^BrGqeSB}k)}1CTY;QIa^wl*hL1JAM zQr2upStEs%HDuW5^Jky?Ln`eq@VZWQkEI~7tOcxfSHM~qenKxS+^nT0w&4$azMt*X z%-p2<^ra^Ct?v3vo>Qx-`TO46+)U2~hX@xKz}572@R-0U4pvuvzMmJ-$oxC+MXsjzg8K$eX=ZiNr`7yg4b3lm+qs%P z3vL%UrG?d5pYP{K*qcA|J`Wqq77o^NVOP}xmo*ZpY+y|C%`cOFyD>lFebGvzy#{f$ zpK9Q;wgJMriS(UF5p_j!M>>tPjauNc9>B)hiL{YgwMANlv;rwya8^Q=dgg5h8*4g* zt5qUJSc`NX4%RTF(03or7}`HTw2^2YXp5;Mh`j_+IW;eTpY+F^J|8!rc!iP$pm{s!2YC%&Z z|39eVj$)v)1iIksT-asUY&b{{<`1fBX<9X^ZO2yOpD%uQic67NwF-okb$9=lUBj@j zcYVfnaH@aw-Gz%rE*NBCS*Ti9$K!9{J%S@?;J(Nu98%UyA!UVCo(Q!HHdZ2RtbM}9 zS_m8Kp0Kf^VPky*8*4O`gpD=sB$ak8aJl=n|Lw^y?iUs|*1v^;RmV+`SS89=>Rj)^ z>H>E@4scjixyQN!cNUg?v0}yx_ePaE_p1{oBndgdVh*rP2sz7ykn=^L5OPKeAt%sH z2su}rgo4woNR7YZl z-v-r^zt!h&;qtd%Ilu}zfLS*=z%2M$VZzr6kBF6fP+Ry~kw_bnHi%TDj!4Imwj*t# z7SbK0y+~WAWg}8iXORveZH=ukao-i25ns!%d{$_9RNEJ`1bo$S;xPeVh3>y8oGjOV zkA#yIzD04eK82HY`-E_^8ax^*sE6_|c1v|vN8xrXYsE*XG<~BI5VE`=WX+OR-wKu` zh3B!lRMeq`0_$)Sc?1NWVuI-CtuSQ55^5tblJoN0w>AJOQ3AZs=cTHK2q5h*sVeUR^o3n{v7si=R{~N4qQSu zcwx(KH@EPcY0u4usnXFvJk}HNSc%}VE|-IL_ceH|^D*GD5)>Y*xx!wFA&tOSL}dh`f9*0^!tv6}NMI?;YSd5`#EhDipJz!V+}B2_9<46c>$+ex%d zJ8n3DBwrfHJWJ_Nk8Ppqxt+t0%xf%|+}0C{6gK+N<{?psR!9#kNe^S_dba;RQEkV4 zEch$4ef0%@HM6g|(6ZY82`y{QQfOJ{dO^#&y+deOE|0DWEz4@$i0@wPSiDRQ(*iEm zX&5@oAs_CNfqtgH4D_W3yjWNxrsqxi{4M(YY5M%~UJf5k+GQ=AHPuJ-^1bfAA!Mb4 zd~s{FB~PCCtT|dau66GXAxpvn?5a%<`SN%<3Q2h?ZFuBxm)TXv%?9eEoaS(|Q^TT&{v>e|NvZ`b&C^7l{W0r?DcR$EPF1w*9unWgoR`CREO%jMvGxw%FqWodJ(M)FV@O=8wz zTvAp6JDEj|tt`DZ*w?(zGrMvlci)TdUGw(A6TNFD9Q<}y=X2Al_*XkSO-eD-`uVS3 zU95_~$(Q4nU0&q7P#`&D1d_8209FCP@>GPH)K)-A1B9Bi>#X3BmPnQS9)H%`aqKH8 zRhG(jz?1^zOJDi2=;#ZmRW1{cjkG)Q>rxx*D3<_=1%oM0p;$u|Kd0DM6{k`3q4*jA zQ~+=&1*hPSr~gQR6m9_2FQxpmS*hv|P3x>nOi=*+#h?Q54&%;tq;Fs`xF%FH~_C z#W0GKE*Qqf(g3syMomg~*G84?rPLmlNA_^}lqFwu6F zkTxIE3qn>qIY<$|iQS?HX*IQ*98N*;XrH>Ymb0{740xyQ`lK4trZcIqkT#`yTN)mM zlo`-43l5bBl`3)E_FSSivC9}zp!~{5{AO)pSJu+!o&m}0TD!HBHR41bLL z!EA7_WH4lc$4bz`W0fTBzoNopy^FU&VRSmFRK^+INeyI$BXNvf9e(s3w?x zjbH8i#br^qnYa}!&WMZRxV_+=9*T4asWsAhq{q~1E>eG_D@aeN)m)qpQ_qM8DBfO< z^?Z)hY9Z1Zq&rA2MY@A@5a|I@617^26p!=*DVbVG`Ok`!zkx_5_%>RJWPwx^senj# zkXj>^mR&+>7jl(aA4-5!|FhySD34TFq&rAckt~pkP^+~_YmjOq6{8l?K_ok*64YuV zQaq9aQYmU7NG?3CnWE_pub;hbv#Slfw_?2N~b_pw6fxWXVl!V^|pX&n4PqI8MH6v_|u^VOjoff-Z%pB2EVV$!MBQ zzEdh!k%Nz=!5DryDXUKk#0n2zUp#z!@$ii$ zOyeP88V?E6xTV50HV~%KBPC1&NS0Q165b@;aRU;DDT(2_vsH{54W%7_^|z#<6Ko|Z z3(eX{%EEE`Y!wrGur+!2zjg;Vc$;tX!fTxBD+$|L!8s@GrIka7cD1iZ07qXs@?M73 zu?(wC20gJ8mRAKTeM_bJGH6E;MXR+@sWr}JNsbWb@?%MpU>wMhl9oP9OW<4Oh>99Z zRFvVxT;1CJxHGqYFZt+(7jwF`dxS?fM)=e$bd|r6)BN&odjC;TuXgB9SE)t{Lp5S` zBqdzD z8SfQN=LnOhb}9huJ)IG^JiIx`{K$nEryTE_s3Q`}Sdu9*VMGfWxUqXm6qU|VRnxaL z=?gVf$d%4?m0Q7BK=tX?-h|*q6M{ES(YNX|kJ<_n&6|YaXp;En5fets&ZQHIiQ#ol zObidPI&vs6EV*(lF&=a#Z!qBzdm;~Ni6Qbo6VIifSLeC=>zFz@Gj+<`E>hI1y5#W- zB--niK%yN=Nf%d;=yc)Lk}a;nzdj)m?GlM-o9WrT>&S?`%ajk=aTCpvrJ0eVTD0R( z4sU$>q$#bf!#**BGztqch0{xf)@`-&(1m_iU70F$vG#Pa`E;?$T49$e-_V;UAoH1W znh4vqUgt&-Rb4^4X$#)XU>odzi9J(9(T#*a2 z?&=J(Re@)OkN=&fi3O%fZ9C@21{V`GIINt`ku@8FOR~bkwUW0`rU`iq1{c*9;S=HL zsy)WLh?Ud=@|3zTUUZ6Z%huy>Dh+z_RM=EHU!?;U(#RIPN*#HX&gNBGR#vOzvK+CF z99eXl&Ah2B0k<|oM(}xt?>`iJt_5;WOYyb?OYJcNAfOaz!awg{dM zwcL-pLmVYb@R@X1J`;nBPdJjcb08BBLMFQnMkzoQo1ciQqBa|=MCQ*{@g;tmRF{zk z?3)$pN_mT*|E9*oxzveN8;e8|(`9%uOD9p%(yW4Qu8FJfA*7TtD)?#%I~hgdCF;%= zWgFPG%7b7VkA~tZ+Nd^I*&$0(QM2U#1a#-IY5g4_92w}9JnY?hjCFWPbV&Nl2T167 z#lyP5C1!1Y+{qbSHQ@)NY0gTo;IL(W`N?E0g9)jN;V;UAiKd|bjE){2yA*@PzZKOwoGjwrDF8WG;SXD~pmK^*T zX$^}Q#MjZ4of*W-aTko?O<`%mOUG6rMv(G&BM`lZw?5TE_FpGT^(vc9?P9Yje|BuX zRhbX9ZSy`}vEye;YdlTaY)Uo~9Iq1;nX$c{qNvPBZ!G~Bdl?AkN_3q{H!*?*k`gh- zlvUfnp~8p_kO6Vpw%TP8;*Kfj)QDLH9b^21BXlkPr!*)RF$>#w5& zl7=Tg>G%5a(|~bF0=!Co5%79$+<|2K~_D1fU`O#xg@PCowS1u>oo0?bkKJI3EGI(R4NrUhNpH_2=IGBIrJ=o3kYVhJflMljw@u@m* z<_G2ryo)p}S^hvNw zph=7Hb3Uu)7inOA&-;#x>FeMIg1QPnAtHqaZWA`cm%gwW zd|m%&ZL@WVpi=tBoi_>m(L&e^VXwT)cbI8%)MjDn1qoFx9jkV2-SK#<@M(+Ro$69T z&|M*w-QA1ZIfjK*^a<_Y^x@HN3m?3Jax8MOn!8vy41&7yiSOWK7ty|-Fs*LDv>Go= zt2ThIeg#RjSHM>z0AD2v_^LhNt5sC;r;>oLUM5s@ST*U@l#=VqwT&@(JgcjKuRd>A zICi%Drg4{7mRuj*T?klV)Arw5y??O)u`U%=G^Vi1zL2wQY6K=&2}0**m{!XRE;<$l z_-agPK~i-RB-I_jS1pQ2CBRoEaI02Hr5bRnrcj%5eXX< zp8)4Se=!R@Nj8**ET}VSQb<=IC>eat|4+19(Vh{ zDG;7i42!TgdI*R^aAxUISBidhqd*5}V}H@FjE}lfXN>=4YyX+=tejuQS<#EY9x0Yl zTc{{pxinv39|C)cfmQ zwOQErJs4NR72~RhVq7&ARKW!@^~O4MmHLtQEQ)r;n>gn{+q zL;2hpBpq}ZprbKz=e1ft9=6c{y8PLCvqLR6%il*pA8aa5M>9Z4V6Lp?%U=0nk<@zA zAe#!W+Y0Gw-hnQ4g1(EH9~*jPTg(>qc}9KysXj|x5IyfuSCF(u(%mca*cX01X?M?f zW1+6pDQ7ao)5&V^>=_SywVdB;O*b!MmlS+tWRP^a`y1(W=6raBXS;IyPflBI`>KAqqPy?e zmFu|s-cZ|aqkfL={jX6!54DXQ_4B3P18*OU?wxPVHLIOIo?(Kysw7;aM0iQ9glp6u z?h!nz5Mk@s0>fD+RVH6}={$5KOsv9E*#+bd|5;AH)Y!IPa8)*4`)yl(((bwCiDNb~ zs%T;*#jYQr7NHoUiti}(V^nh~rckb`fRCDgrAEkO$XR_sOKF%^_4wO5&{9CLmTFbf zpspqYp$b3YQz*pupo_->&+wBJ&#U4oit(y=n&SUs@4VxpI=aShi$2yQqA?JA1RH7u zEMV_aRa6vgc||}l>Ju@E*iaKSXl$Se*c)Pxq9zziVvLGiK@G;JF|nYeVhalV&Uc6l z3(K+~tnd4Ko`3FV_U!E3yZ79gJ7>;0-}y@w&r&SmEOqswuGZyXTIm5_S@wNzSMVvT zSc}H;Z&mR;#lEAFCMc;Y{-mU1kS0oT>oEQzXPUxaRQI8e+=uquhaQ61N`c6w?$JM$ zzS(;HP`rhS-2Aqvt(&NAtf=j8s7H;~3H7MIOEn>1&47Gm4&>_Vt-~(9zZnYB7AQz= zP>{BIK)&iGze_;fD@EOvP&ayg_tK7gtuH!ByVd0T7*I>|I{ARZ$hu=za_#?^TKP}Ft_i;7_ zTqwI_d`fw7J!$-kSzHk0@K=Y=VhgXq|6d%U5%}<0_vkKmmz8Ybovc5v zyD3ShgMpjHEM!B%-OxGwH?a&}nS-nHOt2PS=%_0dXC?Q&DD%ekHJ=$9C90@8nnh}( zi3lV4l{02$mxr(+;jeh^f5UTs6&6kmEF6E`EFAl2NgRHpGu`vfbn!Nri0eVK-9|=b zvW#n@@U|#Cpo%n}ta8e={RBlvzcO}g6n-@6Y%dFSr5qpC)P8}D$?hFMcJB_ddxusP zE$lDB0sc)u3sm8UpRp?Gy6Puej)?=Qq-c@;o^$u4G4yw;Wbm{;5ta91K+l@RpZx#v zUV!MfjCi!}vR!f340dY)Nf8|MR|N?UGQ60Hx>AuoS#!5xTIoyhwvWCnQB>9N^`R=> zjmZ^6%eQecp2Ec#j*HP67o!g@Mjw}m1A>A|CZ+o}Dcz^umLDgHqtHjEi%~Xdm)z~` zXdEV%7Q!$p+m3{hRd2mQh}KZ{Yd5@DsGGF^MK*bZW+avyTrBV=?Kx0a4Ep(qWYQ7b zl$)rV?84~Q?^n@7GT1@g+5E>*FhD_{+NTfpZ(I&iN(K6R1qSz7L~zVP@w1pd&BD3d zM*3|+2G(rQp0)1~PD0aX(D(CT0)jH~jHxPwybWGT1qrWe!4Gqbe=2a`lwm)7q3EWJ zu&DJ3;h{KMSkB8(+!!r#u#@(@7pX1Coo+(c8sMuSX9Ok85ecM`=Y$f(-g-&Ywz<;{D^nw?}WNuW1VTg+May?iYDqZ zSw&s`h_=7lU?NEuTI)=D%%bs~_pF_SUG!Yr8t5}qD3ujb)Z3KnF-@Y5W17stG%>uG zEpI^w{mS4}21yV31sZO*`D_<%a8Ygcor7tm$1aixS4m~?(fKNM2e}=sX2=S;EvYNs zD_)V+D!HuJnLPJl*j>vr(v1MjxmoAPXNt?rcz#AFe(I>b;-%SeGzaPm`jsO33TsT| zZLB44!|Ij~gsSMZF}Cmk7&ga`aUFXr~ zGR5t@$A@UW$7Oc;f_Wc27Z15-dE%)Gy;e!)#>PiosWUQfoX6kRYjFg7%c}8Fodasl z)Fk_8>9jxVcObZ+?B!~Altr{1$?~QP%N@&E-dxV|rY*~x{_tuFJ;}qHcdd@}4P%H{ zc=RAeMGz_|}%B>#eud<-M`Rqle`lna&(uDp1y8vJDz7p^dE{*b$1 zERh{oUx_mo9oH(i<^{|U<+hkk7G916hEaGU4)if6{6$VAg*ma7?1Z`%l6`~LIuj0| zH?LWk1>RT)1{V{Q zUBC?c0BPb&q0Q!%>aEG-)}XFba<@Q$t$Hvq_lE~;a4|O?@T4u0!mmzckbT64Ct{Xa zVxgT-ndJr-pXy}(=CqH5xh^}S{Ki6Z?hb@-rb<>g49$HXjq>Q@9?C3gE3;!$4(>b} zyLbS+cmPgjeE=lM^s!h)OsR78_v}`Y%(T=*nwi5AW)9{|z6`S?ilo*nba*B+RTyha za5dTOmGosh+r%!ZH|lbuwpAbWn)a#5)cLdD9yxI57Z>*=>|J}TRI&Hpa;i0EcBNk~ z-1Bls9QNVRTkAf%<-Ogb598Pz{$v4`+9g87O-B-RZeF5%+?z$-va!)-{WI(=PJHoE zT;#QWAMfHNR;#w+U3AC07|p6l^n4E6c}j-xlti%7)$a>=-g0iH!yD9(J8s4zJ_Fun zgG7EP$BZAA=7-Elj3zQ1sHKCk^`;~b{z2?e=B=IWs<(_Zkp1W|*^||k#%1eGXe%&0~ zRcV}xt)z*`(sA!dke4`>&al`$ms68$hk~Vmp5206O+qvk|4`x|@YtrF%*ZK9Y z-R?TQep-Zy`N}6@ChHSU?q0jFTiZW>SRVDqk)^hMeh!jKAJ-pxyX)L65jk1B4MbpR zMdWCr2L3@~Y16Vg$aWxNMb*KaDW^bL#|ek(jNhfoILw=cFtlb?CsIoJVV+mb(|FQY zSO##i8dTvb)^y}5R9IL8teej4g;=E=SJ9g=v6)yqnyQ(EEIdv5G@^E3{;91aw}?e3 zXHo8!-fKCFiV9n-E(rHaIdkIF)b=BtwW{iOG|70ImfPl!Io_uK#9%Rbs(_cV0?Sny zfmol)+gp)!y6_%X5$#>jz1noJv(AVSgEk%1kg*E7{{Et-N{dtcTf`yXLw(|7F zT;#fR)lv*AwY6`K*f&j2d%i!J47K7y&{{Q#X4S+;t(rtKS8`_6WEsq)WhnYBwc%hS z3!~0hP|Mzs$@hoYMa<8+rWcD{D})dS9DtFeb5+ux7|S~gv2dr`OxogRqp}uMddjCvrlR<|H(wXT>L|_o zOYaZ0Ed}~(Hshh_M8=0>WuB40oz3B5AALyT!d@2}=#29DjFJhIZ7XyzM(3R_F0qo7KN$xUrbg-ydH(*LCHs3Ix$(VqT2-=6fjGRmBqXBznH8(tQ`1ZuZN!92a}cZ@cyv$vxk~LeH?f@J^go+HfPcW zh;{fo0b*_a;@O>E%YI5r-uRvO&+_@yo)iIOZMY-l$jU{b5H!UVmr!1k=|%Z@QE|9=0o_xV6Ro5yj^D+L`wD zoZ(XX`>=?R;;k%hjVLxhv9;-^o^@SH{}MJMWV)@z^%2wN`?fNT@;vNZIw{OAWO^Hm zgb~FSB(^X;?m67K^n)C#;zmqc;A>-g*RzCk>1SbfA=5ipoEBVFB8059(6H(X z4a?$~hoLoEndbrBs#w1Zj@ zvJOMY+KgxuwHk_OIE1WVfm&It6R4Fhgsc*XCL&rPqC^W3t+nqI_`SuW0U}#UH3(Uq zA!IpFZ4uQVWZeXZWrb)iwIF28Kx8JO+dIQ=uJ7>gmL*|n+;A>)s#Gnz+ARlqkMH=| z=j)Gp)?CuCyj^YYfr4~M`nnq`9^`X*TDh-xO z3(Lp;GSzN&rKnngt4rQ{<^1@L2W~E|6m@y^`Qi`j*0Nh&^U=nV_ulU>1>ZHl2ShdV z5{}lM&I;nRsfXZM9@Z`&J7S-`aBx}&)eC7@Usy1S^@5!uR|pE}NQm%~CW5=_RX27- z3Y9uisex1~3sh;1RO-4|D$Su%AE{*LAeDLsJ$c0rHp+Uw3zhFo`pS2HeCHw!BsP== zI?+H>Ke-2us>Y6paOh?g9_1<&kIf>AMYIpm=ZLmatFef#Ao>!~c4{F?LG(4Ef8 zA~VN5=Pz$LUHK#Vm!A&%qow2e9TNnNb$;o7L1Wz=C1|XE54s7|p;5|aL1VR;a#_$= z5eJhXXPpqe9T!}hI zcTOwg_0IP=?OR+)rs%<>Y4XK`k2zM9_v}>df>sY!`R>B?)s3}vXFfY>~Ppqnq+xN$@!42*nJ~_BS z;^8l1Ub}mELCkB3hkqCxb@%Wv|22{2Yxx)dbmFq_gT0yvC@1Oej4LC02^Ogglq@(s zpn1-KOKiBAtVk5? z>?nEmNO=Dsdik1 z(M0^miJWmI7g3*!FiZs8uHW%QNp*3PRF@VfB@k~&(+Qm``hREQ7yj1D-f>s|{N&1Q zq3N_%G@Zmx9PCnOii>cptY804Y)&15;kytFKbv6qN_ZEm6E;$vu#xJG?AF{oqx=wS z2-j5ZMGfpB-pPEWcp2vTNa)lrroFBE2Z-ar3(*QhcM(k#(FR1@5G5g+B%)i04)}S33(;sq)e+66Eksig)kgFwZLu}Typa;BST8~@BFJ0XBKczlq6Ua? zPi)A@2eCLkRUAXQLm%sl{%o^mK8R0QBDD4+dcF-$05LvVU^GV(R+o~n+H`%w*o$*Q zNp)#TOmps?U>pssC7I(4KZ=Y4+dQ)AbavHt+ZF+YPdiMf)cTIYCTjCOP z%hM>#%n-O$i#b_k;-IA)6vU@cfEX(myq^R*+?CF5T)Pimn#2o{6oTMiKu^DM9YZ-(us1BZobar{1P2;LXw2ela<>> ze>(R5D@;+=B#a{1M=4qeN^Re~nYIOJdH*Eg4N5=-!nH+^2gt!lkb>(PDGeSE#8!8zc8h>k}kE`hRp{ z81@q>iy|}ONy5>QtUSi%xzO{qu$K&% z{5O5s9*y{K<+uwBteY8TjV3ZY)55TPjC|B8gshD^r>9E3hqs{t98|6;>PrBh6nz>E z4`MvuODMbAyihhPloHIWA3&q+RdB7*I)gBID-|e-*qQ@4`8+3Fv!`8*3hMIkmu?>O2KsHn%-jqmn^BsBxlnYu9R;&S9+49IqGn8n zH6kyZ^Di@VV|_x8J!{u7jP@Y%Rk&DkU_f2KfLfEp@U|W@U?-4eOiFk#S%>p=zCASv z9Zm413h6qgwd%1LqiZq!*T_c7OEOECP3)t088>^QWAqL|LJwgB;Qed>9B@ZES8`MO z)ey{~HoQpNQ2GkP=pziH-)Fgq1!dr>hyOajT3R&O=bc-{p<&__;r8aang_FP$4A}iU?PTBVkMsPTm)Ng8g1zWbx^ zE$BOAKX=v`-B@GX${M3POr2;!hLd-;!K2SbR=1wB(KPRIMy`BVH-1bJ^O+8w5A#EB z^G3}h*Unt`;BOZwwOr*C{tAF0$C7f+iIW1gU(s4p9>UVcS1f&e$kIoW1E$g|9J+B> z`y!8pv z6L*RyXhn|AzQtLTjfARsCWUU&pDh^$+I3-s03+ zQL;=$?LO{|z`JlAdC}ibYPpWqCtMd-l+I-k@vZ5jp1y3x8(;gLJ@T*klRqZfz&dB@JX9e%+eRS^+m^$5O z>U5uB{XSEtOH7@%s^zK=biT%w`=B7+7j0{y5S%FauyvSB72G~4uwlaw^XoO~7~SEJ zm@5+rt|7TsXV1!9U_4j$;+%at)4QY3qU}{^`ykq$g0`P_tS^nfEjmuZGnk-|(POE2 z9a=OOTu8f-l1>-TOJb zA)~U^s>dW&JszX)-}uYABD{*sr&5D6z9iekctKn$W=us>EynvEfcHK56cb^0R2v}`9eWoVEUI&Qs5nV0&eCrkBfZS+&TC2bE0?3*s`+&$be)MF$4Upa?2e ziLfSZWN?y}C{MPPP7GEyez4(Y5VlgJL~=eol#2i1v$GSlDGOC%0s!>%DR^ z#wWl)iZ06`h(ku8mhv5->1f{^z5^ycEx7W6ps)7u!-C+d3gL(ObaQ;br4|w(>mhCB z?J`k}_JjJDn8;K^eouq8sFjc?rU^dFGgtDt=L}_6X&Bg$pjR8Cx1Go|faP=aw zO(gka8_6Fp!8VED59zf{beJoJB+}tB30Hws)tO2SW^pNo#U+0hm+t7CHHmk2z@D`M zStC?4P2lHqIjFTz|(hcBhjMaJh` zY0miJg(OK2SjoD>0Vc-6-%Ro}m#c6QYpCQZ`>dv)Me zhrlZp9t+y4XCKLTY2PM%<8kEsi2|))Q7_NK{4RvnKnUQr>exqJPRBc0-6rtVPKQPCH^d z)-)MqwfflNhzd!~!!1fqc3KzPv6jh5s~gAS!z(;%?rTvd&}nJxH?>T>#{F@uN_h2W z&216QjZF;nKawW0eqkaji!6|8!$h=rsfZHHMdXiYu!!PAMYIW#44su~PF)&)UCX4mh~h&;l(=3*tq?hvOZm3t&O;)LLDm?V zgH-DmETSMpwGj27u|*ZeYRHoeiU%&8J%?cTL`BK(DKtk#tr z{)u^un#oa4?&pd(|902vtX}aA0?bC9`XY;j-G!XvsqZV z{3o-9_7-v79Rx15D0qbHf`bCI`UarYBLP~?hI(}z>eU3HUj5uus8`<$^=iRB zsnm%|x2Yu5tH*J+<2$B4DOsa;vri*S-mAJ%s8^-uRf?+i_qpN^KkrbZ_kt}Kia+dG ze#+S{QyMO-6t$!3h2p}avTt`n8Ym;wt2k!?FdYVHWh*=?d#G2x3iZljW!K=?c&JyC z1zHsc^{NEWs!mjbdR0-NP8MsWQa{L6pHT_wRcD7I&CZ4M-3Iw?H{XTHcYUE=jiZ5H z(m>fp(m=Njb;F%pH^~+BYb5NfC38kt^+)7}sK1ClLF9$V1Cg7Ejv)E~(NIJKL{utN zL^BZ$M>KHryn{nWhkh9+|MJ<4FWl=+`A(Qta}NF@Osj6gl7(rtw%J4wSObL6uqp8? zL14u{@Dc=;U&>yE!1__D+ri_ogU7KC9>)jpIPMGi=GZcA2FrtUv)ym@6phxGhoQBc z^2ki#ZEP3bhWx*I8!W<|JU7XG8R!RWBm&XVG7C>}t1?8h5Y>@dzFfH(wTvP9=9uSq zl?P33?`FBvoRf1s9-KUs>oI~Tk-uxl87p1?v3BV9AaKUl6E;UC2`f)gtMik(o~rC4 zH~veICs4-5KtE3Y*X7Fe%l)#SEp{Gz;6iMv13$uluA zwR7ao2M=b{i5obPf3cGLR$p#qBDc~oQE7fSU4H0QTYhND9nmG4e1FBjn;nJ2V+FvZ z0yn870FxIJ0ipSfw%(>K>7z%j@)Ui#V?+yvEl*SaWOpu~r`#)_A`5;P#1Ey*dWQ4A z^@{G@9g^T3)J~LGUHF8mxBWTgC-0yKhyN|Voap(bucgTWtEC%ZPQ*lM2F z+An4;J8E@))VI!_;dc-G6uHys!Oed^9M!OuG&5P$eslSG>D;y(rE~jt0&5j4P@FRl z-nJK#)gp>jQ{u0EWrr*nsEi;mWcRs(x>xsIxIdIsNt zZ_waO8Z1oFH^T%4fns!>gNt_Kv`aWG-QB(DMBl9{Zj*5(oTDYDoyTe4meVG112RSH zu9vi#=e4d@DLIZpNtfhRb!5JD>_>F$)zX*W7X2;fF>n%nR7>&dlUK)IKP;-nJg;w8 zMOAgY`e!S@?<#+kvdAND;D;$o)G=HgSE%C}j$Gdgu8-cFz$F)^s1nV8EY08g`g*Tw zj&1q>nKH%!+aeR0Gosex0=i0f59U0TrSm(|3+)*S=#xcJDTM#avuK-vq@t^>oX&xs zwvwLKmYz1Dr3}h{z9%rN;XOpVlVoK7msM)m(Q)(9{#wz#wP=4Z+INueTQTzU%Kca# z5DQJ^p$z+wu^8<4ThZ<<+U0M?@TZ${3+8f7MJ%G%$M6J=;f%{Tqp?IaIpb{3$e~!r{0~P$Ek_AnXG9Ny;YrnOX-|Du2`~P*hX42rcWnU&x5iL@W1B-r?_rR2>o8(3+wRMPF5HO>vVdwxyV; ziXEkRNnHUaPldbHL0ZZtQb;XBs8=VeEZbTy+G$s;gZx`n+)c5cD(+!b}1|5SSS(skjFfhAiB>7cqQ zLhtG#3XWSSnzYd;a-5X=BD&*^Tq2wY2s3XHu)Zh}I&y zhv=z@?jbsi=r2U6)aoFjn}|{nrBe%0iE|<0m2755J&i@g{C@+pU}sxETF$G5T*p?<%LfXmU7kKEEVaL_W63(6|p; z;vy-8AM&?9q^-=Y%~cT9quiVjx`H>FU7YjC;C*GOOz*Bq?`}))4xo1@tKO~Iu&;t^L-?_`;AEv8bFHB4pM}MlCCn8bkCtxMIZa|;Rlfa zm;6t z3ha1iaPcXd*`@Y>9`2)mgE|RO%Ca4}@TjJ4Qkh|zarG40{NZHtTQ?&xXDA^$Z3)(C zOKG{yBq2iG!JB^y^ijC}bbfIfKg?}Eyo~IH1eH-jLW8thO_8S90MPJaDv9daK&!lB zwsMQoa%z0Sk(`>GF;$xk4#&UjiKn?adLKwUfx_Z^&$IA-))4EA7_IqqYm(2bC4qb} zGqgGXpmXvHn(C(`a>-bt{02r9IHD@&5941b#;FBQO+~fWptZs9NZFV$8TGXU9yuC# z+8JMu5HYPNyEIqF+=}THfoaQLo6J;Mm+4E6$b^B;x;CT{Y z?MZ<3G0dX*$}B?JL^_C_VQ@M+e@(0rkMm-UWd9+vCNUQz<$_vbL3m(67)2!3ND(Dw zh-H&U-iO|li}eY^1kuYqZ^}I%tYwO7I+zK(P*G<_n3fmDlW?E!Uq!>heYWHKoa&YY za-nHOsI+m0?@EGY zgx%Vw+i$K~gFe<4)^=N1+ie@kYc(LAS@KBC((~EgolIptc?nLyrg2_-D45N=QjDE*3 zx`ttN4a4Y~GK_$O2DBRAdC%If3|#eiYenyEcdzN}+!{kjr`=$1V#W*PeMmaF6;tE7 zDzn_+Vs2AoWu)Y92k*$LRaH9qA~MSjFRJW^tU#-%1kRh)3X)uEVLU#kUe!B2HQn{T zlk~@AW;t46?Q`jCZxHxuN#LtHYfjO%PfuOu)~^bxe*@K9ViUXD@YP7srq65{swYX0 z)#RN9dmlO!Z|6hbex9wQv5BKH?IBHqcLH}y?)_TKl16IJa)XOWSXKs6ucmB~ToFwQ zzvKpJ=aZ`x^P&P;F&WaAr%s4>gZ$@&SE1i%TOW&Tp1N*pu$|F1Z+N8pBJf!K(f3xR z?K>9ck>7<0Kz@_bndI1Me#rFY9#8B_llib`hEF3(yg#k!W8sZB_;E1ffE8>ny9T%|Hh9&8%DPuQ{GuXM6oZR-*g{=Tw`aqS9;A{zb0rq^mLM?r;{u_og_ys6xWd@t|RxoGDvIO!!jQeSJZr7<2juO(aNKv;J>Kq z|5qAs{w$nA*dnB7^a8(b7Y%-uif{KGGv5zjq}*r8>C!8r&8;wT++pIl!^CkPAOn2# zc7}Rqma8`FevQ+K3*vn#EHk4Z-j}%;HU+j%Ug(GU^>mbpNc~&T%a?Vcmo@G=%>v`c zf@Y65mltr(?9VA^`zhLfgtn8=c0w7uH6DFxq2pmJh8-l+cnZ_3r(_!QPamS-ytC2s zs+G5+#4vYCL2BjZ($L}MD0GotkBN$=+QdCqsL+i%v%57+9GO!IBG!YI#aXfzrIU$s z<}FcMd#1!0dlM1>;IDB0gRy;O?Me=mbfldZrl@FwwU{2g!SqOP^UTWKs8w|Ck=&Zk zjLhm8E$c^n6^)k_3nf&x_1`;fm9xXb@V)t z?kbM|7^QEcJ5XM#ZNf^G5vf-yn(6`l$eMYw5A)=+%#&9tXA$1_ws_y$;(ZUm`<|@U zsK#qeld2O~p_Az@Q#1htXnBh?V>#ooa@QCQyvy)4gt0yIjI3S$h^VMpyjTX>J0NB? z7S#S7+V;Z>i+mr6Ysj8nmCa>v#I8%|PeHZ(Ws{7t{%gNB2|OKCx!2@VWiKRo32mzG z$|s{;`c1fba(UFBM{4=6{l=u3|5}~iBJuCb#)0{F87#zEG85CJ!7msFb=WhcobsdS zU|p%IFT8JH=2n8?ZdJ|a?w=nfXSgeHU)(L zW(LH`So znM|H$(bs1&u+PFG>cWE88c2p~c#o?+nAf0twPLkKX9y)88N=hlv>hLX=R%>SyMfjp z){hAu@vFzojWg29z7}x!?4SQGRdLIsz5Di#?zW(8v70T!+Fz|yZc3XK>*xQ_yaM`j%uaDu-qH_Ho|G0L%1NW823nnViC#ak$E(`Ht7mY z>D`0r-7)lTe|q;Fy+L72jq-G$G%=`_E;kE5%;tG15>dgnJd`Qhi~sOfwcB7j0&^x2 znDdyo?QhC>VtRd*>Gf3tb7ESdlCkm*m)N>K+eZG*+kBeX#`;I|jLN-q%=1p!y~?9j zn0u@n-c|!9+b<(S#W+5e)m2mPq(AA9{xm)1P+)RkTFUjasedQ$NdIGO`p<{bz6gBU zEIs8;hXYenQy%U}zjHk-^=XIX^z_F;HSPokdN_Ug#JIRn<}N~pMLK(H|FS} z4oyNm(o=n#U$`xwr|gxQ&t^w|yyw%M5C4FWwP0?{yg$DD{)bWv=6-WpBv(r;m>auI zBv(r>n0x+Lkvs=vNvZ6Dxfh2ZswjnaQW#SD%dit6#hY3DIil2OZw@VeB<#zO;#QGK zBfkDD*3Pt}XM{`X_^{O>#al++9`W@&dt1|Ko^~#!Z-#vuQrtH3#)x<4$F?$E?Rmwy z^u4fuhZJuUd1b_n`SvYMzxJHyT>7uDfg#1)MaGYKcR{R;=?zaa=h7)*9YczDh&(gm z#sYh5+b5p;oGPV-H3<2*L*(&aZY+pxE+P*nm-JbPM`S6EQte5wi1t&h zsfZ#F-9WULT1`Y`hv+z>&#Bc|L{}U{^f{u<)M_N6iHO2nr*(*2Uqxy)c;$(wnM3ik zuxW@^ipajci1yiwXr$}8T6=?1t4cL%>==pDxzS?%g*g#1*&xW_G1dD~6iZcnn`#=xJZ) zc>Ka(*M*67%)hJMx2wa6PLV;2t9;^Awc)EmatIT~gW#er^t87MZ|N#1srieAfAvuK zSIvNA?GgUffd_)G8UQ5gut2hgek72rlR&aAQVB>_3o8B6*(zq$nKdQv9jkSBTFQ)( zcB>EGTr3Q%PU}kEn=2fci3zJJMP2TnIBnvFneFeaX}{RHO#HEOLZGNCZ3>Vjey(M` zkVFfi^!!v$@H@*(1;?%r5%SK5m3vy4^ePcM;-0-gJKC3(O7*2uadWA(S}N6BER|+a zsgG1@lSes$+hm%w1qIA+GYB2j4l#cbgi@ceXUJQ5q<gF2rG9cFBH(8A z3zAB3v)l!)6}hD=d@KR??4pvJRJuZ?!BlE2l>(@=Ln@UDl}d-HG*Bv;IbOZ{^F{BV zHbT-k^6G?T<`;VGclHc=P)7h*b*G#X^i|JV4_eL>v7%!|D>~NyC_2_|MaQ}-RWg`Z z0!9n^05F<{j&(UZ9qU5A=~&hNH_)*zD>_z({|$7kLtk~W+zBctlbAJMupS%o6pdN? z`|Hgem&>Dkv$Mcb1^`PrFR+vq0!yhWh?M4h2$2sNyp*x)n=3BT@Ktb;+QUVf0vBmg z%56IVTBQtyboFd_ot;Nk9&`tcbx`544h~Y~!Rk0f9fzvpFm-&FBbS>`G?oHrNq5Kt zjRoYS_@Rd`mhVH(F@ie!GcZ`TV6e)A!CER1o%bVa z*^5#tQJl|VyU-ACUOiVl`DD8$GNJ(a$%e$zMqil*o;s}1c)I9W+Eoi3iKUI#dL_^| zHseaPD%7} zLYgkB&&Enx+U;~6eSgu^HJ5BcD+aE0vwZ*9bud|pJ^Y+K6A}lgqmMd%q>i&W(lZJZ ziKX3^Eq`ATu}TJZ7-IP+9XnH|$XP`vGBOuSb2=9W8b!$}6+Tt|uOrYZH=tD&IDEzd z?&wY7j_y1Xy+PnsHKeyCF;6-Ez|-ucEu6F<(f%1oS!?9`#`67DNLeoOfM}*vs&W7$ z|1zoEo_0^bSz8h(?HU7#rA^#2DiTW@!WCc)Bo=DTgm86?lnK;XhSq4yb>)ZM?(9-+ z>ay~$44DvK-h9ZDmem^V`@^$oseOO6tX6l(6VImc+-ZV;$D}y?m%9AL{KoC;%tRzQcAc zKV|i|`N>$zI8`ieA;rG$A}vcXP8DBQ(*HqfD#fj!tu849)fZr*Tm=&~6p`cT;8PPf z2__2q*8L5-;aTb@8cJ5=$q}!FdmVOiTj(BnisA)TJWcVYDxRVEmnxp6Si)KA>Of*? ziw;~AK9xF^n_S&Bu5J)l2boI?o@LqhyPx+assLEEssJB(6lA;D2(Az-~j*)R24K(H=zafg-_H^BdRTcsIq*T zF1V=rV3tY&kLoBjbE9e%N~J}d?j`WK;`y&FxEape4A4mh7rlF_#|O(N(%asWZl#+> zH&#^gH$1G;r&6Nk$Nho|8v;V>djUw++VWbEEN38Dvw&m)LMs*BUa(i~q*VQ`boQRo z+3VBU1;k~KmS%zYsv{cog)?TRPh?IlKwyFb{a|@0KQxxejx)~ZjBm?DByy=n6V>O8 z{OyTc#7Zv0Fj1N4w7(0VkJTH8Qym;mbuRpukM$DySmI^y&zezmrnp38>5hlBkCwg7 zBJzmiiX~Gum~5q)HcusTa|7NEM=~sy;(uOBMD9|Rf^LvY!7#@|X018mtKN;P(D=TH z(flD}Y-6s&W1-n+{8uhQ?H=f&0<;K^jUhZXhRs3!*&OuFwXAvI;*#=P!H!GyP9Ky! zcHOZaIfAbM49SallO<2Mf8%|+(_4&| z=Rr{97<^lrGfu=g{W2g~5=qpS^z##HV{?Ox85^6cq;CR>vgUf{65^9t$@fvphD!k` zaUuthpqmosaqCCozMoY)stUrdM0xtau;LznqY4~WrTL*58hWwq%`^5H^kz`aL0Zu9DwPl|KenVz zU`yKQ)2MO~eRwa59?jJ02c}LxFm?KYsng!|2{LUPt#jI@c65h}SHmw=FK!u$1vaua)2Q^Ng(q7syMq4Bbj+BDhe4J?;oK*iL0Db|JB> zzRa-pBc3N>=1sOJ+h6TJJP>8?MA>iqK9ZD)3Vib!hpqA~+)?Daos8#n*+NPVai%S! zQn516D2!gWyh&C?QmYAnJGW@3&Jn2+ltbv_oeQXBLtgJtF^4?dvQC}!aD(lmJBU%j zC_cEns6QqY{cdAAZpNXA?G_y-gRw-J7KsicrHDnDCWs2rQnpDC2Gj)%s0$cS7cijK zB=5hi77i`gTSDsQ8@!>rjK{~cvXU3Gz_A!R*m!6x6^vz^=qSnUXV6ys5zQI*@d8l! z;N=O{CPcERMIEDe2rFj@Xzu-F6a|n`l&mtyhLAV*6`}4QF=PIS0rn%pE`OgTS%>5G z6J*c4B9_p0vYXbKNdAaUsE0y=k@4|>0P}VXEk&L2fnEJi_PIKvZ?|r48pmySM{j{XK6-BPQgS3=3;&&U~uWy8om zPh@k6Pts(8YYZc0;Ycn?A8eDV$~G~$_{d%bQ z?;}YZ9%x{KOE8G6?^pymipq}?a(fhW_$UfjgwdTOxa=fxTuq+VCoJ{rwlntx7lt!~ zGCus6;i^;&jm=;*5hy)B)N1zPR!TnG@-W<#$YyX{ND}DluR5~_bJEb%>eiL=GWuR4 z;8_u`$OQiiU4O`eR}u?e2`qR;m*?;{`!K{`q&Nx-_;S|eO=S-K#~3F(8HJU!FG{%vx{>g>Dev>(=UhV zvK*$%a&nSw^`@%xqAUnOOEwYlU=xv-V4&<~7NOTbDY`rkT^Sm_kG6T7SH_7MCXoko z**)~fQ99MFaO@*jFn;G)QqEx)WmKMm9e(WIWH7=8S#nl0)c#G3vyK>coV}i9Y7UVsa$YrM}FR73QHY>b8#-bI8@;We+Or zT=odiual%d50 zWqcS6kX4k~oNO$G%M$CvN|_}7SSJP-la$v+v!R9tmo*7it-+>|vT?*da3>9YiAp;+ zxcJ=a$(tIS_RKXeG`kh%kr(EXqhu8drpq16co&wj7nZRX4}=%}{UiyAp;`%vvTh|- z5f0+zJXBc|60=)HGGTCFlBn%H$>#Aef=!}1V*@>j-{ly7^YVWbv=Uez9TZ^0li}6s z)6J|m`%Fcd692}O7>7OV(JZh@iL-b@*S15`AE4>`SVfl@*S7-p$b!it4j|eBT>M2X zML%E8R!cesF>j1-l4PDSPwz%Hlcd15OwJ$LAj3ZBh3P%l*95slGT?bUWkQ zqwOhZ`zhLfgtn6!D?%1_PzEN8as43U`V_|XLUgngda`&v440RbQjSMBf&t6|o$JU9 z4^kmd`5|NpJ7+icYVN(el?=U;nJ7C&q)P4OC^SapkrM)Nhcyq0*^&bTTG5#=FUc@b zzM3L-j_7NCw8j$YuHvbd$mr?61$Dfk4$P|DP{}s>*r2R)CrROV+_QExON-C9RLR{k z%BcJ+b7qagS7I5dv~m^DrO%isbSKNpF-%m9W7Y%cC}{O6wRulWaP`fqS5;OgH2gjrixn9QlV8j?BJK_I$99oWTypm^UHPPW{c&yoY+1it+dq#jZ}8`lW6Nuw9vWG- zzx&rF>0u_X_nI7T(gIkP&4im?F1tma8g6WLCc`Xg+DBhrsy!{%jOF6f(2AtW@FCz; z5s%F+Y@+`2^HnrxLk)fQP?828?9_O(Vq|S5p3Cr}_Qom&u!kOL0^;NzEK&DB-426` zdBo9ONO~&jU<<(Kz8lRZMj9-gW?{K1OI&@HFnn+3joP0#>K5LpZoE<5fFQcHU=9r^ z+YmQY8%rDgd0$k;DZ*Ysdbb!XD&qs>s6Jd*H#+zWTPXb5{Iyi@T|`2> zJBYQS(+1UaHjP;ntSW2mpR)`?bW4`I-YX}HOjwKw#7@mVCLFo|e~*WP6z$9BxEv0I ze7Z_9?Gp7vMpX}PdeIpnxiy~;yX3{3B#h(PEFr^e4HY7#Y?C(P6G+g{4OW#?^*a!< zY{$M3oR(tWRbp|oIu3;DI1s8U2Lh`D73r_}*d8%Yo^K(=XU*ff^4nICcti{f64PaP zDD-G1!Z(JQlRvQLJ30wxGO3bvi~sD^7~-Gk}fG4yVKI-Um) zW#0VV7pj#TS=SgWUt{ee(vq<&6BW$;`tU-M*rF;N{Qz&yNxV59^XB}GH|KA>Ie+8L zc@^Y-46!!y=8SUN{g_Gd^OTbuD~g)YJfm`b84+^6wf}=m6K-{7Jd(!olboBAmK^wO zReEY*>h(i^cL+@V{Z88Cw1>6QehqwfIsMVt^jpKypKZLnW7wgzhw0DWiVjToNlQ;} zzw_s3LbEDcO=wnIzj*dE&ihL#z1Q-YaIP*tdA#vE*Zab~>V8E&?>zfRYNr4D!_VJn zzPD!0YNOt|@qY6!Uawhg(lRN0XWHtPQvXp*$ zf9JmPQuvBO87Z7BR;_P<)s64!t^91->))Q7_NK{4RvnKnUQr>exqJPRBc0-6r ztVPKQPCH^d)-)MqwfflNhzd!~!!1fqc3KzPv6jh5s~gAS!z(;%?rTvd&}nJxH?>T> z#{F@uN_h2W&216QjZF;nKawW0eqkaji!6|8!$h=rsfZHHMdXiYu!!PAMYIW#44su~PF)&)UCX4mh~h&;l(=3*tq?hvOZm3t z&O;)LLDm?VgH-DmETSMpwGj27u|*wq>ZeYRHoeiU%&8J%?cTL` zBCLgPtk#tr{)u^un#r4;+|Lzn{_QT|9nJRYR_4fSCp*Hq>iKJD%blPZh6|b@VZ&14X0EQ~tlF(#|K^A}J?(9e+bjy6 zv2at}Tb+c_V3L7PF>5G%jqVP?u}2mKk8s@q?dm%~R*!^swG`Ub320XngiLiG+Es$k zu697X>PDs8R2tmV;&Ghq_>QShO4jH->@@*e4Oo7m_`?<>$9J5v=+zp%n>~#y{%~KT z8ohVyK6j^W{Onzc(^3Z3QD=|eBDAZCiv)r4qtLD_pj|D7b~Ro=R&g!@tGWs8s$JQ7 zA+gY|QmF*(stUBLPpH&eD%FK()s0Hfu4)L;%3^(~XT?@P^m64pNBJ%Y+Eoj_gLd_R z23AW0eW6_i1G4HHB$c3D^%szp1+=U2(5^lgkX2u3R~M)>h)U3|KA;k`s|Qs2no7{F zDk~yQ&|6dXU$K0DqhK+f6dxPiHRV$QF)V8T%V;yl^$P-)9j%=Bv0$#crbH>g)g=L3 zMYKn@aH#_0p?1XzW{72#5Ozf*oU>Tb7j$?HYI$cGl zK0udX@+=YBhTyn%#@7q+wQK=}%h@XYsA~wKCnbWpGZ~@_g8$lSL#>L4x=1afh@MQ` zI&k>h-;d2P-^(?7m6h* zkMdy1Ck~>4R%ie;&c~tw3;8esQp#NUaP7f78}Fc31#gsOEx48M@1WLZ0z(-u0H zGsj-n8_N|f7-m^d*gCDs%Z0@aP{)tdaj80fp^lf;@v%Bqs~|Pe>jN&g9sjBq|H>ed z722=B4@=4qPfDLSs!Md^i)%sVmGZ1+SYw)6Z*xlNJV&k2`DZkrx9G`|t=`fH4XLWH z79<=ilfkA@tQi`{P)9A4O__*BP_syHv&nN--GweJ`E_|3>?{oys^~_uCgExr(s7Qh zoVGEib>Or-0!1jgdA3-Dx)ODcw>WKgPRk?k9#@hnI{$m|h@-pCzgj|$Eu@dWKT1Z| z;XOq4lTiJ0;+YHJqe#(5`P5xedG-AZ&EloCpL)g5G5_t!TYH8FwMp%{&DXL`s)IT@ zsiTWJ_U6d-xo~~xEQ#wYOi>w{?X0qoz zL4w^gM-lbF7ikz(gz&dA9!kJMAONqUa5U=^l-<} zJpwY?wN5BII!QROGlg}uU8+?6d}81x=ieY*t(M9`B3{Xdweq3srKJL^^1A038scto zXoPLJSBffrO|hI4(r+l5sp4UZja2blDLw=ql>)UY6`qvgv@4KUDg5LhKq|;nC&!0x ztsU(Y7F*8hxSK$n`e6Cc2xWCbkT|$iI-?>aShJ%k*um;OnY1R50JnpFGMR4-9mxoLzIMQl8A00I^ZK=N`IL4vF<;)yR@}RVx>+adVpw(h`bQ}i0BETsUq5d=vPF~ z5Cw|p7NS%{#mq!BjkZ>csNzTwl|nR~wh+}o^e;p+ETpZ~5*XEFq~xSkkXWhyAB*S~ zqIQU0L-dJ=%-4v>8BrBPGezWuXb7S=5zV44M57T^M>LzZ5KTc;8_}nD0vt{?aX7Wb;S_+r zlgWX!Lx+{PCc}5p$nRc+xC4y2f8g`e*>S&BY_KL~$!MavHcur*LB(lo!P_(dZ_^IE zO+)cE4aM6u6mQdh;xq#OiPMmuT-5JQejXws&crYLx((0~CM2yHEpr1uk8$@8YSP23 zo5?upGn8n&wnXDCx0xi@b_cbe!pRt}KcQcA{BXmi7@e`UYrQ4KAu2)b$xhyhv|CO6 zeKrU*yqM}He_w&DNESC}L&K;1L_5V>i3GRhsBl|dA#WL6)DF+e+}&NVxH#1{{wG0T z+M!z#sYE=F1Y!AgGpEPnZ`2#SWLSuku39SQY7ZUr`R=eeUA$`kREM0v={8T@WVb~0 z-;V>kmYEX5Q31tQU~sRXmBwHXQR}eIWMc-dJX1nsKC`Vs{)3xdDBFY6UF6;uWMlF| z_#tCJJkc;MxQL280QnUuBGqYwU!^juI?b!}2VSLnRb&=aoCK&i(NJ-G-ckp;{2-=I zp=w*g(K@GX+`c_rc@wTYADg8UFY^IEH2%(jFTO*0ykT1k=B#Ct-?%3QrMjy#e+u`S+U?n%+vEmxR}7oqu~ulY=ig#Vb$ zNGV!TrU~*f@mAxNZ4!kU`noz`i}qnaT}Qr353Q9471Pz684~G*XNc7LMuPEl=lZgN z;oUE@<{5{x*JwE8hH!3<@eGymyZ}^&_kToA`N&5PC9mi{`uhkn%I}a-uDv2%YQLl0 z{D1-S4o$AaVLpfLsQkxsWiQV8O=sBUolj&L#7BB~CaZFM=RIpDLCVPit7ItN#}izH zIU77Yxi@dUE$TR%ch9LH+h`kJ%$y5rvbnQ~453{m{gb?*HZ||2k~a)4D&xpd+7)@< z5(9Z>sfUkFtJIyG{^;XOj}&!#Eh*fu$ZC~P!06~cudA=<=(4@Lz_GG+bPeL2GdOPZ z*BNmu2(C?H$Y~o!%EA$w+0zo|zXf z_Cr>B3Yr+Motse`$V1u7{_x&+|q{)qFt#p$O!-5VQMixg%@47FleB<# zT*`}CHUF246Y22h^GwPxEWyLTbPL}{uG>bwr_&O3LAP0lQ!$66vbc*p?uff67kptu zyhVNS7S+Fyw87(iKYI2i@Emjc?j7H_#w z7hcLbF}V1`AYf%0DH}(O0<~4hE>g=4FB)nZtxs4bMu|=!vj(p3u69xYuJ2$`aTJC|6N&04$|?liga>2vRg&ZT_xIPN)a0%`kH@*UZ-tk z6rR1JuO$X~!wm}hO}5QNSbgfVoSBkA_{b=?Dr}?R?t>=JpvfUNGEvfSGoG(0XM)zhl>t_D>${)$bsM5{*&{(|`z+cXhPDr)?J3sz%#0|STBxo-N#QU4L%kW`iwJqLfxhg|)ag!qR(L|r zb%%^S1P$CYV|hkxLI7+D0q}1sn!hucH4l|mE-_x)i18{S^W`NOCMtDZ+c42#s}!9m z(-P@PJk?$WC8M&=o$M7OYaUiG{a3$blu>yIb7o9tWf`%B zLkwFu_^W^}jpbkjk4k<6vGO!IGF>rw+C9eem1MxR6u#;KBd9fN4?e6toF!6qC6TIa z8;ceKN^|JWfmOxidQjHKv#gktfs|t`S4&#wV{`_2FdqHq;CNY{GHy^8D^7Rqby%WD z?6z2bYtrF%*ZK9Y-R?TQep;A``N}6@CTi=zM&&2mtmR+#W>7Q#wMR`3oenD9YyYVr zoem?JAE&t9*F96q?l4e3ghLnY`iM=mxjG)36ZtB>xILtN2$)FVwutBIS2bV7Yk?F)t@(N zBZh-UEJbYw)Y6~uoGm;6YT>HC&dHk#)<))Th8V&c_-+(y58Atu=I0egN>G4qQj;! zwrRq04gF81j7G>eso-%wFl|A4@}cw{=}%jw-`SC#diBobLuub0N?nkiay{+WL(lH7 zN`H{@@V*FF1$sXEJ^fUA`t|xBE>9P_)lWBtX7w;MFz`x+$5J{yOE_1z&C=6$5A;hF z?p4oa^7&ChTB`4#wa!$!RQKqmZ+{*>x@6m?w_6_mdH7h9woOa763P4J+cvfMLL~lg zwQbt{3z2+K=GlPmTbq6(rTT4~x_v~Ul@uO-Ed|pX!yEM~y+70iQTgiN=!xISXq zeBV~4QJ#mLODBc-g-mZFInc!xB(^X;?m67K^n)C#;zmqc;A>-g*RzCk>1Sbf zA=5ipoc`s;f%&vYBwE4^jENm zzM@)F5zRn!1<@XAS&FDGqQi)GP^+7}I_5KL z_wC}~&?$2E;wm3Iz22~4nQ#kN*VnB2uWu`-9KKe74fR6o-!_jOaiymKAzHfzJKeho z$m)rJtS&>lx&ZAeKxkLxn+cifN1A^}*8fDn&K>YfZ^}UV(P2hYr|K^4^j+QkKt7>D{tM?^=!5tFupBLYrV# zmI;UI6KGfCD)+Pqfp&ET+Ev@K^+Gm5yZT#bSCOlvQYm0nGpGdZ$_%1aS1LifG8Lj# zFQ0X9*pk0;Ybi=7+`Tn{E1D2WpCRmKuJKPu@+OyW5 zE$5kEn7!ZGGw4C{v2g?IPB|x-tDdzU0=POmQ2!(d%ajfMX^tNy}mIGaKlEckwq?Rv0k{1`<3bg*PS?sPszk1C4s`IlNUk`0_`NWb^RmLxk z{H^bW_zm65OuJF#Zu{lss{Zk5pXj%juWCH@N!i~QHT-~krx!c*(^=2&Dwj-a?`GLt zw7FBXX%h;kNwgU^kjKGM9tY2|v?D5?hsq1FQYKVt!PzlFuHu$XGOsf=agX5L7QG=#pWb#qEnQT=R9q`~9WP)z;r#D>h{E|H9Vwi)ylG3XXwpQtz3w+ViV~lra=K0) z`lWl_cJEx3U#@&}j3BEPRA@ENE7E7yvZGdUUA}ep3{TwjlK`w9d@pb;?}=l+6tq>l z)`Jf;xdmAXR@z`I(fyadz+q|#G0XLW5VK|u4HnJ2#z}F*8i8jyI?D61bbh6*dMWiXJsg zETuvjWz8~}f_%p{D~y#I>G)mYRQhyBahuGuWU{by;jx|;bM{QQJ9Co3`auDIqZVwWA8TFmp>_!xjz++067H;VWWMXW$Kj6sDdvgK*0MDr!DuWA}Pf$_BH za9HECnl~~NEAw>qAvGyN)(oc(g2*x##kOq>uSF;KFgV3v`}PRtEPq%@y*i|OA@nf_Il>0jssFV1j6@Rm1? zfy2_KZ5b7Zr48UR3JwdkW&*fs$H^4z4g;op==qt={OfFlfi^{TQoKI^&=)6HWG*gc3im->7}T!zTvJwp);sqf z=NFDO;DhCxBjI9ofr}Li7psOqm9~};RVJazj-tvQz_A3iC2%aM@3%%ChsN^#XIX(w z^>lNw6e{b*=uj_4nyMq$z{x7O=$-rP>|EYLBi%(K zABjc+=%czxXeFcD3nj`{6q!^GI@S`HSX;oO4FHd}eT`^*h@)uytNEhw52s5#v6>Tg;7QcMF`^FUD?S!c z2e!l-_`i4elR0fb=FQg`oDJtBdtz>GLofW6vachYt`0KN%@Dqsa5S>Hx zKtvAhMC5_!dqj_@g=peg*%$nVwYZ6%I7zMc65SMm=q{oZ5uHG^578fpo>8lVh^`=d zf+&qzh*A(0vk_4-XQ|auL}uqi^e;puM05g?9irC|l{zi8I$6tgos&Jr-?WjCw9+Cv zfoLM4+KB!|t^>dlETQ8R&5)XSiS;yeS+fZuS9w4@}b zs+4k4lIN3>T$_|+Cug}r5X1=!?x~3P?!XiHmbA0#miPsw)wvsIGr^aXe6G^nJK+|* zd6bsqMoZd^x3@nL(A)6u55m8{&y!jhCrvK7d`7dC-CLUFioNqA?%;W@gM|A?bU`Eh zQB|cM9wgt_#Ov+DNn^A`4;-$0HCHSvb$ydq$*lPo#*hTaWDlFksRL{#y$`2I6jaRM zU9xF*f5DnOg_5OG(btjaOzKDOVLpPcl1=TjMo=e4&>%+8WJb{IjG)IELBsGl+gr1Z z;cr0Tn0^$#PkEhb--lZlpQD|$3hLR+1KX*g-Yjw&sfH+}o#2aND0n7_?ck2>P~B)!VTLCec&=!Ec5a4;^YYY9?mKs5s{Brs)Xdu~ib&k% z-)ThF$x|LddtEtqHR6fPEAR)a$ea<}d<1`JaxaumM{~_3?)4=_P$}z&_v&|^c{cOJ z2vVl;vA|bit>zImSDTnvC(>DhR4VW==Ftg+*S*Q~_<8J>7`g(}V!=ZT@1QkN*3@vS5x}(3ZXYYmUd<{7~KnlCs8C*}ZXpwJl`uYoD7%MqINj1!+l5JFqLp7$x zZ%HNlwOgJ#%CmRxa|pwjD<=@Ixt4*n69Z|E^ahExO%+}+oj`RNz?mUy0`GNZxqv)| zOQzB~-ZJR0pjj@`iyF-|VQ%3@C!MF|L+^f`QUyUhW&2`?uOtnh*P1=$;L+`)B@%D@ zx>|wKneag8o=E2&Bb)~hzq9lUR#LASi&nnWehz~eW5@s^?*F)HLWO0sR`ikz3LB_P z*n2fAX3L}qmX`LlRfbl3op5ex>H!NT z00YUc3kH(jhq)O@xfnsY>Q ze;v8^e;Z@lfdoYV8W^H9H?}x=zJXEBtyC7V!nM4t)ah=jdnDDJSc5ukj1lxMM$m3L z_fcva4#x7`ijdWuKK=Q!mj;4HimyKl9G*;vYTy`Pa+1H)K}y}G$7{hCEAd5RNhPJ% z>75s{jN2-LLI!(F9G)i2yf#%&4?bc;iO>!mxxOd&Z!3_Vw#?vjW^@#vo5nTHc=kNtr&pmD*7sW8aPXwUaWb<5_Qv<2P3gwo(Tr}Me_e5 zwG++hbMv0Oc)oXTr+-zitD(^{WMY>u-1KZ3j$(^ZFG!x}_alP-sE*hQ9^)8M4 zvQF2#W??Z4(L)U5-?I`uZmgoqZpC``%k-QWE0Rm&t1(UhS7yAJ+7V|x1LrCRPA3M= zAO_B48=M6m)Itmcrym37DF)6}5s5O`p44dt=X4ik6t<8xujjR`iL281X_Sr7gb~xI z$X<0tV<3CABe^tJoWO{j`_>;X9Ng8F^`oA&Dr*UK+K2aGuFRt9IK6Sf!^eEpV_WO7 zPWPKzmv_29qQ~M7uMO?7z_+O|o3=Az8Mbq0B4iJ{8eY4AV5+)ZP#N*ZF7=zplcNu+@TYhYNJykI3oR(C6n z+s5s4aogyB*ao+a3R}Yl$;&UK!z9`)UrF60QE)hafOE0$V!tH@9p>XRl2s)^V-ctv zpn;2G%;azGC*Yh1rt_oqNnCEFd>J_f2%}ZglRO>D=Av+%wQvT5o_K^K({6 zXubNQv7%@ao0wr2oEgOx3j&*}$rsBoH7A_XpGIgjNk1z>M=8q_Q{-N)_4OgNku3tX zd5|kEiKfB@A26Ib^BFvJ>+#UJ zWcAS9c)oe7tTjn_8@lhqQoDJ3f`v~isU@|sdw{Eai`Q4TX&ibfO$v1VQVM+U_gMay{;!Asu3@{oMC&FOntu~__=?rzFTTHQTF30; zcYhK(R-;K?u1!R~-u&?wul-P|j@jmxKOL|eGOk=}A!CVtyUF7(2K-P_^odfu7>@WOp&qFv2-|kpz zGUQXA?t(ozHsjLt0Yem=VaGZXt39Owp!^l*u%L>`0*`u@bJXyGF7 zK5Zro46E{Bp|1eeT1}zQg4Y=4{0{iI!Yn6 zcb+@=KZqVec(q*6;n>I56A4{WG@!iMU&L~v1VNbX2(B7K77 zgXD?iF47^SaY%!Z`ioQw&eU|IAxHz3&;4r9sL(IY3aaYaM|(W#O+G9{h8bV|I;y5i zhr!8$##+-<&{$_q_ZKwQ@LOLB8f#~YkD#$UpX}Z<+@|s5AEfwhsrp%?sQSw@gpjnm zv9LNuwrugwDOan(IO{1DSyrCpJ7?y%K3>I|Be~q6>4M|f3V7u?CM#6nDeD2-442t~4;LCt<7J91{A)X?f~PT0a=QD6l1;Jcp^0D~c zzWnYyF;|*Wu^aq+R#;YoaRbwg-t*9n=_@SHm?*H-ECsguPJyj_71+u_aj*H_FU+yzn8tUWIQume+c3gS@wE9SzcN0)NUNZd z1_ktl#lxej0PCfFF6679j@cYnq^R65SDEB1eqNztt}>BX_q)4f+^+_6wL?R`Dk{2_ z4o=qNnr$;^fr`DQ19O!r?XP^=A$0DbzYVK->_UQ6P-7bQDrwkSH6IQEtG)ES{U^jk zN;XXY_EJmiwdNU=;=CDifLY zv7G)lxOk5DQg02JRhIXtoxDfdXsV)->eJe2@{1T9tI*%mguC%V(=IKkh9W35mUk|k zt5_?16?3XXF$}DJ46LUZSXVKyI<*8*RYn@;_l%;`q}nqGS+w@dI+y>y#tYC{UVsne z!-u>h9pyv2$U0{Socv6_c2)X``>>b#ca|$`3zsVl;s(rk-o_$dUEzw_94ezpnH(x^ zqB1|bh$Ry{nMMWGmKt2Gv!;b23I)~mIronj%2JfUuQ!avjny^tM z7+QDM1DVPLfd%I3f&x&1qY7&R$*PJa1V!{sKZzeBRHG_M=N)_mEE1} z2&_^uQ_}maaFvJuCx|jL;T7$Jkfc~vb6{D4K-vNV$wMKKO2$lai`(eW=Vl<0{BH>o z>3o79ks9g*p2-EId<}su#h#I>?keP^xA|~ZSXjWFW&?Msmy>*Dg#_=(_~a|&W3Do< zSO}Oa4Kk}V2&S{+A97O6Z;D`%v0NDnB55LZn-6w)Rn8>9-9>LAilBnPC5ltQ|VUpB4Ir_LoPL;N|_ugV@X9F9F=SA zmEou>g~iIiT)ExpctVk{a;IBqXE69b?0u*Hi9x{|wMk>g89~F?8PvY1v}V6SwB~(` zph1kF0cVnYJbSMq4bc7%{$D%m5SlZ9AR_UOOD_4Q*^|2!zRGawRiS3B9CaZ+%s}c@ zL9D(vuDibJTuExR6xI=rFJ-j76dK~F0 zcSu*cK)T8nm99d~$K0jnEwa|UY>p^|EL_Jq12Or1`KGBiqf|j?RfX`y0`JfL;$Ixc z&n`$xc;*+oEKiMcKi62_@l>L@ZWFy>4h6{^dV@J}S?2Wa<_-Dd&!3w7fo5o~wlHk3 zb0}wYsz!fiSayfOi5rB06%rq-&^P5XfP6(1L1*G9^dny_R7k2yR4k~YsxnZ96aT6+ z>Q%^sZjEYECg)(@N5RNfVkj6HbEUbW*daxgm7#2!yiT8IRz?QFiXhjE1i5a_+bqfm(9%MqNHzw0qFsgZC{A3Ny6|)#0!ygJG77)&j-h^PS zBk-{cfsgYEe5`FDEzhZ>G}0s*a>k5#zJI4Uy|YyWC;L82AFoRUW@{#4KKy}Y$Etx5 zalAJPyDQSTsN7Hg5)w8}C*2X;##Yi*u9B{@Po=Av$#YL`LTwMEw!fsdKcKe%pti4C zz_6nK&Y8dPJbFFTDpGK)+_O~(TYs6BiGipqg~iH^1pBl%#tJB2y%W0)M_nl_)LRVxq}kF{Wuk_Hb^T zUX7WPul;bIp;*sS!ym5q>}^30oGWNu)4|5PaY9z0{Fx^wR+Hu)(?FWLUtivYNSb?h zn)?cxdviK>+4Z}ZnALox3@H;iBI>zK1I(Nkw=i~b#e&d$GcAllfbwz^2ADa9CtPIg zW`8D0M$`AmN_d{>dt(J6S%E->;K9+n#P>MuwBiH@>fiqCSw6V#R7ha1)QXo zw;s^IlSnd7EGt#40s3RhKj3$^;*Fj!liqVIlo}wJFwHI`fR&-=;_l~i_u|rcQGk_! z=hD-<82+$N^f0LUdW@!G4fSiZJRkSLNvZ4`;Z$~*!$dJrmP+#ufbV_73o({8kpQOX ze%Ng0VuTKRamppM2%cP2`KFDw0xf@p5$H`k4tDYH?}{{pv{C-$;%W z5yezzZFh?qbAI+UomOxTXOZMT$i^v;S*mV~75pwF|2=END%rr*q_Hh+>0;6c%BGd^Nn2k71}Qg~ck| ztuhQmT`4S9ZU&P69AK62%|0h$AQ*#H@93x?>U0Iw-JI$k zg*ki~b9gt|h$G2HOl(f&k76u$Q9v#Fbj`9?7mOq6JXH3+0hlXIg1YfBSDGtkm>TrB z%+(9v|0rlux}lqbw2NsIELKQmDl~r&LeOc!vp>-}mD(y9Rc#-5 zg=ZeiGY`<|pwnQVCDuX`_-S<#Mz`yv&UHqO2f?eW+CGqJTP$lH0jzo4=tFZ~&zgq> zb`=5UO5;#5Rtot}Op$0FvgV5a1zF{4JHU5oV0)N4jb`d}g^6Y*So}1 zb*GUN2B~vlQ3E$qOH-Gc$a@e(FaYb>cUjNA!g_YBc3_u|Sg*pCvUpB-r>04NYBb5n zdl=4AuynO!hMFhYGjRGbaGqk|T*biYq;||;;7rB{z9D`;aVP1vf^&EfG74W|S#z3L zL|U$3P5!#^F;|&aPxzb$GlZR6f z!@^S$*T?JaLy#RXCT3j)i8)3kE~U1&QriQm?JueA@zi#b3a8qO!)QDXqa>|p0J=zx zolzk2m61&n&E+QWybU!___;6s#bNq|VAVZwRjdoGH3$4cTKltR$v=?jsBiP;d(UIy zREvp|<04;Kl0L#XK96y{7UQ@h<9L7?$64xjFwiTKuOFs6Ggm!*Crqwh+#t!kq9(v9 zPaCC3N;T$ZXR|<5#FGmy_@%huo8Y1IVo5nRHy6C@A9ze}4?_Q4Yky4q+h2k}8IG4Jjq?U-sM42Xp+5|LZQalJdbU$|J zM11d$=t}R>m0mGf^>|rTwV0)LBFepWKgYRe(6Ls@fSZ%vUz^`;to#yfqsNHb7LsI= zc{%oMN+|M_lXi`soJzkRoc1XFL2&x@^k)watbRHv^-h~-m(w3_OaJ}Hv||U-(t2(? zkoM%x;Pg`mY@a>~zMh``N7a@m)Bid<PqSL&FJc>U*JhK#N{$t!8pjQO8^-T2=7+rOyZx`~yU z$N{fU@|rVx=KRmjTihFLzI|^g&{v|5Gn?eK<*pPz-%5(_HT{?E5^Iw|uGixK_L}WJ z(@$;Rw>I&1O^lyv9x~2u>Jf*Prct)-tW8F`o`|3NddOJ2SKR$GEsX8s{HXq;{*mlmpBaRH6(y(uhz_!Q#ZF6ht_wRWm zl(0RtBU1PYJ{^8mt*Ju2N+=O>xulR7BAyMc*>zTl?`#%US#YbaWv9A*+dCg^ z8##S(wU6XV4N8aA?$gKAu2V!rE$`)ByS4kS-@-rPrpyv9!y;F!xr>EJ@TR4ZrMh;r z+qn8G_)|^mhdfEF5FarmrM*b|L@J9EidS=__M4auKwP= z?7264+?qPUw5CO`%6|$6D=satZK~IjN>QtKo_^$XZs`u;UwOWvcw6UsdI&bFgOFJQ zLxeo_bA-UC90f)d(nDZWJCW`qwL`V-XEwjfYf zW}vQaZdRzPfeLlCL!quN3+gKLtGiPCU8pO&srpeJpk9SSy|S?QN1HL_g{iT9gH)u6 zJjq(Oy41;_@Z{if)B`NyBA5{cw%W;!HAecZO#0|51yUpc6lY@we!{UjRb4n%2g_ENWmzf3TcNIYD%91xpss2w)KyP~x{6b%tK{i|y1H4SL*#Z- z?igm+F`k?q&rv@~Pe#?_b1k;w53WBUES0~;-6mpTlq%59}2C;RV z2WF4t%DJGPTLA_c8^(tji{j&o?mvdMV>Xj$dtH8j6 z`(mvHt<#a_k%_FLrDg+L-SerT2NsK0WD5^L2aKw)q{oq#8TXsXz~Y@yh%FspD(+4p;#}!*eCY17NLR}W>Z)_oQVw%{?odHBr1@sS3jU|&Pr^N0 zBYkh9{T}BOR`AeVc_HqCIeI>}uHwU5DU&iom{!dvb&4KvZQdVI)n!1iRH&;^g}Uml zP*)p3T@C6tqUNz4@;2_^ZA{{6wB!XXOeqs?^*AkX`=Lz!6;GuSPo?N2;~}oJiCT`l zb3OQNRlT3s&izg1R0FQboJy!y46J?(tfv@QS6M*4VmwU(Xw_E3u%fkR*17zD4llqu zsoa+G!HIW-ny!0x{&1Tco#bm{q_bBwGR`oi~N76AlW; zRZuu)S#d`tHa}W=>DL}2R~9*pGTr1uQ~A)%doqNo$gjK|!+id92@UaxJiuW|R}K$y zSVbLv&0#%t_zj149A>hv>ga>G(&k_(?i3WNCorj8m&TVDnpD`9x-qU{97d?a6&xN? zhbuY!RUNM8u+(xXI|ZVax_B4P)LYJ^E#-x{(&k`Ae(!A==Ci1~yF89W4%e!~OC0V{ zhnG40Mjc+^@C=6sfN80V!yHn#k{xkXKc;n-LLYfZh*ozidH6x_s6LZAybAqlO$FZ& zx6Z;m+8hq`sx;IqXDC98xo+?vyf?RFNxokSm@A z!Q{YA7)=5cwUaA0<|bUYi2_R>dDJ=o{-vylvG|XrMs!!Ug`!s-17FtvwBXCOM#vj5 zuoKj)`kGU z-TE#MNl(O8>X;*Uefp2xGH~;~=+D#3eCK68qEnfVW}JGM5_D-*>y$4_v`s3rr}CE_ z%K8sW*%UE*TZ?VCd;j*gmi^+&@kk4gs@00h=}G1APNr~jV@dYBlcrqJL~g{&OBBF6DhlA%C(bRt)!Na{mXM*L z#KOlB3qOxo_*#u{T3k?0i<_U!ZaI`d%{T%z=V>`jq9lr2oD((SUVR7m>d!e*VMmc# zAe}}^5y=@kmM7BpNDnE6Gy%xfPo%3p7RZ$|bgbn_H<6x*bQEbX(mkYSl!A_R3F$FX z8l{k)AiV+#>lJZMIJXt4CUmU7A(a&AC{hcgzay18A*I^c%Y8w#dJTM48Ig`6O+c!P z^fyXD$6Ai`7E*aiA?-!_2a+kJpkrM^dIzZzrI4N=wMF_nr2uBtOb`@S*PRmORHd<$ z0+`hTsTWc;k(@KU8nStZd-Sk!Qnh;JxllM!XUxYK2}k&g#D`{7_6RDw|CuClYmLAo zc@dA~Ry>kka6MvoQ}0Aqdg7ET%+wDZJDlS)$(94cI&|UgF`wY zm$u=-xJs?;hnzGKa?+z*B0eZT7~e#$DQp_Ah2U2t2CR+LVX_L3h{ih6CB)Y9Bc+L2Pi9%ywos)OKc@@f`N2FWp98I*7hBgM6hsK{Q7Q zcKs7+QSO13I)aOQSH6wIhG_CY>1wL~fXm8QQVQ{!l6#@qbv!d2qll&9or1{rSnNmQ zhu(*YgGqx{aY5uu=$rVk*0&Cu=sa-I-t5Xx?Goxl3||m2e98F!ujBhaj_*G##8);n z{Bs{|Jcu@)th0@40yYK2B~e>CH(ruk?IY>(Uy&|P;1ztTwz7ZW(Fz6~CMhl$XL{l7 z3?-;*&|2BQ@Hb1gGSvGpTTqv}AAPnnl(>>A0Du@B8ZtOJ>lOE;UvyNqQe8+FQ98&e-Uo3>Z%vD_1XuY#sB(CcbHMxLr1C{#Fi;umCxbKD5 zi!t^zn#z1=OR8fvt!OT-Bo|Gjl>V%&g5;1FIQd-rixuhEO&DFcZwLB%qe+HFOGP9~ zitqaeCH7sfh>vK`gk?G-K6(((6;9TJV|8iG0S%d}b%d+6oNQIcW{CcX=cxY%Y_G2oCo0pbpi*XLcwuIl>vyjI)?9SU6KS$Dp|VYWXGT?1D$Z}dM7Nif=}=C% zMnvM^^Rq9ot>N>f4a8$U)$ZXn^CWLDg zpI%Z-Rbi)a>}2NoJ3mOn!^%yvpp*)!YDZvK3ukFnLH(pvB}dV!66j0UF>rQa;GCar z;1u+gErGV?Qlq*9;mb-mCu<@h4o_vqtOW*lrER-1NtdMq|4zos{b<36uDS{1>?WAi zM#)UQpkr!6$5hmk!_z10Jrf>KlPy_x_<&`HKUibB${N!?)|i4WQstv*&p$Alez~ry z*e+UYOnG$VE!KD@?AHl0WmQ3$K$RJ{vgU^uu|c9ay(AlWW0Z7K+30#7W@b8QCdJt# zcbT_e)h87~(#q8q=k?g)T>rzgO_FONhK@E13q)|o6Ro)}463XqlO!9Zt-lbaa~!Qf zTeD#t^&opN1{|JWyXC3Pg<-`&>fwMo3^jp)v>v;Y)|OTcDovB9D*Mbz#<}i>o>#`p z+K&8kXN)7g4-1;{B5PLvA19)#OvG^{4$G4A9o>m#nnlJLEN?}{Q>lGv{gF^7yTjsN z0gJzRMR_MidP?ml22%U1Z%Q{UUoqz$dcG5}CSR4d+>D-DKUP*j_*T0(eIa~NmX)iI z<6IW3VH%Z{1K14izK3PS#l)4dxtkh6g+|ZL32+$!La%4%5d_+l1eU8zkYyzu28~Rpngb&B&d^ z842T3!NHRelsyAK?x>;Nj;?@W>m?p`YA93p%G85cLmxHw71 zML1KPLbqZ{V_m%@`-C4m#ALN74wH#72WRVRfa#5 z<))(yo((ZYS$Xioh2Xb|BY%!qc<{T;5ez&TJ9|gJRWa*?DM#zp&@E-MCKN8+8*Lch zD$!hVuhFa$=|XO@K$CezqotsC1GD}}YxK0H&Gw{2UCrp(n$dGoLuqS&os+hf{04c7 zt>{oEk;3+u?i4nAnUZM5e$)CG_F`tQ;I5MrZp{eCyFyyH1`X^e81yfn7b0q$vME0bM zX-xP1F7v0|%%4Uvf4a>4X*bP%WVaZh*N$Q#yOq2zwWQiLhLM^zV-y)`wHVbN(YAm} zv*1(!w?{$Yzt1mcuyrx);f{M)FxmRA?#+X}Bdqq#qt#Z-L zcp;0#Ns0PP0y1Uez)K=5TE1+J>9&9};-h*Hs5!@A#Q@+Onz^t3C{?s?%R2*3gqa$}Y+o zG?{&NtRkx5OF?{^hfVOCL5GRVv-R3wLu3EwFo~2TzKTu6bZsh++d}WdZ1`Zkj37-R z0fBM!Rz7x-EJ2A6N6&q$wqyiffmd-aElqukvvjx~Zqn3a)GCPDZ*&uj zUT(ODH#2~%WvflR3iFtjXN{|ZWnl>Imqu`&hHiY0uYNv`qA67nn?h|$vdFiMSR>>Y zu}yf33n>mv&u}gll!pCHnv-7n2NE4sGoO7njx$g%BU&zFN5fF&Pz2iC7=Wl2 zvsJQ57beX5?Tu(asTYsT`u`=Q>kSo6#Uf+Ca322|Wv?*Ha?!cyAZtx-(Zf8LGV7Cq zK;ar#g+`oU2=ksnv?$tEw{84$5j4IkB!*iH2Kr?vdP1k0119 z?96VQaITNtQ&y+{lK$+E^gHQkC({4A6Wr#}U&-6j?~O_SG2oeUnx_^ zY~5v%$CZ87zw?$RU&kH3-Q)2W1AZtiysR(LD+@2HiHVo%Z}C&jLO!%B+1a$I$q?5o z@voTo9dGx~Bi<`bKez2}ZQ}2GI{uZ{`v%zkbR;6&^q{SUwaNRghvKK!>iaLdf5iQ| z!t}K5?^Y(`T)&8)YSDL;-M`}MuQ2_|cE6QLkn5KCskQt1+xmE{Az1yoOr*wE8`4j_`t+D+?}=6)Efvt!B#I3Z$s0n} z38a4^y(>}#gshcF-be#D8HB7+NCS}EI2TeYBv&C=_3a~2D{lx{6(MA`Md~S11ca;~ z;9NO0xLNt~p)}Ecg^(4E_7=suiBunHGEyz1&YTQFR(GVoBXtnTsd?YemPboXghzL_}&#v9x`0m_-MST|Bdc*Q?-M$^2 zkG6}PwYb_RuGJen$M*<2vR05-6(^rpNUS@8#Bv$@PzYM< z$4nH0)|rbCv>HjBe}6%MO4~;Xvt`KTGlKTmz0TzN{YVfV6NSa`j=TYf7S?|950`Lw zOs*oEiTuSGk-N%=ZbGW?gj5mAJy{C8Vz`nfy%Mj8G)lS!&!PpTj0?(|d`y#mMqijI3QSvi2)R)*!{m8lxCl7ZoGxsbXZ6 zHU=Z>!ha1TYw$~AWPO=~k@XZt)^x?lI-(d^J}|QOD@N8J#mE|?7+Dt;BWt2!WF7wb z_QgJXK4%h2Bp+)vO?8@)+id_S zRREwQJ?D`f@UAkYkJ|XYrzm3CbR9*V`SzkBqh-xLAk++CSURqu`XvpyYF1J4vFOr1 zZDTS_-G;hmu6!)%9(~sRXd-y5b#?THWTozi@)!~!fTY)jmIM#+T07};tAbAA1HhzP zX8zrWCf>95KV0R5XLCKbA6hvj0w&g!_3Ce=`l~2eQ=&NLKA`s{(oK)&2Nb51$-uhz z=I54L z6x}LNbWZO|gZps2G`RbwLcr4CCrgD*k?&eF(4LhMb-J{`t@3|chSwZmw2xfdL~ak4 z`J9W)=RB@K-`XbgImK(_k5cC8u+tdu})848r$p4^f3Wz)>de9y?uAHtJm9iFiTrrq4B`S%PO=zcll7L z4d9#|8w8hQBDkDd;Bq<&F2_%hNwKE|nY2UzJ)Px4xdHnRoU{4>E)z0kdh#Km^sa98 z?zjkE%I<;Xv3Q%1!8^i_+of_?^`9J;wn9~h6*;W>9%^-^a`*%uR4QnyG!RkR6s)Df zWO~p?{x=9j6jzx5kV{i&@@Dz;BmdhYC4Kg~x-amsI__OM%;%^&Ji*~5b$F7)+v@NX zhfmbuX*qnL?tqK8;Y{Xe=Jg-!B_=8eMqyDB; z4xen6XD}I9m%2C)BP$b22RLil1A&%#ua#=EmTKDvw5+>SNgW7SKJbu^0#0%RoU{pW zQuSpI`i~3W6e)*p9n6HH6$(Ym0%}%CIYAQj-d0Y~Me5X%I{n9;ZMWY!4>_s7Nap;% zvwYwM=q8*YU4$&4S?2%&8K01)uK1D&S@4evi;$(zTK~MzWn6f3cx7{?@!f@f2Eh(^ z*(yFz>u*b?O#*UO)_1a?tj5B@s!qK(QoyVPfLT=bKq~u7DtkPYokV4qifO&+mq4A( zy_^1oEI3-${Pt3OM^9eX#(7ntZj}UARaY2X1;t>k0^(&2#0#$11n$6Ck~u%13|9o- z<;SnkQ#!ci#{>PoGnYJGcgYZHcC2*IsDWEQY+un{c3V1Lv1ioqyC1e6l`L!6;c8>j z!1k6af5sR1ws@x|DenU-(zdKf4`oF8cf zN4|2d&t>cK#%x_~x?Jw-W08JCYK8Q7q)$Y$Tq9C{9TNFO<50m++Pi`bRQZ5gaW)OY*|ZPGeGrcOWWqFVs4$Jq zglY7rFWr_ArXjHc0|~uUp_Mu}dDiSpngPesovmWDv<*^&M&s4eTyX-9uG&aNyqRG3 z(@R8n{Xl-PO$gl(b>LRru@oft3p)Wg(fA zh3lj&9PbvhR9IZ9jqjt42kC6%n)Kd9zT0x!KTmFTqa>pX4l5(e+gA`%pF^7}t!PvF z9zG;pM6c+q%tBhZDw(lb_R()OC12&wDw4XQ|KU^ZToq0FN`86#67WHMOF!D*68dyY z10$ITjB(?O`EPixQVP%Kz0KJL()qWr36n>N?~f8BWyxpaFg;YZFCYg$1#;L+&5z4k z^BMaXD$j8aYzMzD-+-%gkcXP_V~QsHDX-HPLT)&}aTj-Q=(%1fxM>_$v`{&PdkBH9 zE>8QrgYYCMR(5rtNKL|z^kY2rdyAvDIEvyZilbp14dbZpi7EXWmDe4G$qQ?E7Dp6u z)wk(+UwltML(f%)j-7ORJvS57Z_7dbN)a_*lb_w0n_&7lEKli7lH@47L&X9N?7@sF z*NvZ5df+giI61RbHju5-gKU-X^3s|emoQhWNA_WN`tn-xo>}&9cFg$yA{#@V>T~$#rd7JZMXXb7&lQNoQ^kj`; znk#0;E!8C((1L-}siCy0AeHD#UwR_}vuGUyXP0aPr|kT#ICXkus|fZD<&^*(lj92B~o4NCH~2!zihTeWL&26cWmF z%js70_RV4esPystGQ1n(&g?qnh45T&;q#ip_Z!&#)HESrlCQ)gT?|}okq@@X#OOw;B;Q%Y3 zul(}fpm?h*6tCWg1x@77LE%+d<+9jl$cE%EmO`$*-+7*>Tv?KAw266@o~6zt2|1^Q zEGeIqCFOClq@2ehqhAM>x6YCK8AI-;Utjw1NOC{Blj^&IRNv+*tD98cMAkP|QsFsM z=4%YuTB#G2v@Hj~gnXyl{*W2Qtr2XwD^Dg1EmV`=roaA$i(57#x}_>Pp))(1C}KlpAP?JUY2>`ZnO8L09w7?G{#48P z9zvV7rbF$?=((EFvo)jVB!6jZe=YD8LdPmP)YcF>Ch0`zYj`Zug>QCG=_oIP#$lux zxfxcn8a_gsGF7yxUVx|cJ&YkIT>s>5Y3Rf9s>0y27VUN+nh6gVYqK3FUqgM)`i2`Kg?YB6_m>=)R6*V;8ybqA_?CRJUDp1l@5 zyYg&cLKcEmlc$$NFB_wCK}+droN)U5O&9}9v92MZR=QccYKOl7wi~;_c4H@XI_NY6 zB2#hWTt&%u0+ETY7@J__kegO0K3Olla?LO0L!QkEqguHUBtc= z{f&tXUy7D}@nTXo5HDkeQKGyORCc#AMih+wU7{}b5Opz{g~cl@EXFcX4uFwyqefP{ zNUb*Q>`v9@>K)XqDGR7Y;;FPe2zTkmuh5OhGJ+MIA+j^)=`$?_>#!WIWU|iIkNjZVNX8x!hDtm)?ijb`T_7YogwsA`R+F zZ3HRLU=tgKY*HJA=zW-vT_j6T;=^H1b%lX5@3<;=wFcz|-)=K}J9iaV)lfQIkMqo% z74`c(i(Z>>54$m4%ZS(FRmcG<1*;upfGdVJrl(_s9-=VOy++-&Fq>C}pKYj3!M4c$ z83?Pq7oMCLfLZ&9NE9E!?^@LFCRE};YWquSdpxzBL~SRk+J2KYtJ|J@X3;CALRKSK z`4C>n@A5xmoA4GFQXH6m;at;LP;$^a|3IRnDr!O2b4-&ReVLFQXQ1xN=7BX`q*5K- z5!qPohFZ*4n>Q5F#vpT0);z{lc&cv($fCNY?@tO~oQ(tOJjKIFJ7fvn)%U ziw?5ZB)bjT=p0RT0KO^g#CcCJ`Cd+J^e$qf)&A=J=`;(QyE`oB2JJ5+(;*QnuK zY9|r}ubN0-`iQ>tE`8~hM$~hz`6gA;U@`}qM2euTX)!nJ-M?XDp3F@jGs4LOOy^Su#&-+aMY@?I;y&+Y4c0Ty&&pvJE z%xY;~cj(a`WsWb~5>mn;@|Jhox#e1z|8uB+k1|)5Ee7mZu%RF4>8d9QlWP~L~r}?w&93Kyz?OG{qSuLc)zor~;91<*AL$p$82PoE5 zq@yk(B`p#uR-|%GMDj;EhZI988|7#k*_=L8 z+eEIZCZ*mI>2^1f0+CjTG|Q@V>U%4`A1s;|+7gOcO0k9%>xeX;VsDCcw5v!qNV6za zPb7b&IN#YJX$KQc@2xfQo%XiHKdMf;IraO0h9#7+{bo_k`9b|6ZEj9o_MV3jj=tTo z)?~=1KHUYMaBRk<=>vu&f<4-?&ctd@X#p{G{VUF4K^2n)9`!8io^9tmyKUqrix*FG ztN`+Z9}4Q~7f@H<3+ieq53UCzzHn`Lv^-?NQaOfAhky7DN-q5Ri%MdwMXhDQb(lfNS%>-bFRfT z5480IbFx_ISCQ)lh&8K$0I~c5Vud4Z5UE^4k!Cx0unUVgBh;9U4pORN#dz;cNL!FL zi&UeKakw7`V zA0K$o>1s8BTMg+cIF+)XIL>sa<2wt=N;sU2_9FKe`8D~VkTNbp6*&XfW+%jv#sbQ5 z`K)r?FiVYOfz*XkkVpb4WejQN{J7bcWhS*2=oL?_6aI%}L9JezK zOiJMvO5wb%xXS!LM*rO88hL{ zxfv9cnNUzFK|!fiUaIt+(<|<{4mH2IzkTF()5k;J*nVi*RU4rhwcS=j;5VOtpy*b| z6y54~ilj_XFsuU#hV{?y971_IK0GUPo?IDzgnrUOz6cJ+oS)j6FY1t9{c(bI=sUbE zb9iQN$}>9#$H?x5Bv;N=m2*M8vE$9lU;4R`#|gzPvf^HW=lIl<+YjS+8z6=8Md>ew zhVi?7Iai+2#0mX(dt7TP4XX?7EkSy(NrS)esJH(gSLB;lUmIQXnCmvvx99pqexT@9 zE{bjytzcM}6bx&Of?>VmmFju4yPT#DJS%T_R`Kwx`ka;?eLWnW3aMQe4YzTjvtK$x z-jXJbaaNjL%o^}lF4Evm&65VV z3aZ>g>hyD|#=2+c54X9|QCh5@H2g1sOD>WBcjkli0*6-0huQ$J=n@o7E1BAt`J9W) z=LTF`k|0-Tv_Y<5#tn4hdGq#paZg1oz0DP6x^rYKZ_pL4Xe{YZ-ZLkzSecuUNzsv_ zmZrMOv}x5$sX}OI{b!1I}U@vJSosr zon77R?yMJ_(tf1;P*WRBBqFk58m$y6iN!XUUF|J`8MySIT93E1KD>?jC z9j@lE)N(01h0Cdnci~LXrnDu!P*Z`9!x z4$p8HeBJ=mRoH{xf-Fi)>$AcY`cZ^bo0(MGK9E!jWi*?e>XfRsmO3rxo9bq6#aQrU{9HCktL2W55^ZdoAQG7GR&UGk7#2I>m3*4Yrb#T0I_6}Q;an39QH@gz54 z5A4g7o6u8Q_TcH#@{Zq1!b(Fwr!~H@vRZvilK9_~B>qqddu?{YqG!}7345JO!pg~z z9#IkYUb1Sf*{iG;dzCqo>KkCg+VlXth}%g{8cK3f+>9PkU)b;F-%0#iE1q7~`3{i` ze1A?<*lZ_pD>OVMJ02WIN*1YnE0LU$&LKUZ6p}yE6{JV5QmVDM6=t83w9{Yh#UJsP zNVAbPAtfO_rBoY{jv}QXrBVv%HqtYsbV{`qsr+e?N;!yBLVO#uks2bIBAJL(zMV+U zrzLs38VMDpPe`eD_HtiHwUEk+RKC4Pvyti}m7^5WCL|lA3Y6*~(orM_q>7Y6x{c(7 zRGCs8MJk^lQb(j$8%wE<5(CvRK~gweN#Up}Qh8F$oss$>Rd1{|Bn;K*&CeOAlTlb| zd))IN=bSq*cv0E0sXG$??H>@3dzKi zw!jUOnQ>ku66~p$;e}|y^HzaMn$5$FCVi$h7hFP1+KhLvKQVaQh`}2~4BkFs@PdfJ zOIDPO>f$vL=th@aYe(qqY?4@k{zMJra3u#xzf%1NJWg-pf-zbW2UjfWy#V<^A4`0E z3cX^hELRM3U+hP^M9>V`lTZJ{R5yt&&fL__u;lJR61Jn|=DSYx<8h)N!_1^^?VF10 z*l!T7<9&p>Iu3tm7yZ^L+ISdk++KGZm%;l2gSR*oAFRJ%P7Gd-ZDq4>ODLc(m8-Fj zv<>|a)1oBjq^U%Ay?B_Gu(nh>`5-dO^*>Z;GdeO?@(a^4;x6U09iF;JM_tkx3pqyW z>M!yPTPTVZ&gBs*1930eD&xpjxkK-Mf!=+K%2uJ~V=840)R8z^w?>-?me-)po+l%! z?knFYs%+6p^yx;ERG3qNSjGw4;&Zg{^Ln-A@ObcyFDv ztDZ@_Z*L^;Y&EK9oe5W7sXPAT%QJsiW75oFf?J=%{a5yX5H( zD867u>I1z5GcJ|n(t-Y<17X=682?S!B=N0t^!!8?+3(~}Ab(Qi986Mlyaok`!4nIk zn2{CDOP87bk)4tCI~AoB63d4yLvJx7OGc4Ad0QG{RW_SOhnZ8@Ql`bC7b9!FRBc&? zSII@o2-AY5qseE=JyB88VTu`9(wY2EF|umQ!Uyv!O!Imr82S-h_}?**P9Q;j4YX17?R|H{ZOb$9!1H>V(KIy+CI@y%2Ec`WFix>aK`tK zr^D=7%qjLdBC2@K=dQ&4QNBwoy%c}Z4@vV#n;N|?)5Wma#fIg`s5b1^x! zZ4JqB+2~$P>w))>#%9mc&%xzhOeIBD}yVJCzY1&1M#>zZBZ_n@4 zc#&|hcII{Zmy_s`FijfG;;u15RO!RILtoY%`m*lOm+rJLKHR=6P4va9*OzTJ`eGQV z6vZ=H>pOSDNQ@`(Q7q<7$dTi+iid5Sq>mghF5}xLnkyR3(bAo?z`a`jhSqeblR#_y zRZZGjvO;V0#ow?2e?w)~n{KN7wX;f$lT|7vM;dpc)=a5e%pU(vJ#})yS*y&tm5F_H z)NzCGSQ#j-rvRe%!|`1zPRcd&cdq2bQSQ%8UR3;5Nd=7eHgEfVe*T`Tz zmSm3$N~<-{FSV@)x1xB)I6yn-Dz>r3i8WDc@IFe(OPzq3c}j0bKuO07gcLt zzZ0mV*;jNG-FPc1`~Q}0LXTp^V6d(+;;vs$`u!^A$xbXh1l5pwPPV}&^`I7Fm?!&T z6`f*@X_Z=TI;k~Hg1E2SgOE{JXPl)b;%qNJx(WSCCcDa5l4cjey^IT^xd~%QS&apu zc*zc~TK2;WOI>3mw6Uj-@V7TEc=(vFdTeVw*6Dt8>+(+bFNVK$|4>|b-4la^9OW_B zddiBb6<0mBv-Whl9~XY}-l1dRHyMy~xPrUITwI#5f}CT}&OSSSxL(YfRQ3ch7>|`f z)f%KXJ2)pTI2%CNU_6$uqH1ZIM0xpzG)7Qnq5cxP@RaQ$|6>;!h{wvHYUN`W4S$&G zk{_P^c?av)NnpzE{UC+MG?Xsg&rR{Lh-7zT6=XBpY`C-NwS{dqJRW4Y5G2T}rp{R# zt*0TaM|&HQ+@yTNwF=d@!hLD3=ug*TfVZPCnOX(0DLlFRP_>O9o0jDaWq(~d-z!wg z^L>mIrQKg^6=XcUdlIW4iPfp{Mp!`o>D{-|yJu`^c#&6NtD7Db4%x63mlAcZQr`{;OZ0m@b=R_{09Y)+&Cl3zMg%OrDzHLGaS) zFOqd*iKjY-KQ_l`8iYS7s|Ea@!kqUac?(+|Id282-PllSHz&?Y2jQv^q)vDo|3x5{t_9EAs7@41nl&AUk@sdd z&YmLXJJ+T^tCM~sIDK&XqcLfx2B$xbJ@x27+P4Q%=chmUG41yQ&+a@5o{;+F!JWbB zrw-UYeH45>J^hcWEl;Kk{py>;ZGt_w?0I&h=Zc@x1dru=NAOt7MkEU!%ViV=B7Tqp zNipd+dVZGvuS)-}VY~a))=e%n|2ppQm6DUZl19y#|Jm1#@4dhMi|VbLSegC&%aDNA zCwa{oJySSX7WW35Z{J%=_*gAPA7=(1ONyUwCB^re{>yfWwaFmYYw>@3&32#Zr?&4~ zn|Qk>#!od58D}^3h{H)>#7})aWUSpQae?8chiqT9HW};sb^O6vA!F>? z#_e2Tdd~J|E0giAyW$U8gp9PC8ke%%^jF*MRwff%H^v{V9WvbRV4TBp(-hljRwh$i zSH>T#6XHAeUR+>Ut!K8qt;z%FOK5UdBl58bRn;A8C+K9=445%t5)t!pYEtb2g4 z_6rDW4Ir#P;aEY-`T|klV^CNIQ_=V-1Iobq#4R5`3&%NG0K8 zeS@@}QZ^?#58l??Y~~tZOD+eP?l-jRj)y68Kn($o2Ct+lS0*)w)ij(C@)`q;NlqTGf-gHiBfz6-~f+ zOofwG%Rt1G0#Pk17$++ZPS!ld$*KS+>x|-L-GY-fM{%+iDo$2c#mS0LoUAj7lXVMD z)*Qvj>O28X)|>m`Wa(gA=_lz2nkuI_S^9yj^eW~GjSlVFRDrSHR$#0~3XHWcxa7`mYq${S#%3hBfjm-2_c>ps`S{!CF4$X zTtn3$SM10upkP+r1ld&-?5xN3Q!{QuwTCwa1(rxVZ_b71LI=x~p0sK!|9H|){_X~t zG`f}4b}d0&UF#~Ht2N+3KDf#UGcZYKntrxiH!$f?h>Xk(?F*-@x!@35F?g-J&HHgb zMpc&)p^Ja_p^3NptG|Bg?+5DdO#bo|#&c^cxiwIIg(*4m%PVnuli)T3ZSDis%hW!W zOa4}L5-hw$+&~q1=Uiahb>j^za&}e^es2iBtyI_)`Moly3jI*#R6@$4#U%o$i&+mT zs|%zo=2Vp!UTN+MlH~_3%U)guFKXXeYM)W}3LkpNhsyFQERzrQzDpTe^H>nKdMMswC2ya0e*BWkDv+nRK(H>t|&93p|QMFqq(B7q#%A{ZLT znLM3hniONRuEOB!?R%J|Evry^;D=!qEC)VrZq{(`y`fFc1^zs$i9_Je+hR|jnLa=E zm5%$nkBr~3O1L|ffMh{iswyxfQ$7IUsURP`1ij?Vf2N*)>N0BV201D#vKF4H{*JF8 zC-oh?BmB7CUzW$>ZO*F05>|59_n)ZcI6SKkUsdXRsOEB*g^xA=QvI+8eFRZ8$UnsU zf{OsFCIH`Rng=^;4_}EEuGZwuV7iWZmlgt*tNQ|v$m1NIQHLiuyrvFMa`>k@JjG$j z?ow6}y41zj$(d54M()BzN1hR zm8uSZR_bWfTXMMN0H;)hE-tQkUEIoK=w0f@0C%;{Qs^U(;NXqjtpubL1jXz#sl%(V zlh#xa>Q!eUCT$LflvNs1mNTTRX&%9DaU1N;%l{Y31xE9M!f=7A11IVvsGzH0CA>ELHHGEU>LNr4lq)vK(BxptDlzGl60$;#HFkQtt!XLCRW$ zSRGOpm7S<6djyqzk;>jm{bfM1bT;?;!uh%dY^(*GuX&)q-poUqK&e%fvZfS(Fk?x6 zb>)iY+-ezaVw&89(WK5?aUoaad71OG^_2c`=TXz@V~>c(S8q<%AX&rIaI(Vfa5Ugu z48Xg1qaSOe8(AY&G1eOtCkwVqfMUCx%Ni#naRIaZWWSwX!g|?P50daIw^g!rSQyd` zqzNJ|LE4CP2Wg^6=aFKO{wODOsMZp{blCcH--dscI_KJKwfG}$R_$f)Hd*pFcJvhY z%_9o6kwU*wC{+sWqR?Xs1xuknDU?p3wo<6HWSuuGA)bw9pG%>?Rg*%~q>x=NDO6Sn z1?AgGAxlD{$}bm(&qop^b@+3Ml4^!j3F%{zO0N;A6H*nVPekg3fTdZKCAtosf4W9ByloGwDYmNolRSDHhB>@5-UlBvWp?%wXyD0Z8R>XON7_%BD^*; z(Yz32ss0N#5Y$9TW$r0hw34or4YiA5uKtIBti&WgKB)3f^>#MNuBNGkdv#%7()sL5 zTD!E=yOXn2c960B5z@Ymxq+bOax1CMmz1^9N$p5@l$PX1OWI6=P=AtDwvqccsG`)u zJ~p=s8YfLI`L@IX{0EYyH=jeYRT@D%tSVk9txkNO^ee^8ENuDJn5tDW7O=YmVGZn;Zmus0|&8-p#F!!h9#`@ zkvOogNUT?pQgE!Ey8lO#ESNv5$lmgAHSKN4VT{TWQ8^<7nN8t-ltgY!W*8P%(azyF z;@0LFAy>aMPofLf>EZQTNl;D;0$-aAe;DoAdmuBXz091(;a$FicliP}zlECj(5m?i zNS0Q@((_OPy0856Kq^wI5OO!@FbzEylY(7*u`xIC83`oDk}SC5Os+`2@i=b6P-&qr z+^Y(-IO&4@bY_S-5v0Y|g({tJFHyG-nLQ;jdrCBuHXfsBc!PNbz9KGbG65b>2^@K- zC|Q$rPTWX4I!ChQ1MWN*xK%Oliie|e*$s_)D&}3iP-6McBF@an>-2fr9L2n=isbPW zW~5Xx@5-n_QZLgo(PVcIq+>OcA+)FwSf!UwPVEzYQ*G(4rb#WCCVfCM*dK(rUM0kJ zA8DRJU^0>wCgX<$$sW9`XST}g#k{M$=E_+ZR)!oF^R7Cc&?|jK+awa&5RtVFv5B1t zzN`X(NY*zSZDJ`ex6}-ig{O3hbp%tucVM--j$d_#k{NT46)i-7KJW} z10#R7ZZYp_qkCc5GsV2CV&0VkQWbGRM=|fpNcM@wBKm>u+87&)6!WeG6s5`cF6Ld~ z5h&(e=u^i2sGZIl^mRm{68=3Tj| zpf5LqzBGr$yeqY-VKMJ&ZGjP3dAT`u^2DnlvO@`vfis4C1- z#k{NYvn4CUvo{YluYD^ErBE^Ns+f0W305^75^ z?<#Wp&Xi)_RWa|%b*OnU?+V;bIWRcD#4Le2WrJcB^RBYMt#U%FY>IhTf^p1B&MM|z zWwNs}*;d88t76_&(IK#k8g8Wnr&Y|mD&}1k^R9|{SH-+5V<52fgj?yLViohQig{PN zig{P000G^|xgUChvEWvjL0FnA{!T4P7q( ze|+95)}#N5PN%B=yW)>CHjMdkUd!Dz+_BvVoSvFLucS6qH-BMVW;SB}&;aHkK=LL8f;LlbohFW`= zM){(}jA}q-OKd5K9i(eNc1&~w&lSzX$!1eUB+8~JBMu6AbOb>5ivZcT0%Z4kQ))O# zc>8`?Dc#~!dUw~_aYy70cuohuF+<*f59AHdwXM4pe(?X=dlR^xv+sW#4Q3=}Bz=mq zwV>2!quth|m8d9WKC~#RQCW(F8BC!lrQKR88bg+;$u^dx#ZsAxge)mB$Xe9zJYS7> zz3bh(_dC7c^Zoq)&EqjIub!{-zW2WFd7X3bx#!$-aniU1sw2_X5 z7~MkaRfI%-Mn(g$4Nt>ogG#TigRRYOPX7;M5{@30%T)vB3p07UhPEG%h%B zBWf72TP|-k`C;@S+Qj&Bs8~f}taj6*bebIO4q}dJ|I3lXT{t^Gh?neVnF!6E;b1{+ z!D}OR{cU_>0!*334hRWf;=zD(iLajr8H&y1$SliTODhRsVn@+e$%AH0hT=0CG#_Y#7g8`FF z28=3=;Z+GZ+=9!|8+ULP2`fLAKMWs0QLaW#!O?uD%PJ1BS9E)`m+JhOL?t!u4{vEX zaWk(DQ7O*$R(9BI9?tAL=lS*x&h{{9`+yY^%lhe0N-)~4C6N>-ma`6D@FX6+$5A?J z=ZN)A!Ng#*>s5aq-E%~lPT6s>!&jk(=SOe?gA+c09DD!~Y#+eB;=gyaBJXsV3FGep zU%(}rX)&35*^~LUCjoB`f$)i^eXk#z;gx&>rC2C}XNSzioUUkuG&tU-!CZD^iBii9Q`t3OTL zm?Ko$ljw_s2S!-XzjZts->0eUD&BdTObkB^o|qSd1C}_|i1WnhDkXK#z(jf~{lFI* zcOd=1035sme(%IFNvAML^A99`*9KW8*%tN$m;VHfCur{AWF3RDe~h8_?6v2xBme*Y z_Iuto>GMg&HMiHWygJ*|g^Y1hh&~@leV*Tk`1J-1{&X~*977dNI-Aa`qM^4Sh}b(8 z11h9lgvb@ZYy4J}{wSs2R%4>9&QN79ZT;C+vU$X^YQ*lbwYzW21W z!h}3fqp*@=HA}}u2evBt2`& zGQ0+o62O$4YzWvb{;*=^VJ^P|5Ii$v6J5rse<_3by8Uc>sL@0sn@9rYkJdu7B@gq+hQC|ptV5V){xCZjL#>Ie6sA#IXU5J2E{0JMllKZ|j=C^s zj;27~Z6NOlAnykt@3xTlgIEW#Ga|m5MEf7GwSL`nJdeeK$Y%O3;Qrvla{0FseRk;S zCVbjA5O+6-yEJ~tN4l+{SbuW+4w8pSFh_Y~ahh4Ia#O)93R5baKX@GH4=!fT9~^** z@n|r8HcVhGX!?dUT<(}H-@*v5)pX_t{hVZkmUGMG#d7U%pbElh`Y&YrOyc0q5EjJ2 zX5a)}ucEU*2Xj=dEzBaCFWaUj-63KYt6Q#i48>~4B+Qa~qU>waz|Y;7u}#8^Z4zc| z8!=<+1E#bY&nCtvmGGn9ST$Opscm{V1VhE);6!uM^R^m{X#!i++k>R5yae3PZYo_( z?4s2+O3`c%BM<0V_>_9mkZKM?2j3+$aS%PF^5xtOVDXwC^Xm zI|y0)W{CAUItcYJeDuNaA%aOVT%J0@f`k_U#%`xDYpaZzfaMBiq9Fk2N849B>+jcp z_`Ci|eO+Gt`zHa0Z++{Z7=E}_|L#!z(>rxJr|asb9y(oD^JHHAmD6Kt-v&IYum4+I zH^2UU!Tdii7zWrMJn^A?YRtX5>irj-&(Ytx$Lh+bZc5Oq|KK|2`kS4Gqu)poZJA-L z%t52gsT)H!9TR)LWXy?g3{>7|oz1#%*ZJLVvr4)RmJFMH@BV!6fve_h_8_7nndkGQ z4rhEZSn_}_;Y%e~%{lmN1L6A5mmJRM{ll1WMG*({vg|MaGbXe5&tsM-ia44VXRnb8 zTdKC^qDEZrq%ji|MHZXqWv>|+=B3sp%O|$?`7z%pig=ly%|0_I%u{WA*3p>Wg=6k1 zh%7TdmVHJhY_Zy!tXI*!AB;JyAmZ1VDvPgFS-pM6D<3|XJojh$2r-$j&6H>BeD5`T zpNMnd_5gE{kz=|<$xrX5CbMtfmyV`WOr$Oy-5NS^Yw}R}gdqi!OoJvQ{=9wrkLKbd zM}8SKYPzh?8Raq8x~5GI&EB^y)KSfSpInsrpphmDuOEwM?~`3MG^%ics$7`gPoucqM2}C|1QX!&C>m9ue<0kbi3^Bag_4T@iI=dW}nD#7O zboKEXzioYGruD5Y==%D%Q8Lp)j$VDMSGeOy#hM!Xp)%i^$wd|JRi*;Au6Ic5?cege@nA{u5&L`EPQ zK}0f?UPocy7azLC*$vBfoQ`K^^ek{BJ=4Uq{Zzm!6tIg5m|^V}nk^R|?Wksvpb%wl zoou2o!-gP7Kyv}j0%S|jK0xk(<^Y;W&;vmJfW8Mb3uQ$Rv?ZbR@slFwKwWyv^QtRi zIAxQ@~p67km;xDk+1gjG~ z=P|*iJ#(3qG18&gR0Y~Jl#&p+BFBXEsxH~e+gK11%h-b|0+2kYgaNJ6vsE5bR(*JW zAetf{N=cFEd(?=Sq84?rS+W}>1nO9#gyHm>73d6|Rm*>zHQ$&jy}pf_;DfqkvK^(( z+JtUT{`;FTX0hPGMC$CBI^Re9MnZKyu1}==CkZ^s70Eykw1&RoeM*dhUU*V?TWzJ?ZN(2alnnCFzfS z^O7{TIGx*>Bw<$aVyxSRe#>jN*%!=ORuj%#qnK+PbKQ+AzRNg#mk{J)eB&Jn^+EAJ zQt=PZ+?gtArUy}I#GnGS1qR8Zv*pl$$<+0ssHYz>!VCgv0=7UL1wj;s_l3&Po{%`W zU{-!830=Gd37wt@E{jOqR%ns9y;xj9;wD83eZDbqcO@zGFV#LqUi9KTx{igyFQ5

kS`GoFM7&XrhVasl4?;Djy<6*Q#XZt&dju z5G^V;_g$pu_`+M~Ba}B$hNUBWMcu;m=T3_m^myIP2U8>q6%;deX=xX9KbE~-CCTC! zBI)<5UqG_OGo)kMMZ|#w$K#JZ^vC2IJ8sHFIaQiPgxM*acGQk?s$p)=;I@}J(6hLe zW^Vt$?I`B<9NoS)b`Q<1*{fyZ{Lv~#F3rI$%<+a9L4L^=p?0drOw^tv(6f_;3fTuy z%j@Y)iE3==uTw?z%#$c{e4-8xNi&bk?xmKqow<$1?NR177Pp1WZ9HyYF}J(u_6gGh zRK6Ou3`U*o&Bsc0Qq03xR#3)@gTgnvB>rrj+|>`+7Bhf&`c-4@1--cWed0rHmwSz+1&&?sn!y^i5*PxL0;}p`a$pmgp)!7|t8PGH`%li^m zy0;=SYd7O^KxEd&UT`^d#YHo2+7g$Apt*|G@S#mt!)cK((1q4C?@LWnm+++^E1P&a z<0J}DIUqlR!T}`%dID%AK}CSl0sSpyr7p4RyFzn`o#b%JcA*8sYC!%3*#IgA^cK)+ zg2Dk+0ICHPKu{5&_kijFtwCA42>NOvK_b!wtwmXYqyY5H$f(V!~v}*$Oe!dAW1+Q2nq+}3TPmpjVKF{FQCDIenwe1W-$=Z z@Mvm8pfi=VM~eDuAw^&+0>ZI|;ee6>DMg#4ohH8l#|;em2ouPM$Kfn3S1U122E=of za`!jM!{1~Ef0N|(D$k;z2!vd!AmnlmLN4bZxG+GDAD09LQN)9UrY&xdSL zmITUzhteJ%N})k;CEmmf3FCAQF}x$I#$|YI89&CfUn z>X0{)0=f)%4zVTTIut$}3^xYDLlA~1i!eN)IVJwT?SUYF4k?u84h|+j%Lltvsz*U< z+CXa_fJb*G)ay)mbPvI!>wp-%%!chM6w~FyIZQ*6;sVm4bHzyBpOL&%(8ylz9j>(rAcG zX}W7DU!0iY0N*|$;QJD9dm~n-w>B=!9>m@7=ra)d!e$2ttJO;zmHEx?}uk8G-egn>J8ryLNlvhkQgswL6TewI8-Ou&FWDsUdd!gyp?)=S~n7Cz>v zRaG!sW(#>`h^IiBKSkkCQC;{jUiD}(n8#fjIr_%f|UnZh?p!yOb;8oeUB1Ls(&UC zOFKuSF7|cHVMCw{EMrzcbBmdBHTE#!a|lKJS1{Xdm60%uMq<7Off)f!${xfdsFMZR zH+j>h-{$+i1qk6S=b}bQ%+5LN`|faPt@FG9+Dfhu{^ip+SssV!(C;vWmV?`WgWILx zb}6`>35Du=!e`>KJ-SWTnOISmEt$QAwh;RK4Hf>0+wu4VlXJW&V+;w$4&h+=Q1&Ut zG}#8zg!kLVE!-S-b@MVuu1fu9B2BwCf|y+!m#~3@=i9V-*v8)Kz6B0;5v^3w)^4_- zSJqIv2}9`s45iAwh`)B*>1#+El2@mdnlu87PRdwxvcsZN+CogNTHCr35RlBi;#C48 zI2d~wm>u0!uwoiFd7~F;&xlbV_Ka-j>y|frh^Y=n$|;yE*jrC3Q)spcR{WS!y(&+zSLFt?S7kPM5961Np=4X@ zw8C~!Hl`}^c>8@X$F|B z$dql3<;`R)Z_dD|J_E~}`!Pqi#PHkU`#U)7+z=Kt8ZX3kdj)J&!B7Q}Xdh+YyrX`-)oaV7IL!J}B{p_zLDm;T z){7zQX^?dnM%EP|>xt0p7Fd2B$Yj*wEbEvDXyWz6urAL>>MQ*47=9?MJXeLR8nF=G z4zEXh%o)5OtGcE5i;sg=`#LHOUMMPAwb=wOI9dgH?|zI1q|= zfZvB6|Kw)mkBPEBCd###D8IpCb`_Q~8Dj_{%FXCV;wi)L|A1)%HPmkZNNYc&;3}nP zs5Au>-^>}pL_8%j#tHg7woL~DWqoz!IF#zaNMbXBqcm!XS{p0M-k7tMLy6}@iN`{T z$AYbbbE??ml?ULJxq46pLM33|2)E*I;)NJ@$rda)EmXn;$re+m(TuGEbvhgB^aKK{ zJlF!OnDwk%Jg<7}a5K8a#&CVCdaT48eL4DFz^)SZ;{T-$lRc~Ui;@8x!|b=zPFquH6+Kp1gwe^Q z0OsA2n2Q0YBmFDFuu59V_bcdduC2(h9?v0Pt@k1;cHxWjIk9Zs!9lQX!GDvqKPew9(jB$%4mNca zARlal_W-s8xeFdL*`}Ceygc7>%lOMwz)B0u*eNhbYT3L8RV;{-di6p$R|+D#c)w*o zV};$?X)CO%Y9`uaLvxVT= zBPMwj0x8oFNa?}^Ql>!OZ6NP9koNK-+MG zu+ShET|AGQJSccU&CT6!ksjE_Qr!4X>nK{!dsXtAIDsI zF*8?=0Mk>!^ntjTQD$q~LdF7ihru+ksRa!E+-PUC$FecP_}yOT3A&4AZSYsp|3F9= zlfo*bsl$e)S``s+(=;4C3=36-oL%vsgt~kyCTBx2OBP{*uSQ_THjM!>W7~}x+a%1` zdV(pi-#gTj>7eMW)~pY1#d9)9@Q%%F6oEh-0=5*GlvIpqg7qcsu_SWd9^l5Hrqado z7KJ*Wri8sbFL;0$leRf(RCxLW6h0D@w&|F(3C%`<(PfJsO$DVq`wxgXo}>Rj7W$Co$l&1H5F8}z zOuSfXFvaT%$6Yc(spd-ki-5Yf^{)f!AJu<&eR^l@hq}&uSDpE;I`dsovX#z!SDpE; zI`dt1=DX_5ch#BiN)RcqI`dsM$(_}h+p06)RcF4d7$l?;NLDOCC%58|POCHDRcF4d z&U{y$`K~(iT?sS=7H`R|I8b%wyCUa9XTB@)9yXjz*qQIDHQxp+`xFx(B~*XJGWcBB zLzb3x=DQNy7IOg{ufaLF6&#!t9a0q3SYv0tEBJsq^Idi3yW*busx#kJ!*PV2`L6iR zodtz!k0F)Arf=S$&U{xAeCz}fR&py2>9jOD^Ig%$F5Flt!EVin=2kq{NT|+yR}}r% z;Z_XT!O1@1V6t>H)S2&!GV%y3UW#_s3xC%}XTGb>d{;W1`L1T9CLuafFuTTkQBZhm z#dqM2jm~^mG*C)o2;`bh>+@|B-YggnRPEie(V6dxWU~^C<8z;Rhi=7SWwPplZ>-Io z9^Zkg?R^)W`L5iI)Uj>#^Rr?JCX>}V+OBo9%|uz9`L4jj&U{y$`K|<$rnfWS74NC9 zI`dt1=DX?`W2Q6TRcF2{+T9N)dJq=E+PQC>TT(1Oyc|qctoG!)s=c%Mwsx>`@lA({ zZ?RCNI z?DK!P1s}n1lm$~(1If~a2H|Kn4J?papb^dT^fDGQKZ&wvKk!jxo&9u3S?g&%%FUxc zTBR;TYVh(o*z%u_gtFeq=-~}^yTHz)6A)7yPC(@5JZTTr02I&F>mraGSxk+>Kk|@O zV`B)|@VrxW45BIafg?M2x(&AG9{@LQFe$T;QFeCI)5#hR9@GMNKOL>YI&!iEd%%%^ zzb^@86#daayo~L9(JR<#9*=V$nni?x6#|ADJuYCYP}62HTf>ETxX8X@IvwXaQfFL2 zHkEi}Q_({<6<=gism1|S)i|oE+zzZrL;7Ii*34sj)WO<5bWF+{j=A?gB~GHO!H3+8 z*tpF)fRM?N1@+b8*{}G>q}56iD<6y#0=9Sbp+f~20=BQ1a#AWns+t`?_w|$Bb{iB| z=LQa%nwb~aZR&?;aryXnk>dM`bB^xWYO|s&MBD0qpsM$tv*H1Hfdi&y<_2<1i$=Ly z{P{Xu1E(j_;Tl7YDM3{)Z5+SIoG>yGDYN=}A$Qf*y>#ZudK^A7;z3i=H#{W_1`+F6 zjmE@S><|^*A4Ts*nyg;k(TWk%C|}jYwP*#CL2KGBw4xhY@rkrUvt&&~y0HGHc;RU{ z1aUpGW{qG@8`(V>tzr&E9DyuapGey{S0&W>PJPnSUm%M(?1*Dxy7DcgbCI20iaDWh zBC-%pLe|Mi$P_*agDGFH&$a(E!Q`DDc20o11S-EHyudR@<@BT#6Wu=2Z!Ck>svTZ3qmNDJOsrAV7ea|F(S2YM4MLV^?X4(#19HhWoW_oXvV(A5k~T8Jd-Lf;=}=b- zZw?tgskr9vMOlJNm*tG&o7oiCt7w9hj+}$uNH-vW5&?~Tf9ANpJgdMsPighLI(6?B2c!p(%5-dBUW7&c7 zSCZ|t63o6!q6!6TiE)}EzZ;0f=`(1VEc*XPW(k-JnSIP*>xclLg+}%74eLVc-x$`v zz4M`VUi~5OomT?h1=Kw~UB9Eg#z+)Fxkr~xdA9X61@nJ-P0wbzRnxQYZUXkd81T{cg=&7E8^bQ%IG1(d zW{-EjMc(>yu;j{^yZ7h+puTF3vd7wxP1&i>mmE$PGf?^N1QAvCd3R#-thwt#HWkGY zo*`#C`pVYDD*U3#3iE)L**|FnK9Y) z@`S{|?fri;ml)Ys=lh7r$7}3{WjkJ45M>b27!W;}sFuDnf44|w*5Jo${3d9~Ogl6# zL8MZ1q0jh}mp1lE+W4_zjo+N`K1s&*k5|f8niczu_fOs0CsIDtywYj_6>w>yT9n81 zZRQHG)^cGZ6(y)qCPr#e%K*g_lnm%4pw)nOfocRn{Y(kk0B8@W0I2~A2DH!mU3Z50E>cIe=yo^Z<}Qpzi_ALRk?6ZAmD7{G`Y^P*>(#v-7GeV&t#S%(PgL zTwzw4c)0MDrf0z{x0*dCT$MHbi*9K|Y-lA_RyUci%@&U$#{X65GhX?y>*F=E<`-P= zTD@Y%J`v|Y87jM~VvSwd_`d#;^1(i5l$Y!wSe@WG#N9H}p1J)@6bfcZBdf#)v}tIR z`2yD|fL3+MR^G;fKxGfA2te|n5(czN&sKR%S@q%hfoKYS5Q&G0V;T`t)S@mjEvFAu z+Dwj`6DUV1bUKzOVK|jrfzHrbwfx6f^Np#}>)WUaKB!9uHMa@fp8WSWW6WZ~gNfAH zGfA#~yVf=Bd>nn=vc!)u_#=$|aG*b4B#ylvDQ^HqUI8O_7IZy){?sm!`GNW;)AKbV zI#XqJrpo%1Dr+WvB};y(STn1vDaf^0fNP@+g|oJjXHfusU* z|6nAg8P0)pJ$?<9UK@?Qpkp}I0Ucw9_pn8^;b@8AAc=q;R~z~Sbrj=m zwNULAR0}oG1X|tqDm_^JHC(gv_;Z68w{9 z6m01SwJQK3MZ7P~bS`?WGdD~;981$GGd-GCndxC#wc-Ye+l$4dl*@{*lenqVwCa2? zarX_W?Qa}w#%y^w2s(Z;G1LV*{wh5Wr{^9RbNADj+mk*3a~5$XJ_QRR9*n}BQ21rY zGEGh{df}z#pbI3?CILehs1aXK32GdR8ifVvp~k+baS}D+CB7*^LqiH^E>*spq}DFt z+Im&*q5DMx^470Y$;@3Jsd%XMV{Rp?0X{Ndg;DD*feufS%nU%7_Xzy9v%w z--byzMvPR)tp;vgncH!=O=fQOa9hFLj;GrjA*gOImGm)*N-{*9?2soaMpY+^sC6em zZcD8z1?6nC4lMvtPXCyLa%tvAvQ6o2ncJhdwPtRQuK~8KaN>A^P^o+rh`OCsXH7CARrqBeum5+YEfpE>?5I33-|+jK=RZk5qT_(o#_H`(OedE^ zp2*asB?`2t>3jXFaGx4cTGcG2A5>#udJ-0en_hLDM*(& zu45xyPJNoWoJ{pZ+!Cd)P@vQ$bz04S**hufG9Vp5R{^~u$W)&odq95ydIKszepe_e z>aIG46};O_R0hM{5~Be<22?}PWk4B#o&)*-Dno*90(u9i4pe|@0ChoxRTqk|G96El z^i_hs1k{b7%YbwMeGTXf3!<8UsHm$HDD@u%O7$SD7pqN})C*gKl3AfW*xSgKC z?Nrj5+lk^s{5iTIeBr5Rdc+#Jorw4&q}v$M9Rlf=g>>sdx_#kxlEJFIfKTxdVrbMS z9|UuDA;ql-aSJ->5{bqdjiNu=q&~h3pOX!IP6yy~nhBrNO!%A*!RO=vpHrqiSYgEY zobZ!McoNr;rx9)_ZA1k~kr=DM`PB4$(uRO8B@Tf?R3t(vJ@By&ggXXD0%Zsb>WLbm zH2feJ{~SLq49HyRvN~dO^d?a(4)3=(0xxYI4h3XR#cOhe9UWtilg~r!6%Eg&HQDM%i1wk(}A&|bCK*T+gKrYW=o?Dy}sr#1E zmu_!x#vnydv^}cv|%VxFG6Qy$5ku3Q{h$2$zAln4}FZ3Yyxu$HA2XHd)#6iL`)VUriZc9_b7>2HQVXWa(M=1!f+SwYG?rLX9;yC zZ5+&I2am*jZ6wYp6|#*YoPz`@F&4X3!tCClB?uw!-k@Ar^+~oq`ruzaq$v)e&A-DM zS`Kdi4Q~GpZkK}FnNX;{CwwLz+oKDO-1d%@{4JJLKIa2zG38)RR>#cY6=os&fCRXQ zqj~X(5)x9_v9N77Z5!bI){y4)#feg`7jk`RRL8A;5}4W4fs z>>^a&h9y+^X`_Ql8m&UMvgTxjp>z|5(g7Gsm9Ye2x79hoTxnDgSU&))S7s*35cD)Q zL1(RZQ4M78a6Fv$)4}e{h7uSP%u(!z$bO@~x5AbU31*81&$sQ}ze3X_jQ@0?dQp%m zv}He<5{$r?*ByUhH)(%NXglgUFajX5Y5G*ZyH zZs>&8AS^<-p_|*zY}L_J_GlM}G*&`@MnK`WVmxr&iOy^g90zsF)80>tXJ5g#WhDoE z-2uJ+3-tP2==I;B*MEm_FJtyBW?*%58CEx|hS8Lq6;uyiex6bDKV+MjTpWhAE=fVBQce26GH<%$KkW3yQqN} zXS?)eZRKcs$OyKDWuUWF z&A8lyK-T@Yh8CL7zhhV1L zTzm<&ww!l*lL6ojpMe^7nDc(i?k{L`A)J82233`!b+g;>CBXkf=Fw&B8&6WkmU5nN zxwwW{1`*>wa(z=vjw0?GK_jpcRGFD8hdQ55ln8gi1S$s;s2oh7A{grkhOr%18q=`S z$oc@}@>ZX2&0&~S%y@NJ-lBgzCG5_Vf5R?;8Dx#M2pbG(ZF)I6oT>vnCSh1ns^sXO zEniDRFD6&4ErBLj+);{JL7;qiKh~gR98`cMuHiHi`J%ExxPxP5?Pp{Ad!)!}d?#t6vob zWi$=EU`>?MkP*jaCm4DPW4J$rx^}!G6%JQX@tIZw8PeS|2RhWuC(^woO+$|9&INwqos z(Q@A8a=nUV+#CM?a`^xA;s1|?|34P&))uVY(sr(0!Pza176}I6xURrg$v2FjWx}+(EE$psQU-xu;`=1F{|J9AKlQ!*S7r(Z`G}BrG$8 zgW)4I%Y;L$n1F-1hUPhtL4q~Mc<5A$U5*<|d|LJVr&%tS)bw5~uzawh%-yp8in2dr zN4z+n6+0x)fs!vB{6jn-H&A-&swi=>_;-sekFF?lvYbpjZMnp?ulR{sE14UbL{K$O zlNr;7-&|MZVz^|L#!~21{{fmx-GPc zyg5LP<2Tn88E}*qi;3TA)ngQ>^np6p3Xd=J?kPaQ-V#z^X=Fin<%!$_(d z$#!q7clCxr)ElDS8+yHWgZF?|!`5?L--N@}3ORIoL2Y3k!_6VXuV17ieJri{GkEiQ zd=^#v-6c~H=@bnf@HCKum~9|+$3S`u1L<)%2NxsGrWher#kQCt%jc~oXAZ32V#fO2 zLaKsg{bHu+_E}cVFrF<5p3DuNi7K(q^?8nuc87uSW@5x6kg5=&$Sw6MC)a_EQYFVx zlw}clU&3fEccWIgIPz0SX@p z22Y2f%Qe6YLNNe~za2mYwP1^~1RT1>p?IOWN6=r*JSNOq(@NN(Z()Z%gB@A|JG2CL zXgZc1ys_+1UJ7pLW7*+)6>S?TMVNC}(&E7|b}<*@$nOSX&N;qi@x``cH(Xmw;_M@^ zZ70GuOITJACKuOOnQ}q)78xwL$o<~^`N`iHsMN{aytep!m0wNfU$@8alsq@EqI$lsxW9wBXX2GjPe;G< z9djz&K=sCnYvmU{EF+>j6Y5L9sWp4$d-!yif$E#(gx7fhpR`l5Hs@!V8Ee$mWxd+j zyW$)1+%E?gtX3<_+P-sh7q#1p!`GR=&i-;}!78=+m-_GAJVfoJ;_x8zr`eZ=75J(B zacO(}W(~DC#o@u`53?@~FIb`0ExUjG=E-XQio-+AZ)abUD_EvBF?)O5W^1*%io+w! zi?T1t7x<{H%kCeynGz5wDn^;-Wm66eFR#$-?Xj_rYBGQ>WWO-na=xE;Xm)>K9~B5Y z2{I3m#SnBG&@n)Z3F;5%B%oA4ZlH=LC=O5ppoO3U#UAPm93Y|9pIVy{l#~8yC1%&c20DDu>5hkYHLfoyWPiJI&xlg{x+vGqVq$Y)=QpO z$dRu8`7g&}qRc*WK~&+HQReqrfl=8$5uua9iscd&3hYfcTO=Oe9vNfqIdaUnsIuwv zz0~p&&OdfcF$*lt_SwW>}1@lZba=wV{mp6Uton3a7 z_XcX1>973JIoa6rs`BdxV$lh*nG@0qy~i$$@T=-UM7N1(H;BAJ&N!Hc4m2?th8I2k3TnzTdoUia5Mx@GQ?-E%>-(q!O=jKG>B;~b{lS$>|jA5(Fc zskpwyyX+G4tQSTEs!K#WRhqANj?$a4+b;16L0@SQ)XRdP$$+kb3eYG(=70)7rAd$} zAZtKHpwg5GNWZeUU!Gce;>0xbL&;Z_#TSp#pbhxF^3<{cr2%p$$T~(kPpvrdyEO9? z$=8&{J=`>C>pejgfPM$$Nl+o6_kd0V`hlSSu>^g!pP+MqmJnnOND5F^^4JfizZE|S zrmlX!sKPny-36b5C2k+wGAhPtuGYTo6Dxf>-b2T7%e-l0W%i%-Oo|CExI44ZBFpu; zZe`+qjd$`(3zkH$A)d$dQvKONOVi=&n8nhWL$r#It~jgrtHcZ1&b^V!UP)ho_T9Zo z&SArep|Q``6+hTauq46hW!=+EG;(}md*rFf?4Lkwa=oftutXZrhQUc{V1EN-4`=|W zi~!LWu|yb9#NaOm#BBZ`_v>GdXiDJ1h>CIFP%9Mo*d^Ydj5hu392G2%<_wE=(y{DV zq6&0|4r&R$GjFI?F?~7reb59M)U}anE@%@PdvCT)u7V3X`!4OOmr#wg@K|wnu~!y- z-aUyQ=Jdx)eCv|*N9GG7edn;g#K9*d$N|R63P9X9p+gTFP@qu-hcJ3M!sN)AKpS1 z{4=J0tU!nH2KB%XyV4I`#?ud_&?B6n)w6f~^i3jxT4Y5%mwB3a z-~3(Zve!>E$5Jt?i0uzz?~xwY&Jvv;=Dn5#y}Ta@dj7lNwu$$1CFm=OT|{3AP3tEt z_VReK?!83N$NqxDi~Jrqq8JM?I0|1nGtHN!cOLM7PY-3Oq+?kKP$p?mZGXwWg7 z>OiAyQLO~3h1#(b9Q1JT4;oCLFm-65S}{~RiK;C|2Q)(G=6PwzxSZRG>!KILqyg-j zmZba}l5$H(`9%_J(Yh%Iiys6LXU0Mc+^6Rv^jv}d@Fo45ElPis9qJPkoc7{MpG_9e zKKy=eewc3E^It2*>DIkuuCJKu8|L~BSBOI}i9_06l8`D$NJm0FQT$pe-W$R^2*nEv z3PWG_qxvl&b|$DALZ}EmD+jLpM9mTaQGOs^7s@4;a`#k>a|tAIyMn>>3I^AB46b?u zN!ommleE3uOw2uUj+hI9mrGl1o~3O}{M5cj{FEYos(|?y==nf;UP9l;gSEteOsE=& zRl$6G2|cNB2PrB%(+h>;HRs@^CBXukt^|7v7{Uisf*Qx7#x1B(SWsWo_#@R=jn7OE zjSw^x^;%1&+!q6Cgwu+$oY+e*&d>ASb4HvF)i^JH=h5Ud;)ahVuU9O6Gb$@n zQ&;7F^~V$Ub(Rs>zR$}7+2)fJr^9i9%<_B{0;$y3E9O|Khpjk5+cmb}R@@i2;S9>$ z#xbZL&;$m>Z7o*p8NWqc3J;N3?BQDMZV2a_Q*C!SE7UpCAsdyJ@gurU|6;u~=5#GuTrJA-Znx|Bh2TZ@P^ z1NbnQE#+$N8?m=jwuv+BOI$YLUej#J-Rm*P45l4@lii0~t!8f(NdVG))uIv_ZT&$2pbSGXox-w-!t2Ul;aIr&*D(&SvAO@zmo za4b=H7$RtOEKLlTR9Yf)nT-|c;|RxcN6v;@$l1WGuemop4}i660{f3*5 zFODsovi#I;TfgUGng!>_7Ftft+#?2TB$P7>zK}CSH0Zj$8ogj$>f=mF-kS^Ai2>))GrA@-NxEXe?j^)-f z0YwlL4#*YIY(P5*DgxvSXda+Qf+P|N3IwzOP!!4n6a~lyP&CQ{lniJQpcs^u7#KGr z-F1GswP!T7D^`KZ+D}k6Aa6i%1la&82DBVdJVD`rDgdnnw3DDBK<@zs0NRDJk_h_B zji4U^?M7LEqyTMrm~WvsK4Bt%dIy7+Dj1W8tN}VA<@^;4O5Ksh_!LcsJD-n z4|Llva%Y;Z46(KX+;lm$ds)VFVn{fV?C}nupAff~5x0*ua2tQHF*_TK3q2hU*RA5$+E|O^-eJ!{rS*kly!v4N<~>p zC|+2QJ8B$=8ZV*|hp7=lgYr>h8rAp|jnG9Sg7f_en+X9t^qzQ93Lcz%NIY2ifY>ZU zY<>zhpCL9I6B~mV`YZGq_}ruCO7#5pJ9?f^&->EzX#9~)f2gvE4XN-~jC5}U!}mhE zjUnBAms!3}`Y~>XekF-uh|XWyMSJ@Q0vd%*mPg6wsRP1MPd|EhYm$HvQ}hJMgT5e$ z!tib+>>)bERHr3cAS@{3YWnFE*zSTY1>(qaj`GtcEy>Ll^?Ad@72ksFoX66tp z4qYOaU1NTt56K1>0Vxs}b*f2>*OO%b0{5Ap?gv%8iJq6z^H(Tx zEWWHf>g%QW*lweXg$2EahR{ciebI<>)CeI#6;{3%^P^c zakNH(63{f=plP7rdf}s_ z2?xJKYv^TVC6+qf(BJv zwxRrS$%#s)c`Y6;kn`TFwhvD1AR~&?IlcuKnqcABl!mC`u2i%fK20zK7 zXGIuPm*RIqgD{x9MveMt#1%9`Sda+SSO}TcgoKNs5nQ2N-kwE!H^dWT`+%{SNE1A8_j*5?1vc^1pAlAC5I}l7UdI@|Ab`!B2V+TxgxkI(eR!j zV3P%`bw@`F-#%fC5f1i=5TKlbtc(~z-vibgf%Tgp=mXdU{nL8aNUDKsB3MVXx~V%C13Im4 zT4KG6ngNq#9!vzroPpi)(S|yZ`rZ_MzsHfU+cr%hmc7KXf*8Xn#W)=5OrAzi>uef9 zZ7^v|5VM^a)1O8yHPfF`A}g zG`0VeC>a+}c{izr6^`->) zsssyI63m?mz1}CT_JE)DpP04%f?3<#rn9z@=%CLtYJ_Eoa4>zi8X~-zEA6J@&9K_k|= zmTPg5z!Nt-(WKA72UCn_47}v{c%6iWUN}BJ6C(G>Yq&@B8{8wXl7$9g+F*|t8h}Qu zMvk1!$f5K<;%V^@k+~LI3r^Hm(E5y{Ekn0Bh zO7u%P4xcTSw@4Wi@oTIo&%Q{7pTLTTM|Udxwka_oK+*&8qz7I> z4~(TU{4o{Bq-7~|OB}{8MZBl5pt-0~5;bC`vJ~H#&>*3?OdgkzVAZm9c^F1X#d4Ch zsb@*nc0!{XK%*K!qxxS>r$yqam>loK zH$f`~(OVV~{68*!)^@*=c@*BAuiMsLLyZOz{6{2~^;Yce8`h$-C-JBTvm&+o#Cj*p zmCbyf{rM{Ch%zQnQkX#5;nO$*>&OWoKn^~D2(}O4amn91T5%YX&kCGid5ehq@RT%j zp73lkZ?s(swe3WvRtk7Q&xkajI1j_ z)-53GF_3jF$hsC}-5r|!rUoX_6Uq(9YGGqF%Md0N*)GdQsMZL({lmeZ!ObM$&ojcU zBz|p+2PKr{Dx}g6v!)ha*%s>#es^i{DTAZ`;OG_bdnfz{r?BYZk42B#HDjr8n7}s~ z6W9|pcVGe=V2TC>9S;$8p;=xfW_f7~tnz@lgq4Y&B+(X_Gr@+Hgm_~W3aZ(K zma{6YyrIR*vEq@B6^}Tqc*KF-I)e42aCe(vO4X4uT_rAVHdrHUGxlX z5~`)r;4%SQg=&`c#J~d^UZ9~{?2%$5vnjISvLr%&&NME*%7x(CfyHTvuyKKEb%F2w zN;I(|UX1vx&qPzjaU45Y^W+RD_kV&WZ9;T722C>hmi(Z4Bi>)kDj8qykZ8RAVA;Tc z+%3_btD**q-FdgjthjR^#JzDP#1D3d?Nk)D5|Db(eCe2G-H#DfN?hQELzbEt(XRLWjzz?)gP_+MEaH$ zKgHNX2$X8m0%8#{CLJptj;dmOCex0fs!+V}cBU%$Pwt>_g1L-Xcq{p$q=x#>5zS#p8TNpyj z%9h(e{CymMZ=une6;t(jF<{W8?Fhu;W^V9oxKv_Bt^?g3j0yh&`VNE!@n&Mw9~$#} zv8&pb_eY$1JL*fxAsOF}U#Bpv+kBTtaZ$^ix6a-2aQN!&+Z9Sq{rpu0ZoY0IO1C*5|vC$@C|U+Ml2 ztu{rCEsWD5_$I*>cM0A>KX^5eetEJ?%zOX6;hvGYVp*C0eWvk!`I~U#_2Q-9E|)f_ z-jH7K!{vdGEYC^dc{!f{P`=%``?J`WNoV3_$V&X?eR*%U<(9tIck@Sv^eWMQXth>% zzuqYRh%TX|bSh~WN_s#g1)-#ED9MYeGeUI&AnJ$e%BVV1R2PWqmQZ!_sO~(qDI9Mn z0HSD=tAJWiryE)j{i}D+%X<@NP`B&Ey`XNdh#i|7XE|@hxsnPWj+~xRRkHSFl4}|9 z63iVy%(Vw|bLj&BU!M|#eV)@7VMb4a;&i9UYR*N$AGT4!j}}lx(T4bY)gQ!Pb@ap| zYR6^tL=<|$n|i_tZOlbafIDiROY{eoWP^9_g_7=3b)!(-da5o3UyKB*69CaDRQHgo zOF?zvs1Bc%4XV40HsS3AKoou0d*kK3Oke8+K+LMYA~A|Hgjl`bPHf0`A&K%aD90m7 zuznsfj2OH7Ws)zLE<$|V0?B?sd<-NmJA=zBNU|Ri+tummg?yP&AYCj)^FC7RXu z>Df#w_$WSRO}ykqddVVmyfk{^KJ|nfdSVNDLI6bhs1ALqgX+qux=K_RhwAWIEk&CI zK-7b(D}*AFMs+_@b#C~q#8BN?YLh0q;PZ$Etth-!>iqHDhjBMo{x&!DxMI%Jm-V%) zebaj7{>YaIq{=Bs#t90W`N&7beiJ4-xG* zY`;EA<*|Ofz|+f#)6ef@yzipYqf3|5%3ZpMv;ADIJM$7g3!U7ZRGI4-P6aG~{>Imt ze)t3Zk4|m;??>uQ>ILtG|MhZmoZ;i;>fz$esf45V-k(UMHyA|i?c4Zsx*OP=DWPc( zHh=xY{yVQfrXOd1(WQ$R+mD~opQzr)cd--4dcWJY?35w>bR@kf`>S^)Hq4&n>EYw# z;WN+L_Xj8Mxttn4I>>FZ5fw0xy8b_GbuS@KP~B*__d+KpA8+af`lm$)zN7CiJ^uZ@ mDb_MwEYicfvX@fTk7Frn4Q=U8T*DVD+T|kE@8%*yfBiq0`Bm)z literal 0 HcmV?d00001 diff --git a/benchmarks/data/very_large.xlsx b/benchmarks/data/very_large.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..c6056db2287594f3324c1376e24c6ff6be8b350a GIT binary patch literal 4333464 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

+aL;viwC`D3up@js4 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 *1g+6QLR~S-B8L=34x_r||&5^jPN{L4>6@ZpP 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®3MWr8@f$0R>i9LHn-G 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� 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 X;PUiS+?CnY4^ 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 z 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

@K@_7i$vQ>Cq2+MDwsc}EA^EpgH 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�ep*x0c%KqLb4mcDdXs8H3T17>+As;ogw)5R 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

{> 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

nyQ8z(=eGiCSA^9C{PiqXT?-f=$yEF;Z>Z0BfZ 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

Jqq2LY*uCRb3SI`ZV&TgQ4D7b)vbtur9 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%0DIfQ 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 +#include +#include +#include + +void standard() +{ + xlnt::xml_document doc; + + for (int i = 0; i < 1000000; i++) + { + doc.add_child("test"); + } + + xlnt::zip_file archive; + archive.writestr("sheet.xml", doc.to_string()); +} + +int main() +{ + standard(); + return 0; +} diff --git a/benchmarks/disabled/memory.cpp b/benchmarks/disabled/memory.cpp new file mode 100644 index 0000000000..a6895826ef --- /dev/null +++ b/benchmarks/disabled/memory.cpp @@ -0,0 +1,65 @@ +#include + +#ifdef __APPLE__ +#include +#endif + +#include + +#include "../tests/helpers/path_helper.hpp" + +int calc_memory_usage() +{ +#ifdef __APPLE__ + struct task_basic_info t_info; + mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT; + + if (KERN_SUCCESS != task_info(mach_task_self(), + TASK_BASIC_INFO, (task_info_t)&t_info, + &t_info_count)) + { + return 0; + } + + return t_info.virtual_size; +#endif + return 0; +} + +void test_memory_use() +{ + // Naive test that assumes memory use will never be more than 120 % of + // that for first 50 rows + auto current_folder = PathHelper::GetExecutableDirectory(); + auto src = current_folder + "rks/files/very_large.xlsx"; + + xlnt::workbook wb; + wb.load(src); + auto ws = wb.get_active_sheet(); + + int initial_use = 0; + int n = 0; + + for (auto line : ws.rows()) + { + if (n % 50 == 0) + { + auto use = calc_memory_usage(); + + if (initial_use == 0) + { + initial_use = use; + } + + assert(use / initial_use < 1.2); + std::cout << n << " " << use << std::endl; + } + + n++; + } +} + +int main() +{ + test_memory_use(); +} diff --git a/benchmarks/disabled/profiling.cpp b/benchmarks/disabled/profiling.cpp new file mode 100644 index 0000000000..d20837e9bb --- /dev/null +++ b/benchmarks/disabled/profiling.cpp @@ -0,0 +1,131 @@ +from io import BytesIO +from lxml.etree import xmlfile +import os +from random import randint + +from openpyxl import Workbook +from openpyxl.xml.functions import XMLGenerator + +def make_worksheet(): + wb = Workbook() + ws = wb.active + for i in range(1000): + ws.append(list(range(100))) + return ws + + +def lxml_writer(ws=None): + from openpyxl.writer.lxml_worksheet import write_rows + if ws is None: + ws = make_worksheet() + + out = BytesIO() + with xmlfile(out) as xf: + write_rows(xf, ws) + #with open("lxml_writer.xml", "wb") as dump: + #dump.write(out.getvalue()) + #ws.parent.save("lxml_writer.xlsx") + + +def make_dump_worksheet(): + wb = Workbook(write_only=True) + ws = wb.create_sheet() + return ws + +def dump_writer(ws=None): + if ws is None: + ws = make_dump_worksheet() + for i in range(1000): + ws.append(list(range(100))) + + +COLUMNS = 100 +ROWS = 1000 +BOLD = 1 +ITALIC = 2 +UNDERLINE = 4 +RED_BG = 8 +formatData = [[None] * COLUMNS for _ in range(ROWS)] + +def generate_format_data(): + for row in range(ROWS): + for col in range(COLUMNS): + formatData[row][col] = randint(1, 15) + + +def styled_sheet(): + from openpyxl import Workbook + from openpyxl.styles import Font, Style, PatternFill, Color, colors + + wb = Workbook() + ws = wb.active + ws.title = 'Test 1' + + red_fill = PatternFill(fill_type='solid', fgColor=Color(colors.RED), bgColor=Color(colors.RED)) + empty_fill = PatternFill() + styles = [] + # pregenerate relevant styles + for row in range(ROWS): + _row = [] + for col in range(COLUMNS): + cell = ws.cell(row=row+1, column=col+1) + cell.value = 1 + font = {} + fill = PatternFill() + if formatData[row][col] & BOLD: + font['bold'] = True + if formatData[row][col] & ITALIC: + font['italic'] = True + if formatData[row][col] & UNDERLINE: + font['underline'] = 'single' + if formatData[row][col] & RED_BG: + fill = red_fill + cell.style = Style(font=Font(**font), fill=fill) + + #wb.save(get_output_path('test_openpyxl_style_std_pregen.xlsx')) + + +def read_workbook(): + from openpyxl import load_workbook + folder = os.path.split(__file__)[0] + src = os.path.join(folder, "files", "very_large.xlsx") + wb = load_workbook(src) + return wb + + +def rows(wb): + ws = wb.active + rows = ws.iter_rows() + for r, row in enumerate(rows): + for c, col in enumerate(row): + pass + print((r+1)* (c+1), "cells") + + +def col_index1(): + from openpyxl.cell import get_column_letter + for i in range(1, 18279): + c = get_column_letter(i) + + + +""" +Sample use +import cProfile +ws = make_worksheet() +cProfile.run("profiling.lxml_writer(ws)", sort="tottime") +""" + + +if __name__ == '__main__': + import cProfile + ws = make_worksheet() + #wb = read_workbook() + #cProfile.run("rows(wb)", sort="tottime") + #cProfile.run("make_worksheet()", sort="tottime") + #cProfile.run("lxml_writer(ws)", sort="tottime") + #generate_format_data() + #cProfile.run("styled_sheet()", sort="tottime") + #ws = make_dump_worksheet() + #cProfile.run("dump_writer(ws)", sort="tottime") + cProfile.run("col_index1()", sort="tottime") diff --git a/benchmarks/disabled/reader.cpp b/benchmarks/disabled/reader.cpp new file mode 100644 index 0000000000..2049e32807 --- /dev/null +++ b/benchmarks/disabled/reader.cpp @@ -0,0 +1,45 @@ +import os +import sys +import timeit + +import openpyxl + + +def reader(optimised): + """ + Loop through all cells of a workbook + """ + folder = os.path.split(__file__)[0] + src = os.path.join(folder, "files", "very_large.xlsx") + wb = openpyxl.load_workbook(src, use_iterators=optimised) + ws = wb.active + rows = ws.iter_rows() + for r, row in enumerate(rows): + for c, col in enumerate(row): + pass + print((r+1)* (c+1), "cells") + +def timer(fn): + """ + Create a timeit call to a function and pass in keyword arguments. + The function is called twice, once using the standard workbook, then with the optimised one. + Time from the best of three is taken. + """ + print("lxml", openpyxl.LXML) + result = [] + for opt in (False, True,): + print("Workbook is {0}".format(opt and "optimised" or "not optimised")) + times = timeit.repeat("{0}({1})".format(fn.__name__, opt), + setup="from __main__ import {0}".format(fn.__name__), + number = 1, + repeat = 3 + ) + print("{0:.2f}s".format(min(times))) + result.append(min(times)) + std, opt = result + print("Optimised takes {0:.2%} time\n".format(opt/std)) + return std, opt + + +if __name__ == "__main__": + timer(reader) diff --git a/benchmarks/disabled/speed.cpp b/benchmarks/disabled/speed.cpp new file mode 100644 index 0000000000..a893d5731b --- /dev/null +++ b/benchmarks/disabled/speed.cpp @@ -0,0 +1,31 @@ +"Benchmark some different implementations for cells" + +from openpyxl.compat import range + +from openpyxl.cell import Cell +from openpyxl.cell.read_only import ReadOnlyCell +from memory_profiler import memory_usage +import time + + +def standard(): + c = Cell(None, "A", "0", None) + +def iterative(): + c = ReadOnlyCell(None, None, None, 'n') + +def dictionary(): + c = {'ws':'None', 'col':'A', 'row':0, 'value':1} + + +if __name__ == '__main__': + initial_use = memory_usage(proc=-1, interval=1)[0] + for fn in (standard, iterative, dictionary): + t = time.time() + container = [] + for i in range(1000000): + container.append(fn()) + print("{0} {1} MB, {2:.2f}s".format( + fn.func_name, + memory_usage(proc=-1, interval=1)[0] - initial_use, + time.time() - t)) diff --git a/benchmarks/microbenchmarks/CMakeLists.txt b/benchmarks/microbenchmarks/CMakeLists.txt new file mode 100644 index 0000000000..745df1b82e --- /dev/null +++ b/benchmarks/microbenchmarks/CMakeLists.txt @@ -0,0 +1,36 @@ +# FetchContent added in cmake v3.11 +# https://cmake.org/cmake/help/v3.11/module/FetchContent.html +# this file is behind a feature flag (XLNT_MICROBENCH_ENABLED) so the primary build is not affected +cmake_minimum_required(VERSION 3.11) +project(xlnt_ubench) + +# acquire google benchmark dependency +# disable generation of the various test projects +set(BENCHMARK_ENABLE_TESTING OFF) +# gtest not required +set(BENCHMARK_ENABLE_GTEST_TESTS OFF) + +include(FetchContent) +FetchContent_Declare( + googlebenchmark + GIT_REPOSITORY https://github.com/google/benchmark + GIT_TAG v1.5.0 +) +# download if not already present +FetchContent_GetProperties(googlebenchmark) +if(NOT googlebenchmark_POPULATED) + FetchContent_Populate(googlebenchmark) + add_subdirectory(${googlebenchmark_SOURCE_DIR} ${googlebenchmark_BINARY_DIR}) +endif() +# equivalent of add_subdirectory, now available for use +FetchContent_MakeAvailable(googlebenchmark) + + +add_executable(xlnt_ubench) +target_sources(xlnt_ubench + PRIVATE + string_to_double.cpp + double_to_string.cpp +) +target_link_libraries(xlnt_ubench benchmark_main xlnt) +target_compile_features(xlnt_ubench PRIVATE cxx_std_17) \ No newline at end of file diff --git a/benchmarks/microbenchmarks/double_to_string.cpp b/benchmarks/microbenchmarks/double_to_string.cpp new file mode 100644 index 0000000000..0b82803f64 --- /dev/null +++ b/benchmarks/microbenchmarks/double_to_string.cpp @@ -0,0 +1,207 @@ +// A core part of the xlsx serialisation routine is taking doubles from memory and stringifying them +// this has a few requirements +// - expect strings in the form 1234.56 (i.e. no thousands seperator, '.' used for the decimal seperator) +// - outputs up to 15 significant figures (excel only serialises numbers up to 15sf) + +#include "benchmark/benchmark.h" +#include +#include +#include + +namespace { + +// setup a large quantity of random doubles as strings +template +class RandomFloats : public benchmark::Fixture +{ + static constexpr size_t Number_of_Elements = 1 << 20; + static_assert(Number_of_Elements > 1'000'000, "ensure a decent set of random values is generated"); + + std::vector inputs; + + size_t index = 0; + const char *locale_str = nullptr; + +public: + void SetUp(const ::benchmark::State &state) + { + if (Decimal_Locale) + { + locale_str = setlocale(LC_ALL, "C"); + } + else + { + locale_str = setlocale(LC_ALL, "de-DE"); + } + std::random_device rd; // obtain a seed for the random number engine + std::mt19937 gen(rd()); + // doing full range is stupid (::min/max()...), it just ends up generating very large numbers + // uniform is probably not the best distribution to use here, but it will do for now + std::uniform_real_distribution dis(-1'000, 1'000); + // generate a large quantity of doubles to deserialise + inputs.reserve(Number_of_Elements); + for (int i = 0; i < Number_of_Elements; ++i) + { + double d = dis(gen); + inputs.push_back(d); + } + } + + void TearDown(const ::benchmark::State &state) + { + // restore locale + setlocale(LC_ALL, locale_str); + // gbench is keeping the fixtures alive somewhere, need to clear the data after use + inputs = std::vector{}; + } + + double &get_rand() + { + return inputs[++index & (Number_of_Elements - 1)]; + } +}; + +/// Takes in a double and outputs a string form of that number which will +/// serialise and deserialise without loss of precision +std::string serialize_number_to_string(double num) +{ + // more digits and excel won't match + constexpr int Excel_Digit_Precision = 15; //sf + std::stringstream ss; + ss.precision(Excel_Digit_Precision); + ss << num; + return ss.str(); +} + +class number_serialiser +{ + static constexpr int Excel_Digit_Precision = 15; //sf + std::ostringstream ss; + +public: + explicit number_serialiser() + { + ss.precision(Excel_Digit_Precision); + ss.imbue(std::locale("C")); + } + + std::string serialise(double d) + { + ss.str(""); // reset string buffer + ss.clear(); // reset any error flags + ss << d; + return ss.str(); + } +}; + +class number_serialiser_mk2 +{ + static constexpr int Excel_Digit_Precision = 15; //sf + bool should_convert_comma; + + void convert_comma(char *buf, int len) + { + char *buf_end = buf + len; + char *decimal = std::find(buf, buf_end, ','); + if (decimal != buf_end) + { + *decimal = '.'; + } + } + +public: + explicit number_serialiser_mk2() + : should_convert_comma(std::use_facet>(std::locale{}).decimal_point() == ',') + { + } + + std::string serialise(double d) + { + char buf[Excel_Digit_Precision + 1]; // need space for trailing '\0' + int len = snprintf(buf, sizeof(buf), "%.15g", d); + if (should_convert_comma) + { + convert_comma(buf, len); + } + return std::string(buf, len); + } +}; + +using RandFloats = RandomFloats; +using RandFloatsComma = RandomFloats; +} // namespace + +BENCHMARK_F(RandFloats, string_from_double_sstream) +(benchmark::State &state) +{ + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + serialize_number_to_string(get_rand())); + } +} + +BENCHMARK_F(RandFloats, string_from_double_sstream_cached) +(benchmark::State &state) +{ + number_serialiser ser; + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + ser.serialise(get_rand())); + } +} + +BENCHMARK_F(RandFloats, string_from_double_snprintf) +(benchmark::State &state) +{ + while (state.KeepRunning()) + { + char buf[16]; + int len = snprintf(buf, sizeof(buf), "%.15g", get_rand()); + + benchmark::DoNotOptimize( + std::string(buf, len)); + } +} + +BENCHMARK_F(RandFloats, string_from_double_snprintf_fixed) +(benchmark::State &state) +{ + number_serialiser_mk2 ser; + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + ser.serialise(get_rand())); + } +} + +// locale names are different between OS's, and std::from_chars is only complete in MSVC +#ifdef _MSC_VER + +#include +BENCHMARK_F(RandFloats, string_from_double_std_to_chars) +(benchmark::State &state) +{ + while (state.KeepRunning()) + { + char buf[16]; + std::to_chars_result result = std::to_chars(buf, buf + std::size(buf), get_rand()); + + benchmark::DoNotOptimize( + std::string(buf, result.ptr)); + } +} + +BENCHMARK_F(RandFloatsComma, string_from_double_snprintf_fixed_comma) +(benchmark::State &state) +{ + number_serialiser_mk2 ser; + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + ser.serialise(get_rand())); + } +} + +#endif \ No newline at end of file diff --git a/benchmarks/microbenchmarks/string_to_double.cpp b/benchmarks/microbenchmarks/string_to_double.cpp new file mode 100644 index 0000000000..5392f0a25b --- /dev/null +++ b/benchmarks/microbenchmarks/string_to_double.cpp @@ -0,0 +1,223 @@ +// A core part of the xlsx parsing routine is taking strings from the xml parser and parsing these to a double +// this has a few requirements +// - expect strings in the form 1234.56 (i.e. no thousands seperator, '.' used for the decimal seperator) +// - handles atleast 15 significant figures (excel only serialises numbers up to 15sf) + +#include +#include +#include +#include + +namespace { + +// setup a large quantity of random doubles as strings +template +class RandomFloatStrs : public benchmark::Fixture +{ + static constexpr size_t Number_of_Elements = 1 << 20; + static_assert(Number_of_Elements > 1'000'000, "ensure a decent set of random values is generated"); + + std::vector inputs; + + size_t index = 0; + const char *locale_str = nullptr; + +public: + void SetUp(const ::benchmark::State &state) + { + if (Decimal_Locale) + { + locale_str = setlocale(LC_ALL, "C"); + } + else + { + locale_str = setlocale(LC_ALL, "de-DE"); + } + std::random_device rd; // obtain a seed for the random number engine + std::mt19937 gen(rd()); + // doing full range is stupid (::min/max()...), it just ends up generating very large numbers + // uniform is probably not the best distribution to use here, but it will do for now + std::uniform_real_distribution dis(-1'000, 1'000); + // generate a large quantity of doubles to deserialise + inputs.reserve(Number_of_Elements); + for (int i = 0; i < Number_of_Elements; ++i) + { + double d = dis(gen); + char buf[16]; + snprintf(buf, 16, "%.15f", d); + inputs.push_back(std::string(buf)); + } + } + + void TearDown(const ::benchmark::State &state) + { + // restore locale + setlocale(LC_ALL, locale_str); + // gbench is keeping the fixtures alive somewhere, need to clear the data after use + inputs = std::vector{}; + } + + std::string &get_rand() + { + return inputs[++index & (Number_of_Elements - 1)]; + } +}; + +// method used by xlsx_consumer.cpp in commit - ba01de47a7d430764c20ec9ac9600eec0eb38bcf +// std::istringstream with the locale set to "C" +struct number_converter +{ + number_converter() + { + stream.imbue(std::locale("C")); + } + + double stold(const std::string &s) + { + stream.str(s); + stream.clear(); + stream >> result; + return result; + } + + std::istringstream stream; + double result; +}; + + +// to resolve the locale issue with strtod, a little preprocessing of the input is required +struct number_converter_mk2 +{ + explicit number_converter_mk2() + : should_convert_to_comma(std::use_facet>(std::locale{}).decimal_point() == ',') + { + } + + double stold(std::string &s) const noexcept + { + assert(!s.empty()); + if (should_convert_to_comma) + { + auto decimal_pt = std::find(s.begin(), s.end(), '.'); + if (decimal_pt != s.end()) + { + *decimal_pt = ','; + } + } + return strtod(s.c_str(), nullptr); + } + + double stold(const std::string &s) const + { + assert(!s.empty()); + if (!should_convert_to_comma) + { + return strtod(s.c_str(), nullptr); + } + std::string copy(s); + auto decimal_pt = std::find(copy.begin(), copy.end(), '.'); + if (decimal_pt != copy.end()) + { + *decimal_pt = ','; + } + return strtod(copy.c_str(), nullptr); + } + +private: + bool should_convert_to_comma = false; +}; + +using RandFloatStrs = RandomFloatStrs; +// german locale uses ',' as the seperator +using RandFloatCommaStrs = RandomFloatStrs; +} // namespace + +BENCHMARK_F(RandFloatStrs, double_from_string_sstream) +(benchmark::State &state) +{ + number_converter converter; + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + converter.stold(get_rand())); + } +} + +// using strotod +// https://en.cppreference.com/w/cpp/string/byte/strtof +// this naive usage is broken in the face of locales (fails condition 1) +#include +BENCHMARK_F(RandFloatStrs, double_from_string_strtod) +(benchmark::State &state) +{ + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + strtod(get_rand().c_str(), nullptr)); + } +} + +BENCHMARK_F(RandFloatStrs, double_from_string_strtod_fixed) +(benchmark::State &state) +{ + number_converter_mk2 converter; + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + converter.stold(get_rand())); + } +} + +BENCHMARK_F(RandFloatStrs, double_from_string_strtod_fixed_const_ref) +(benchmark::State &state) +{ + number_converter_mk2 converter; + while (state.KeepRunning()) + { + const std::string &inp = get_rand(); + benchmark::DoNotOptimize( + converter.stold(inp)); + } +} + +// locale names are different between OS's, and std::from_chars is only complete in MSVC +#ifdef _MSC_VER + +#include +BENCHMARK_F(RandFloatStrs, double_from_string_std_from_chars) +(benchmark::State &state) +{ + while (state.KeepRunning()) + { + const std::string &input = get_rand(); + double output; + benchmark::DoNotOptimize( + std::from_chars(input.data(), input.data() + input.size(), output)); + } +} + +// not using the standard "C" locale with '.' seperator +BENCHMARK_F(RandFloatCommaStrs, double_from_string_strtod_fixed_comma_ref) +(benchmark::State &state) +{ + number_converter_mk2 converter; + while (state.KeepRunning()) + { + benchmark::DoNotOptimize( + converter.stold(get_rand())); + } +} + +BENCHMARK_F(RandFloatCommaStrs, double_from_string_strtod_fixed_comma_const_ref) +(benchmark::State &state) +{ + number_converter_mk2 converter; + while (state.KeepRunning()) + { + const std::string &inp = get_rand(); + benchmark::DoNotOptimize( + converter.stold(inp)); + } +} + +#endif \ No newline at end of file diff --git a/benchmarks/spreadsheet-load.cpp b/benchmarks/spreadsheet-load.cpp new file mode 100644 index 0000000000..64318c7911 --- /dev/null +++ b/benchmarks/spreadsheet-load.cpp @@ -0,0 +1,58 @@ +#include +#include +#include + +namespace { +using milliseconds_d = std::chrono::duration; + +void run_load_test(const xlnt::path &file, int runs = 10) +{ + std::cout << file.string() << "\n\n"; + + xlnt::workbook wb; + std::vector test_timings; + + for (int i = 0; i < runs; ++i) + { + auto start = std::chrono::steady_clock::now(); + wb.load(file); + + auto end = std::chrono::steady_clock::now(); + wb.clear(); + test_timings.push_back(end - start); + + std::cout << milliseconds_d(test_timings.back()).count() << " ms\n"; + } +} + +void run_save_test(const xlnt::path &file, int runs = 10) +{ + std::cout << file.string() << "\n\n"; + + xlnt::workbook wb; + wb.load(file); + const xlnt::path save_path(file.filename()); + + std::vector test_timings; + + for (int i = 0; i < runs; ++i) + { + auto start = std::chrono::steady_clock::now(); + + wb.save(save_path); + + auto end = std::chrono::steady_clock::now(); + test_timings.push_back(end - start); + std::cout << milliseconds_d(test_timings.back()).count() << " ms\n"; + } +} +} // namespace + +int main() +{ + run_load_test(path_helper::benchmark_file("large.xlsx")); + run_load_test(path_helper::benchmark_file("very_large.xlsx")); + + run_save_test(path_helper::benchmark_file("large.xlsx")); + run_save_test(path_helper::benchmark_file("very_large.xlsx")); +} \ No newline at end of file diff --git a/benchmarks/styles.cpp b/benchmarks/styles.cpp new file mode 100644 index 0000000000..cff6314412 --- /dev/null +++ b/benchmarks/styles.cpp @@ -0,0 +1,250 @@ +// Copyright (c) 2017-2018 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include +#include +#include +#include +#include + +#include +#include + +namespace { + +std::size_t random_index(std::size_t max) +{ + static std::random_device rd; + static std::mt19937 gen(rd()); + + std::uniform_int_distribution<> dis(0, static_cast(max - 1)); + + return dis(gen); +} + +void generate_all_formats(xlnt::workbook &wb, std::vector& formats) +{ + const auto vertical_alignments = std::vector + { + xlnt::vertical_alignment::center, + xlnt::vertical_alignment::justify, + xlnt::vertical_alignment::top, + xlnt::vertical_alignment::bottom + }; + + const auto horizontal_alignments = std::vector + { + xlnt::horizontal_alignment::center, + xlnt::horizontal_alignment::center_continuous, + xlnt::horizontal_alignment::general, + xlnt::horizontal_alignment::justify, + xlnt::horizontal_alignment::left, + xlnt::horizontal_alignment::right + }; + + const auto font_names = std::vector + { + "Calibri", + "Tahoma", + "Arial", + "Times New Roman" + }; + + const auto font_sizes = std::vector + { + 11., + 13., + 15., + 17., + 19., + 21., + 23., + 25., + 27., + 29., + 31., + 33., + 35. + }; + + const auto underline_options = std::vector + { + xlnt::font::underline_style::single, + xlnt::font::underline_style::none + }; + + for (auto vertical_alignment : vertical_alignments) + { + for (auto horizontal_alignment : horizontal_alignments) + { + for (auto name : font_names) + { + for (auto size : font_sizes) + { + for (auto bold : { true, false }) + { + for (auto underline : underline_options) + { + for (auto italic : { true, false }) + { + auto fmt = wb.create_format(); + + xlnt::font f; + f.name(name); + f.size(size); + f.italic(italic); + f.underline(underline); + f.bold(bold); + fmt.font(f); + + xlnt::alignment a; + a.vertical(vertical_alignment); + a.horizontal(horizontal_alignment); + fmt.alignment(a); + + formats.push_back(fmt); + } + } + } + } + } + } + } +} + + +xlnt::workbook non_optimized_workbook_formats(int rows_number, int columns_number) +{ + using xlnt::benchmarks::current_time; + + xlnt::workbook wb; + std::vector formats; + auto start = current_time(); + + generate_all_formats(wb, formats); + + auto elapsed = current_time() - start; + + std::cout << "elapsed " << elapsed / 1000.0 << ". generate_all_formats. number of unique formats " << formats.size() << std::endl; + + start = current_time(); + auto worksheet = wb[random_index(wb.sheet_count())]; + auto cells_proceeded = 0; + for (int row_idx = 1; row_idx <= rows_number; row_idx++) + { + for (int col_idx = 1; col_idx <= columns_number; col_idx++) + { + auto cell = worksheet.cell(xlnt::cell_reference((xlnt::column_t)col_idx, (xlnt::row_t)row_idx)); + std::ostringstream string_stm; + string_stm << "Col: " << col_idx << "Row: " << row_idx; + cell.value(string_stm.str()); + cell.format(formats.at(random_index(formats.size()))); + cells_proceeded++; + } + } + + elapsed = current_time() - start; + + std::cout << "elapsed " << elapsed / 1000.0 << ". set values and formats for cells. cells proceeded " << cells_proceeded << std::endl; + + return wb; +} + +void to_save_profile(xlnt::workbook &wb, const std::string &f) +{ + using xlnt::benchmarks::current_time; + + auto start = current_time(); + wb.save(f); + auto elapsed = current_time() - start; + + std::cout << "elapsed " << elapsed / 1000.0 << ". save workbook." << std::endl; +} + +void to_load_profile(xlnt::workbook &wb, const std::string &f) +{ + using xlnt::benchmarks::current_time; + + auto start = current_time(); + wb.load(f); + auto elapsed = current_time() - start; + + std::cout << "elapsed " << elapsed / 1000.0 << ". load workbook." << std::endl; +} + +void read_formats_profile(xlnt::workbook &wb, int rows_number, int columns_number) +{ + using xlnt::benchmarks::current_time; + + std::vector values; + std::vector formats; + auto start = current_time(); + auto worksheet = wb[random_index(wb.sheet_count())]; + for (int row_idx = 1; row_idx <= rows_number; row_idx++) + { + for (int col_idx = 1; col_idx <= columns_number; col_idx++) + { + auto cell = worksheet.cell(xlnt::cell_reference((xlnt::column_t)col_idx, (xlnt::row_t)row_idx)); + values.push_back(cell.value()); + formats.push_back(cell.format()); + } + } + + auto elapsed = current_time() - start; + + std::cout << "elapsed " << elapsed / 1000.0 << ". read values and formats for cells. values count " << values.size() + << ". formats count " << formats.size() << std::endl; +} + +} // namespace + +int main(int argc, char * argv[]) +{ + int rows_number = 1000; + int columns_number = 10; + + try + { + if (argc > 1) + rows_number = std::stoi(argv[1]); + + if (argc > 2) + columns_number = std::stoi(argv[2]); + + std::cout << "started. number of rows " << rows_number << ", number of columns " << columns_number << std::endl; + auto wb = non_optimized_workbook_formats(rows_number, columns_number); + auto f = "temp-formats.xlsx"; + to_save_profile(wb, f); + + xlnt::workbook load_formats_wb; + to_load_profile(load_formats_wb, f); + read_formats_profile(load_formats_wb, rows_number, columns_number); + } + catch(std::exception& ex) + { + std::cout << "failed. " << ex.what() << std::endl; + } + + return 0; +} diff --git a/benchmarks/writer.cpp b/benchmarks/writer.cpp new file mode 100644 index 0000000000..f2f94b3c9f --- /dev/null +++ b/benchmarks/writer.cpp @@ -0,0 +1,90 @@ +// Copyright (c) 2017-2018 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include + +#include +#include + +namespace { + +// Create a worksheet with variable width rows. Because data must be +// serialised row by row it is often the width of the rows which is most +// important. +void writer(int cols, int rows) +{ + xlnt::workbook wb; + auto ws = wb.create_sheet(); + + for(int index = 0; index < rows; index++) + { + if (rows >= 10 && (index + 1) % (rows / 10) == 0) + { + std::string progress = std::string((index + 1) / (1 + rows / 10), '.'); + std::cout << "\r" << progress; + } + + for (int i = 0; i < cols; i++) + { + ws.cell(xlnt::cell_reference(i + 1, index + 1)).value(i); + } + } + std::cout << '\n'; + + auto filename = "benchmark.xlsx"; + wb.save(filename); +} + +// Create a timeit call to a function and pass in keyword arguments. +// The function is called twice, once using the standard workbook, then with the optimised one. +// Time from the best of three is taken. +void timer(std::function fn, int cols, int rows) +{ + const auto repeat = std::size_t(3); + std::chrono::duration time{}; + std::cout << cols << " cols " << rows << " rows" << std::endl; + fn(rows, cols); // 1 cold run + + for(int i = 0; i < repeat; i++) + { + auto start = std::chrono::high_resolution_clock::now(); + fn(cols, rows); + time += std::chrono::high_resolution_clock::now() - start; + } + + std::cout << time.count() / repeat << " ms per iteration" << '\n' << '\n'; +} + +} // namespace + +int main() +{ + timer(&writer, 10000, 1); + timer(&writer, 1000, 10); + timer(&writer, 100, 100); + timer(&writer, 10, 1000); + timer(&writer, 1, 10000); + + return 0; +} diff --git a/book.json b/book.json new file mode 100644 index 0000000000..c51052a96b --- /dev/null +++ b/book.json @@ -0,0 +1,10 @@ +{ + "plugins": ["build"], + "pluginsConfig": { + "build": { + "template": "docs/template.ejs", + "format": "man", + "output": "docs/xlnt.3" + } + } +} diff --git a/cmake/FindArrow.cmake b/cmake/FindArrow.cmake new file mode 100644 index 0000000000..c893a1aadb --- /dev/null +++ b/cmake/FindArrow.cmake @@ -0,0 +1,133 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +# - Find ARROW (arrow/api.h, libarrow.a, libarrow.so) +# This module defines +# ARROW_INCLUDE_DIR, directory containing headers +# ARROW_LIBS, directory containing arrow libraries +# ARROW_STATIC_LIB, path to libarrow.a +# ARROW_SHARED_LIB, path to libarrow's shared library +# ARROW_SHARED_IMP_LIB, path to libarrow's import library (MSVC only) +# ARROW_FOUND, whether arrow has been found + +include(FindPkgConfig) + +if ("$ENV{ARROW_HOME}" STREQUAL "") + pkg_check_modules(ARROW arrow) + if (ARROW_FOUND) + pkg_get_variable(ARROW_ABI_VERSION arrow abi_version) + message(STATUS "Arrow ABI version: ${ARROW_ABI_VERSION}") + pkg_get_variable(ARROW_SO_VERSION arrow so_version) + message(STATUS "Arrow SO version: ${ARROW_SO_VERSION}") + set(ARROW_INCLUDE_DIR ${ARROW_INCLUDE_DIRS}) + set(ARROW_LIBS ${ARROW_LIBRARY_DIRS}) + set(ARROW_SEARCH_LIB_PATH ${ARROW_LIBRARY_DIRS}) + endif() +else() + set(ARROW_HOME "$ENV{ARROW_HOME}") + + set(ARROW_SEARCH_HEADER_PATHS + ${ARROW_HOME}/include + ) + + set(ARROW_SEARCH_LIB_PATH + ${ARROW_HOME}/lib + ) + + find_path(ARROW_INCLUDE_DIR arrow/array.h PATHS + ${ARROW_SEARCH_HEADER_PATHS} + # make sure we don't accidentally pick up a different version + NO_DEFAULT_PATH + ) +endif() + +find_library(ARROW_LIB_PATH NAMES arrow + PATHS + ${ARROW_SEARCH_LIB_PATH} + NO_DEFAULT_PATH) +get_filename_component(ARROW_LIBS ${ARROW_LIB_PATH} DIRECTORY) + +find_library(ARROW_PYTHON_LIB_PATH NAMES arrow_python + PATHS + ${ARROW_SEARCH_LIB_PATH} + NO_DEFAULT_PATH) +get_filename_component(ARROW_PYTHON_LIBS ${ARROW_PYTHON_LIB_PATH} DIRECTORY) + +if (MSVC) + SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll") + + if (MSVC AND NOT ARROW_MSVC_STATIC_LIB_SUFFIX) + set(ARROW_MSVC_STATIC_LIB_SUFFIX "_static") + endif() + + find_library(ARROW_SHARED_LIBRARIES NAMES arrow + PATHS ${ARROW_HOME} NO_DEFAULT_PATH + PATH_SUFFIXES "bin" ) + + find_library(ARROW_PYTHON_SHARED_LIBRARIES NAMES arrow_python + PATHS ${ARROW_HOME} NO_DEFAULT_PATH + PATH_SUFFIXES "bin" ) + get_filename_component(ARROW_SHARED_LIBS ${ARROW_SHARED_LIBRARIES} PATH ) + get_filename_component(ARROW_PYTHON_SHARED_LIBS ${ARROW_PYTHON_SHARED_LIBRARIES} PATH ) +endif () + +if (ARROW_INCLUDE_DIR AND ARROW_LIBS) + set(ARROW_FOUND TRUE) + set(ARROW_LIB_NAME arrow) + set(ARROW_PYTHON_LIB_NAME arrow_python) + if (MSVC) + set(ARROW_STATIC_LIB ${ARROW_LIBS}/${ARROW_LIB_NAME}${ARROW_MSVC_STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}) + set(ARROW_PYTHON_STATIC_LIB ${ARROW_PYTHON_LIBS}/${ARROW_PYTHON_LIB_NAME}${ARROW_MSVC_STATIC_LIB_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}) + set(ARROW_SHARED_LIB ${ARROW_SHARED_LIBS}/${ARROW_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + set(ARROW_PYTHON_SHARED_LIB ${ARROW_PYTHON_SHARED_LIBS}/${ARROW_PYTHON_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + set(ARROW_SHARED_IMP_LIB ${ARROW_LIBS}/${ARROW_LIB_NAME}.lib) + set(ARROW_PYTHON_SHARED_IMP_LIB ${ARROW_PYTHON_LIBS}/${ARROW_PYTHON_LIB_NAME}.lib) + else() + set(ARROW_STATIC_LIB ${ARROW_PYTHON_LIB_PATH}/lib${ARROW_LIB_NAME}.a) + set(ARROW_PYTHON_STATIC_LIB ${ARROW_PYTHON_LIB_PATH}/lib${ARROW_PYTHON_LIB_NAME}.a) + + set(ARROW_SHARED_LIB ${ARROW_LIBS}/lib${ARROW_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + set(ARROW_PYTHON_SHARED_LIB ${ARROW_LIBS}/lib${ARROW_PYTHON_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + endif() +endif() + +if (ARROW_FOUND) + if (NOT Arrow_FIND_QUIETLY) + message(STATUS "Found the Arrow core library: ${ARROW_LIB_PATH}") + message(STATUS "Found the Arrow Python library: ${ARROW_PYTHON_LIB_PATH}") + endif () +else () + if (NOT Arrow_FIND_QUIETLY) + set(ARROW_ERR_MSG "Could not find the Arrow library. Looked for headers") + set(ARROW_ERR_MSG "${ARROW_ERR_MSG} in ${ARROW_SEARCH_HEADER_PATHS}, and for libs") + set(ARROW_ERR_MSG "${ARROW_ERR_MSG} in ${ARROW_SEARCH_LIB_PATH}") + if (Arrow_FIND_REQUIRED) + message(FATAL_ERROR "${ARROW_ERR_MSG}") + else (Arrow_FIND_REQUIRED) + message(STATUS "${ARROW_ERR_MSG}") + endif (Arrow_FIND_REQUIRED) + endif () + set(ARROW_FOUND FALSE) +endif () + +mark_as_advanced( + ARROW_INCLUDE_DIR + ARROW_STATIC_LIB + ARROW_SHARED_LIB + ARROW_PYTHON_STATIC_LIB + ARROW_PYTHON_SHARED_LIB +) diff --git a/cmake/XlntConfig.cmake.in b/cmake/XlntConfig.cmake.in new file mode 100644 index 0000000000..2100b91ba9 --- /dev/null +++ b/cmake/XlntConfig.cmake.in @@ -0,0 +1,13 @@ +set(XLNT_VERSION "@xlnt_VERSION@") + +@PACKAGE_INIT@ + +get_filename_component(XLNT_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) + +set_and_check(XLNT_INCLUDE_DIR "@XLNT_INCLUDE_INSTALL_DIR@") + +check_required_components(xlnt) + +if(NOT TARGET xlnt::xlnt) + include("${XLNT_CMAKE_DIR}/XlntTargets.cmake") +endif() diff --git a/cmake/cmake_uninstall.cmake.in b/cmake/cmake_uninstall.cmake.in new file mode 100644 index 0000000000..bc37cfec8e --- /dev/null +++ b/cmake/cmake_uninstall.cmake.in @@ -0,0 +1,33 @@ +if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") + message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") +endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") + +file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) +string(REGEX REPLACE "\n" ";" files "${files}") +foreach(file ${files}) + message(STATUS "Uninstalling $ENV{DESTDIR}${file}") + if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + exec_program( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") + endif(NOT "${rm_retval}" STREQUAL 0) + else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + message(STATUS "File $ENV{DESTDIR}${file} does not exist.") + endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") +endforeach(file) + +message(STATUS "Uninstalling @INC_DEST_DIR@/xlnt") + +exec_program("@CMAKE_COMMAND@" + ARGS "-E remove_directory @INC_DEST_DIR@/xlnt" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval +) + +if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing @INC_DEST_DIR@/xlnt") +endif() \ No newline at end of file diff --git a/cmake/pkg-config.pc.cmake b/cmake/pkg-config.pc.cmake new file mode 100644 index 0000000000..207cb951aa --- /dev/null +++ b/cmake/pkg-config.pc.cmake @@ -0,0 +1,10 @@ +Name: ${PROJECT_NAME} +Description: ${PROJECT_DESCRIPTION} +Version: ${PROJECT_VERSION} +URL: ${PROJECT_URL} +prefix=${CMAKE_INSTALL_PREFIX} +includedir=${PKG_CONFIG_INCLUDEDIR} +libdir=${PKG_CONFIG_LIBDIR} +exec_prefix=${PKG_CONFIG_EXEC_PREFIX} +Libs: ${PKG_CONFIG_LIBS} +Cflags: ${PKG_CONFIG_CFLAGS} diff --git a/cmake/ucm.cmake b/cmake/ucm.cmake new file mode 100644 index 0000000000..5dc8e4e257 --- /dev/null +++ b/cmake/ucm.cmake @@ -0,0 +1,634 @@ +# +# ucm.cmake - useful cmake macros +# +# Copyright (c) 2016 Viktor Kirilov +# +# Distributed under the MIT Software License +# See accompanying file LICENSE.txt or copy at +# https://opensource.org/licenses/MIT +# +# The documentation can be found at the library's page: +# https://github.com/onqtam/ucm + +cmake_minimum_required(VERSION 2.8.12) + +include(CMakeParseArguments) + +# optionally include cotire - the git submodule might not be inited (or the user might have already included it) +if(NOT COMMAND cotire) + include(${CMAKE_CURRENT_LIST_DIR}/../cotire/CMake/cotire.cmake OPTIONAL) +endif() + +if(COMMAND cotire AND "1.7.9" VERSION_LESS "${COTIRE_CMAKE_MODULE_VERSION}") + set(ucm_with_cotire 1) +else() + set(ucm_with_cotire 0) +endif() + +option(UCM_UNITY_BUILD "Enable unity build for targets registered with the ucm_add_target() macro" OFF) +option(UCM_NO_COTIRE_FOLDER "Do not use a cotire folder in the solution explorer for all unity and cotire related targets" ON) + +# ucm_add_flags +# Adds compiler flags to CMAKE__FLAGS or to a specific config +macro(ucm_add_flags) + cmake_parse_arguments(ARG "C;CXX;CLEAR_OLD" "" "CONFIG" ${ARGN}) + + if(NOT ARG_CONFIG) + set(ARG_CONFIG " ") + endif() + + foreach(CONFIG ${ARG_CONFIG}) + # determine to which flags to add + if(NOT ${CONFIG} STREQUAL " ") + string(TOUPPER ${CONFIG} CONFIG) + set(CXX_FLAGS CMAKE_CXX_FLAGS_${CONFIG}) + set(C_FLAGS CMAKE_C_FLAGS_${CONFIG}) + else() + set(CXX_FLAGS CMAKE_CXX_FLAGS) + set(C_FLAGS CMAKE_C_FLAGS) + endif() + + # clear the old flags + if(${ARG_CLEAR_OLD}) + if("${ARG_CXX}" OR NOT "${ARG_C}") + set(${CXX_FLAGS} "") + endif() + if("${ARG_C}" OR NOT "${ARG_CXX}") + set(${C_FLAGS} "") + endif() + endif() + + # add all the passed flags + foreach(flag ${ARG_UNPARSED_ARGUMENTS}) + if("${ARG_CXX}" OR NOT "${ARG_C}") + set(${CXX_FLAGS} "${${CXX_FLAGS}} ${flag}") + endif() + if("${ARG_C}" OR NOT "${ARG_CXX}") + set(${C_FLAGS} "${${C_FLAGS}} ${flag}") + endif() + endforeach() + endforeach() + +endmacro() + +# ucm_set_flags +# Sets the CMAKE__FLAGS compiler flags or for a specific config +macro(ucm_set_flags) + ucm_add_flags(CLEAR_OLD ${ARGN}) +endmacro() + +# ucm_add_linker_flags +# Adds linker flags to CMAKE__LINKER_FLAGS or to a specific config +macro(ucm_add_linker_flags) + cmake_parse_arguments(ARG "CLEAR_OLD;EXE;MODULE;SHARED;STATIC" "" "CONFIG" ${ARGN}) + + if(NOT ARG_CONFIG) + set(ARG_CONFIG " ") + endif() + + foreach(CONFIG ${ARG_CONFIG}) + string(TOUPPER "${CONFIG}" CONFIG) + + if(NOT ${ARG_EXE} AND NOT ${ARG_MODULE} AND NOT ${ARG_SHARED} AND NOT ${ARG_STATIC}) + set(ARG_EXE 1) + set(ARG_MODULE 1) + set(ARG_SHARED 1) + set(ARG_STATIC 1) + endif() + + set(flags_configs "") + if(${ARG_EXE}) + if(NOT "${CONFIG}" STREQUAL " ") + list(APPEND flags_configs CMAKE_EXE_LINKER_FLAGS_${CONFIG}) + else() + list(APPEND flags_configs CMAKE_EXE_LINKER_FLAGS) + endif() + endif() + if(${ARG_MODULE}) + if(NOT "${CONFIG}" STREQUAL " ") + list(APPEND flags_configs CMAKE_MODULE_LINKER_FLAGS_${CONFIG}) + else() + list(APPEND flags_configs CMAKE_MODULE_LINKER_FLAGS) + endif() + endif() + if(${ARG_SHARED}) + if(NOT "${CONFIG}" STREQUAL " ") + list(APPEND flags_configs CMAKE_SHARED_LINKER_FLAGS_${CONFIG}) + else() + list(APPEND flags_configs CMAKE_SHARED_LINKER_FLAGS) + endif() + endif() + if(${ARG_STATIC}) + if(NOT "${CONFIG}" STREQUAL " ") + list(APPEND flags_configs CMAKE_STATIC_LINKER_FLAGS_${CONFIG}) + else() + list(APPEND flags_configs CMAKE_STATIC_LINKER_FLAGS) + endif() + endif() + + # clear the old flags + if(${ARG_CLEAR_OLD}) + foreach(flags ${flags_configs}) + set(${flags} "") + endforeach() + endif() + + # add all the passed flags + foreach(flag ${ARG_UNPARSED_ARGUMENTS}) + foreach(flags ${flags_configs}) + set(${flags} "${${flags}} ${flag}") + endforeach() + endforeach() + endforeach() +endmacro() + +# ucm_set_linker_flags +# Sets the CMAKE__LINKER_FLAGS linker flags or for a specific config +macro(ucm_set_linker_flags) + ucm_add_linker_flags(CLEAR_OLD ${ARGN}) +endmacro() + +# ucm_gather_flags +# Gathers all lists of flags for printing or manipulation +macro(ucm_gather_flags with_linker result) + set(${result} "") + # add the main flags without a config + list(APPEND ${result} CMAKE_C_FLAGS) + list(APPEND ${result} CMAKE_CXX_FLAGS) + if(${with_linker}) + list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS) + list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS) + list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS) + list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS) + endif() + + if("${CMAKE_CONFIGURATION_TYPES}" STREQUAL "" AND NOT "${CMAKE_BUILD_TYPE}" STREQUAL "") + # handle single config generators - like makefiles/ninja - when CMAKE_BUILD_TYPE is set + string(TOUPPER ${CMAKE_BUILD_TYPE} config) + list(APPEND ${result} CMAKE_C_FLAGS_${config}) + list(APPEND ${result} CMAKE_CXX_FLAGS_${config}) + if(${with_linker}) + list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS_${config}) + list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS_${config}) + list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS_${config}) + list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS_${config}) + endif() + else() + # handle multi config generators (like msvc, xcode) + foreach(config ${CMAKE_CONFIGURATION_TYPES}) + string(TOUPPER ${config} config) + list(APPEND ${result} CMAKE_C_FLAGS_${config}) + list(APPEND ${result} CMAKE_CXX_FLAGS_${config}) + if(${with_linker}) + list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS_${config}) + list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS_${config}) + list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS_${config}) + list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS_${config}) + endif() + endforeach() + endif() +endmacro() + +# ucm_set_runtime +# Sets the runtime (static/dynamic) for msvc/gcc +macro(ucm_set_runtime) + cmake_parse_arguments(ARG "STATIC;DYNAMIC" "" "" ${ARGN}) + + if(ARG_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}") + endif() + + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" STREQUAL "") + message(AUTHOR_WARNING "ucm_set_runtime() does not support clang yet!") + endif() + + ucm_gather_flags(0 flags_configs) + + # add/replace the flags + # note that if the user has messed with the flags directly this function might fail + # - for example if with MSVC and the user has removed the flags - here we just switch/replace them + if("${ARG_STATIC}") + foreach(flags ${flags_configs}) + if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") + if(NOT ${flags} MATCHES "-static-libstdc\\+\\+") + set(${flags} "${${flags}} -static-libstdc++") + endif() + if(NOT ${flags} MATCHES "-static-libgcc") + set(${flags} "${${flags}} -static-libgcc") + endif() + elseif(MSVC) + if(${flags} MATCHES "/MD") + string(REGEX REPLACE "/MD" "/MT" ${flags} "${${flags}}") + endif() + endif() + endforeach() + elseif("${ARG_DYNAMIC}") + foreach(flags ${flags_configs}) + if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") + if(${flags} MATCHES "-static-libstdc\\+\\+") + string(REGEX REPLACE "-static-libstdc\\+\\+" "" ${flags} "${${flags}}") + endif() + if(${flags} MATCHES "-static-libgcc") + string(REGEX REPLACE "-static-libgcc" "" ${flags} "${${flags}}") + endif() + elseif(MSVC) + if(${flags} MATCHES "/MT") + string(REGEX REPLACE "/MT" "/MD" ${flags} "${${flags}}") + endif() + endif() + endforeach() + endif() +endmacro() + +# ucm_print_flags +# Prints all compiler flags for all configurations +macro(ucm_print_flags) + ucm_gather_flags(1 flags_configs) + message("") + foreach(flags ${flags_configs}) + message("${flags}: ${${flags}}") + endforeach() + message("") +endmacro() + +# ucm_count_sources +# Counts the number of source files +macro(ucm_count_sources) + cmake_parse_arguments(ARG "" "RESULT" "" ${ARGN}) + if(${ARG_RESULT} STREQUAL "") + message(FATAL_ERROR "Need to pass RESULT and a variable name to ucm_count_sources()") + endif() + + set(result 0) + foreach(SOURCE_FILE ${ARG_UNPARSED_ARGUMENTS}) + if("${SOURCE_FILE}" MATCHES \\.\(c|C|cc|cp|cpp|CPP|c\\+\\+|cxx|i|ii\)$) + math(EXPR result "${result} + 1") + endif() + endforeach() + set(${ARG_RESULT} ${result}) +endmacro() + +# ucm_include_file_in_sources +# Includes the file to the source with compiler flags +macro(ucm_include_file_in_sources) + cmake_parse_arguments(ARG "" "HEADER" "" ${ARGN}) + if(${ARG_HEADER} STREQUAL "") + message(FATAL_ERROR "Need to pass HEADER and a header file to ucm_include_file_in_sources()") + endif() + + foreach(src ${ARG_UNPARSED_ARGUMENTS}) + if(${src} MATCHES \\.\(c|C|cc|cp|cpp|CPP|c\\+\\+|cxx\)$) + # get old flags + get_source_file_property(old_compile_flags ${src} COMPILE_FLAGS) + if(old_compile_flags STREQUAL "NOTFOUND") + set(old_compile_flags "") + endif() + + # update flags + if(MSVC) + set_source_files_properties(${src} PROPERTIES COMPILE_FLAGS + "${old_compile_flags} /FI\"${CMAKE_CURRENT_SOURCE_DIR}/${ARG_HEADER}\"") + else() + set_source_files_properties(${src} PROPERTIES COMPILE_FLAGS + "${old_compile_flags} -include \"${CMAKE_CURRENT_SOURCE_DIR}/${ARG_HEADER}\"") + endif() + endif() + endforeach() +endmacro() + +# ucm_dir_list +# Returns a list of subdirectories for a given directory +macro(ucm_dir_list thedir result) + file(GLOB sub-dir "${thedir}/*") + set(list_of_dirs "") + foreach(dir ${sub-dir}) + if(IS_DIRECTORY ${dir}) + get_filename_component(DIRNAME ${dir} NAME) + LIST(APPEND list_of_dirs ${DIRNAME}) + endif() + endforeach() + set(${result} ${list_of_dirs}) +endmacro() + +# ucm_trim_front_words +# Trims X times the front word from a string separated with "/" and removes +# the front "/" characters after that (used for filters for visual studio) +macro(ucm_trim_front_words source out num_filter_trims) + set(result "${source}") + set(counter 0) + while(${counter} LESS ${num_filter_trims}) + MATH(EXPR counter "${counter} + 1") + # removes everything at the front up to a "/" character + string(REGEX REPLACE "^([^/]+)" "" result "${result}") + # removes all consecutive "/" characters from the front + string(REGEX REPLACE "^(/+)" "" result "${result}") + endwhile() + set(${out} ${result}) +endmacro() + +# ucm_remove_files +# Removes source files from a list of sources (path is the relative path for it to be found) +macro(ucm_remove_files) + cmake_parse_arguments(ARG "" "FROM" "" ${ARGN}) + + if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "") + message(FATAL_ERROR "Need to pass some relative files to ucm_remove_files()") + endif() + if(${ARG_FROM} STREQUAL "") + message(FATAL_ERROR "Need to pass FROM and a variable name to ucm_remove_files()") + endif() + + foreach(cur_file ${ARG_UNPARSED_ARGUMENTS}) + list(REMOVE_ITEM ${ARG_FROM} ${cur_file}) + endforeach() +endmacro() + +# ucm_remove_directories +# Removes all source files from the given directories from the sources list +macro(ucm_remove_directories) + cmake_parse_arguments(ARG "" "FROM" "MATCHES" ${ARGN}) + + if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "") + message(FATAL_ERROR "Need to pass some relative directories to ucm_remove_directories()") + endif() + if(${ARG_FROM} STREQUAL "") + message(FATAL_ERROR "Need to pass FROM and a variable name to ucm_remove_directories()") + endif() + + foreach(cur_dir ${ARG_UNPARSED_ARGUMENTS}) + foreach(cur_file ${${ARG_FROM}}) + string(REGEX MATCH ${cur_dir} res ${cur_file}) + if(NOT "${res}" STREQUAL "") + if("${ARG_MATCHES}" STREQUAL "") + list(REMOVE_ITEM ${ARG_FROM} ${cur_file}) + else() + foreach(curr_ptrn ${ARG_MATCHES}) + string(REGEX MATCH ${curr_ptrn} res ${cur_file}) + if(NOT "${res}" STREQUAL "") + list(REMOVE_ITEM ${ARG_FROM} ${cur_file}) + break() + endif() + endforeach() + endif() + endif() + endforeach() + endforeach() +endmacro() + +# ucm_add_files_impl +macro(ucm_add_files_impl result trim files) + foreach(cur_file ${files}) + SET(${result} ${${result}} ${cur_file}) + get_filename_component(FILEPATH ${cur_file} PATH) + ucm_trim_front_words("${FILEPATH}" FILEPATH "${trim}") + # replacing forward slashes with back slashes so filters can be generated (back slash used in parsing...) + STRING(REPLACE "/" "\\" FILTERS "${FILEPATH}") + SOURCE_GROUP("${FILTERS}" FILES ${cur_file}) + endforeach() +endmacro() + +# ucm_add_files +# Adds files to a list of sources +macro(ucm_add_files) + cmake_parse_arguments(ARG "" "TO;FILTER_POP" "" ${ARGN}) + + if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "") + message(FATAL_ERROR "Need to pass some relative files to ucm_add_files()") + endif() + if(${ARG_TO} STREQUAL "") + message(FATAL_ERROR "Need to pass TO and a variable name to ucm_add_files()") + endif() + + if("${ARG_FILTER_POP}" STREQUAL "") + set(ARG_FILTER_POP 0) + endif() + + ucm_add_files_impl(${ARG_TO} ${ARG_FILTER_POP} "${ARG_UNPARSED_ARGUMENTS}") +endmacro() + +# ucm_add_dir_impl +macro(ucm_add_dir_impl result rec trim dirs_in additional_ext) + set(dirs "${dirs_in}") + + # handle the "" and "." cases + if("${dirs}" STREQUAL "" OR "${dirs}" STREQUAL ".") + set(dirs "./") + endif() + + foreach(cur_dir ${dirs}) + # to circumvent some linux/cmake/path issues - barely made it work... + if(cur_dir STREQUAL "./") + set(cur_dir "") + else() + set(cur_dir "${cur_dir}/") + endif() + + # since unix is case sensitive - add these valid extensions too + # we don't use "UNIX" but instead "CMAKE_HOST_UNIX" because we might be cross + # compiling (for example emscripten) under windows and UNIX may be set to 1 + # Also OSX is case insensitive like windows... + set(additional_file_extensions "") + if(CMAKE_HOST_UNIX AND NOT APPLE) + set(additional_file_extensions + "${cur_dir}*.CPP" + "${cur_dir}*.C" + "${cur_dir}*.H" + "${cur_dir}*.HPP" + ) + endif() + + foreach(ext ${additional_ext}) + list(APPEND additional_file_extensions "${cur_dir}*.${ext}") + endforeach() + + # find all sources and set them as result + FILE(GLOB found_sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" + # https://gcc.gnu.org/onlinedocs/gcc-4.4.1/gcc/Overall-Options.html#index-file-name-suffix-71 + # sources + "${cur_dir}*.cpp" + "${cur_dir}*.cxx" + "${cur_dir}*.c++" + "${cur_dir}*.cc" + "${cur_dir}*.cp" + "${cur_dir}*.c" + "${cur_dir}*.i" + "${cur_dir}*.ii" + # headers + "${cur_dir}*.h" + "${cur_dir}*.h++" + "${cur_dir}*.hpp" + "${cur_dir}*.hxx" + "${cur_dir}*.hh" + "${cur_dir}*.inl" + "${cur_dir}*.inc" + "${cur_dir}*.ipp" + "${cur_dir}*.ixx" + "${cur_dir}*.txx" + "${cur_dir}*.tpp" + "${cur_dir}*.tcc" + "${cur_dir}*.tpl" + ${additional_file_extensions}) + SET(${result} ${${result}} ${found_sources}) + + # set the proper filters + ucm_trim_front_words("${cur_dir}" cur_dir "${trim}") + # replacing forward slashes with back slashes so filters can be generated (back slash used in parsing...) + STRING(REPLACE "/" "\\" FILTERS "${cur_dir}") + SOURCE_GROUP("${FILTERS}" FILES ${found_sources}) + endforeach() + + if(${rec}) + foreach(cur_dir ${dirs}) + ucm_dir_list("${cur_dir}" subdirs) + foreach(subdir ${subdirs}) + ucm_add_dir_impl(${result} ${rec} ${trim} "${cur_dir}/${subdir}" "${additional_ext}") + endforeach() + endforeach() + endif() +endmacro() + +# ucm_add_dirs +# Adds all files from directories traversing them recursively to a list of sources +# and generates filters according to their location (accepts relative paths only). +# Also this macro trims X times the front word from the filter string for visual studio filters. +macro(ucm_add_dirs) + cmake_parse_arguments(ARG "RECURSIVE" "TO;FILTER_POP" "ADDITIONAL_EXT" ${ARGN}) + + if(${ARG_TO} STREQUAL "") + message(FATAL_ERROR "Need to pass TO and a variable name to ucm_add_dirs()") + endif() + + if("${ARG_FILTER_POP}" STREQUAL "") + set(ARG_FILTER_POP 0) + endif() + + ucm_add_dir_impl(${ARG_TO} ${ARG_RECURSIVE} ${ARG_FILTER_POP} "${ARG_UNPARSED_ARGUMENTS}" "${ARG_ADDITIONAL_EXT}") +endmacro() + +# ucm_add_target +# Adds a target eligible for cotiring - unity build and/or precompiled header +macro(ucm_add_target) + cmake_parse_arguments(ARG "UNITY" "NAME;TYPE;PCH_FILE;CPP_PER_UNITY" "UNITY_EXCLUDED;SOURCES" ${ARGN}) + + if(NOT "${ARG_UNPARSED_ARGUMENTS}" STREQUAL "") + message(FATAL_ERROR "Unrecognized options passed to ucm_add_target()") + endif() + if("${ARG_NAME}" STREQUAL "") + message(FATAL_ERROR "Need to pass NAME and a name for the target to ucm_add_target()") + endif() + set(valid_types EXECUTABLE STATIC SHARED MODULE) + list(FIND valid_types "${ARG_TYPE}" is_type_valid) + if(${is_type_valid} STREQUAL "-1") + message(FATAL_ERROR "Need to pass TYPE and the type for the target [EXECUTABLE/STATIC/SHARED/MODULE] to ucm_add_target()") + endif() + if("${ARG_SOURCES}" STREQUAL "") + message(FATAL_ERROR "Need to pass SOURCES and a list of source files to ucm_add_target()") + endif() + + # init with the global unity flag + set(do_unity ${UCM_UNITY_BUILD}) + + # check the UNITY argument + if(NOT ARG_UNITY) + set(do_unity FALSE) + endif() + + # if target is excluded through the exclusion list + list(FIND UCM_UNITY_BUILD_EXCLUDE_TARGETS ${ARG_NAME} is_target_excluded) + if(NOT ${is_target_excluded} STREQUAL "-1") + set(do_unity FALSE) + endif() + + # unity build only for targets with > 1 source file (otherwise there will be an additional unnecessary target) + if(do_unity) # optimization + ucm_count_sources(${ARG_SOURCES} RESULT num_sources) + if(${num_sources} LESS 2) + set(do_unity FALSE) + endif() + endif() + + set(wanted_cotire ${do_unity}) + + # if cotire cannot be used + if(do_unity AND NOT ucm_with_cotire) + set(do_unity FALSE) + endif() + + # inform the developer that the current target might benefit from a unity build + if(NOT ARG_UNITY AND ${UCM_UNITY_BUILD}) + ucm_count_sources(${ARG_SOURCES} RESULT num_sources) + if(${num_sources} GREATER 1) + message(AUTHOR_WARNING "Target '${ARG_NAME}' may benefit from a unity build.\nIt has ${num_sources} sources - enable with UNITY flag") + endif() + endif() + + # prepare for the unity build + set(orig_target ${ARG_NAME}) + if(do_unity) + # the original target will be added with a different name than the requested + set(orig_target ${ARG_NAME}_ORIGINAL) + + # exclude requested files from unity build of the current target + foreach(excluded_file "${ARG_UNITY_EXCLUDED}") + set_source_files_properties(${excluded_file} PROPERTIES COTIRE_EXCLUDED TRUE) + endforeach() + endif() + + # add the original target + if(${ARG_TYPE} STREQUAL "EXECUTABLE") + add_executable(${orig_target} ${ARG_SOURCES}) + else() + add_library(${orig_target} ${ARG_TYPE} ${ARG_SOURCES}) + endif() + + if(do_unity) + # set the number of unity cpp files to be used for the unity target + if(NOT "${ARG_CPP_PER_UNITY}" STREQUAL "") + set_property(TARGET ${orig_target} PROPERTY COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "${ARG_CPP_PER_UNITY}") + else() + set_property(TARGET ${orig_target} PROPERTY COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "100") + endif() + + if(NOT "${ARG_PCH_FILE}" STREQUAL "") + set_target_properties(${orig_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${ARG_PCH_FILE}") + else() + set_target_properties(${orig_target} PROPERTIES COTIRE_ENABLE_PRECOMPILED_HEADER FALSE) + endif() + # add a unity target for the original one with the name intended for the original + set_target_properties(${orig_target} PROPERTIES COTIRE_UNITY_TARGET_NAME ${ARG_NAME}) + + # this is the library call that does the magic + cotire(${orig_target}) + set_target_properties(clean_cotire PROPERTIES FOLDER "CMakePredefinedTargets") + + # disable the original target and enable the unity one + get_target_property(unity_target_name ${orig_target} COTIRE_UNITY_TARGET_NAME) + set_target_properties(${orig_target} PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1) + set_target_properties(${unity_target_name} PROPERTIES EXCLUDE_FROM_ALL 0 EXCLUDE_FROM_DEFAULT_BUILD 0) + + # also set the name of the target output as the original one + set_target_properties(${unity_target_name} PROPERTIES OUTPUT_NAME ${ARG_NAME}) + if(UCM_NO_COTIRE_FOLDER) + # reset the folder property so all unity targets dont end up in a single folder in the solution explorer of VS + set_target_properties(${unity_target_name} PROPERTIES FOLDER "") + endif() + set_target_properties(all_unity PROPERTIES FOLDER "CMakePredefinedTargets") + elseif(NOT "${ARG_PCH_FILE}" STREQUAL "") + set(wanted_cotire TRUE) + if(ucm_with_cotire) + set_target_properties(${orig_target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE) + set_target_properties(${orig_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${ARG_PCH_FILE}") + cotire(${orig_target}) + set_target_properties(clean_cotire PROPERTIES FOLDER "CMakePredefinedTargets") + endif() + endif() + + # print a message if the target was requested to be cotired but it couldn't + if(wanted_cotire AND NOT ucm_with_cotire) + if(NOT COMMAND cotire) + message(AUTHOR_WARNING "Target \"${ARG_NAME}\" not cotired because cotire isn't loaded") + else() + message(AUTHOR_WARNING "Target \"${ARG_NAME}\" not cotired because cotire is older than the required version") + endif() + endif() +endmacro() diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000000..22f207fdba --- /dev/null +++ b/docs/README.md @@ -0,0 +1,25 @@ +# Table of Contents + +* [Read Me](/README.md) +* [Introduction](/docs/introduction/README.md) + * [Motivation](/docs/introduction/Motivation.md) + * [Examples](/docs/introduction/Examples.md) + * [Features](/docs/introduction/Features.md) + * [Installation](/docs/introduction/Installation.md) +* [Basics](/docs/basics/README.md) + * [Workbook](/docs/basics/Workbook.md) + * [Worksheet](/docs/basics/Worksheet.md) + * [Cell](/docs/basics/Cell.md) + * [Iteration](/docs/basics/Iteration.md) +* [Advanced](/docs/advanced/README.md) + * [Formatting](/docs/advanced/Formatting.md) + * [Properties](/docs/advanced/Properties.md) + * [Printing](/docs/advanced/Printing.md) + * [Encryption](/docs/advanced/Encryption.md) + * [Views](/docs/advanced/Views.md) +* [API Reference](/docs/api/README.md) + * [cell](/docs/api/cell.md) + * [cell_reference](/docs/api/cell_reference.md) +* [Change Log](/CHANGELOG.md) +* [Contributing](/CONTRIBUTING.md) +* [License](/LICENSE.md) diff --git a/docs/advanced/Encryption.md b/docs/advanced/Encryption.md new file mode 100644 index 0000000000..9db6035f4d --- /dev/null +++ b/docs/advanced/Encryption.md @@ -0,0 +1 @@ +## Encryption diff --git a/docs/advanced/Formatting.md b/docs/advanced/Formatting.md new file mode 100644 index 0000000000..c13439352b --- /dev/null +++ b/docs/advanced/Formatting.md @@ -0,0 +1,37 @@ + +# Formatting + +## Format vs. Style + +```c++ +#include +#include + +int main() +{ + xlnt::workbook wb; + auto cell = wb.active_sheet().cell("A1"); + return 0; +} +``` + +In the context of xlnt, format and style have specific distinct meanings. A style in xlnt corresponds to a named style created in the "Cell styles" dropdown in Excel. It must have a name and optionally any of: alignment, border, fill, font, number format, protection. A format in xlnt corresponds to the alignment, border, fill, font, number format, and protection settings applied to a cell via right-click->"Format Cells". A cell can have both a format and a style. The style properties will generally override the format properties. + +## Number Formatting + +```c++ +#include +#include + +int main() +{ + xlnt::workbook wb; + auto cell = wb.active_sheet().cell("A1"); + cell.number_format(xlnt::number_format::percentage()); + cell.value(0.513); + std::cout << cell.to_string() << std::endl; + return 0; +} +``` + +An xlnt::number_format is the format code used when displaying a value in a cell. For example, a number_format of "0.00" implies that the number 13.726 should be displayed as "13.73". Many number formats are built-in to Excel and can be access with xlnt::number_format static constructors. Other custom number formats can be created by passing a string to the [xlnt::number_format constructor](#cell-const-cell-amp). diff --git a/docs/advanced/Printing.md b/docs/advanced/Printing.md new file mode 100644 index 0000000000..a412b38dd4 --- /dev/null +++ b/docs/advanced/Printing.md @@ -0,0 +1 @@ +## Printing diff --git a/docs/advanced/Properties.md b/docs/advanced/Properties.md new file mode 100644 index 0000000000..15bf4de052 --- /dev/null +++ b/docs/advanced/Properties.md @@ -0,0 +1,54 @@ +# Properties + +```c++ +xlnt::workbook wb; + +wb.core_property(xlnt::core_property::category, "hors categorie"); +wb.core_property(xlnt::core_property::content_status, "good"); +wb.core_property(xlnt::core_property::created, xlnt::datetime(2017, 1, 15)); +wb.core_property(xlnt::core_property::creator, "me"); +wb.core_property(xlnt::core_property::description, "description"); +wb.core_property(xlnt::core_property::identifier, "id"); +wb.core_property(xlnt::core_property::keywords, { "wow", "such" }); +wb.core_property(xlnt::core_property::language, "Esperanto"); +wb.core_property(xlnt::core_property::last_modified_by, "someone"); +wb.core_property(xlnt::core_property::last_printed, xlnt::datetime(2017, 1, 15)); +wb.core_property(xlnt::core_property::modified, xlnt::datetime(2017, 1, 15)); +wb.core_property(xlnt::core_property::revision, "3"); +wb.core_property(xlnt::core_property::subject, "subject"); +wb.core_property(xlnt::core_property::title, "title"); +wb.core_property(xlnt::core_property::version, "1.0"); + +wb.extended_property(xlnt::extended_property::application, "xlnt"); +wb.extended_property(xlnt::extended_property::app_version, "0.9.3"); +wb.extended_property(xlnt::extended_property::characters, 123); +wb.extended_property(xlnt::extended_property::characters_with_spaces, 124); +wb.extended_property(xlnt::extended_property::company, "Incorporated Inc."); +wb.extended_property(xlnt::extended_property::dig_sig, "?"); +wb.extended_property(xlnt::extended_property::doc_security, 0); +wb.extended_property(xlnt::extended_property::heading_pairs, true); +wb.extended_property(xlnt::extended_property::hidden_slides, false); +wb.extended_property(xlnt::extended_property::h_links, 0); +wb.extended_property(xlnt::extended_property::hyperlink_base, 0); +wb.extended_property(xlnt::extended_property::hyperlinks_changed, true); +wb.extended_property(xlnt::extended_property::lines, 42); +wb.extended_property(xlnt::extended_property::links_up_to_date, false); +wb.extended_property(xlnt::extended_property::manager, "johnny"); +wb.extended_property(xlnt::extended_property::m_m_clips, "?"); +wb.extended_property(xlnt::extended_property::notes, "note"); +wb.extended_property(xlnt::extended_property::pages, 19); +wb.extended_property(xlnt::extended_property::paragraphs, 18); +wb.extended_property(xlnt::extended_property::presentation_format, "format"); +wb.extended_property(xlnt::extended_property::scale_crop, true); +wb.extended_property(xlnt::extended_property::shared_doc, false); +wb.extended_property(xlnt::extended_property::slides, 17); +wb.extended_property(xlnt::extended_property::template_, "template!"); +wb.extended_property(xlnt::extended_property::titles_of_parts, { "title" }); +wb.extended_property(xlnt::extended_property::total_time, 16); +wb.extended_property(xlnt::extended_property::words, 101); + +wb.custom_property("test", { 1, 2, 3 }); +wb.custom_property("Editor", "John Smith"); + +wb.save("lots_of_properties.xlsx"); +``` \ No newline at end of file diff --git a/docs/advanced/README.md b/docs/advanced/README.md new file mode 100644 index 0000000000..91d7eed0c3 --- /dev/null +++ b/docs/advanced/README.md @@ -0,0 +1,7 @@ +## Advanced + +* [Formatting](Formatting.md) +* [Properties](Properties.md) +* [Printing](Printing.md) +* [Encryption](Encryption.md) +* [Views](Views.md) \ No newline at end of file diff --git a/docs/advanced/Views.md b/docs/advanced/Views.md new file mode 100644 index 0000000000..06b4f28b89 --- /dev/null +++ b/docs/advanced/Views.md @@ -0,0 +1 @@ +## Views diff --git a/docs/api/README.md b/docs/api/README.md new file mode 100644 index 0000000000..5e11d117d4 --- /dev/null +++ b/docs/api/README.md @@ -0,0 +1,4 @@ +## API + +* [cell](cell.md) +* [cell_reference](cell_reference.md) diff --git a/docs/api/cell.md b/docs/api/cell.md new file mode 100644 index 0000000000..2e28c3907c --- /dev/null +++ b/docs/api/cell.md @@ -0,0 +1,188 @@ +# cell +## ```using xlnt::cell::type = cell_typeundefined``` +Alias xlnt::cell_type to xlnt::cell::type since it looks nicer. +## ```friend class detail::xlsx_consumerundefined``` +## ```friend class detail::xlsx_producerundefined``` +## ```friend struct detail::cell_implundefined``` +## ```static const std::unordered_map& xlnt::cell::error_codes()``` +Returns a map of error strings such as #DIV/0! and their associated indices. +## ```xlnt::cell::cell(const cell &)=default``` +Default copy constructor. +## ```bool xlnt::cell::has_value() const``` +Returns true if value has been set and has not been cleared using cell::clear_value(). +## ```T xlnt::cell::value() const``` +Returns the value of this cell as an instance of type T. Overloads exist for most C++ fundamental types like bool, int, etc. as well as for std::string and xlnt datetime types: date, time, datetime, and timedelta. +## ```void xlnt::cell::clear_value()``` +Makes this cell have a value of type null. All other cell attributes are retained. +## ```void xlnt::cell::value(std::nullptr_t)``` +Sets the type of this cell to null. +## ```void xlnt::cell::value(bool boolean_value)``` +Sets the value of this cell to the given boolean value. +## ```void xlnt::cell::value(int int_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(unsigned int int_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(long long int int_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(unsigned long long int int_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(float float_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(double float_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(long double float_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const date &date_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const time &time_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const datetime &datetime_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const timedelta &timedelta_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const std::string &string_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const char *string_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const rich_text &text_value)``` +Sets the value of this cell to the given value. +## ```void xlnt::cell::value(const cell other_cell)``` +Sets the value and formatting of this cell to that of other_cell. +## ```void xlnt::cell::value(const std::string &string_value, bool infer_type)``` +Analyzes string_value to determine its type, convert it to that type, and set the value of this cell to that converted value. +## ```type xlnt::cell::data_type() const``` +Returns the type of this cell. +## ```void xlnt::cell::data_type(type t)``` +Sets the type of this cell. This should usually be done indirectly by setting the value of the cell to a value of that type. +## ```bool xlnt::cell::garbage_collectible() const``` +There's no reason to keep a cell which has no value and is not a placeholder. Returns true if this cell has no value, style, isn't merged, etc. +## ```bool xlnt::cell::is_date() const``` +Returns true iff this cell's number format matches a date format. +## ```cell_reference xlnt::cell::reference() const``` +Returns a cell_reference that points to the location of this cell. +## ```column_t xlnt::cell::column() const``` +Returns the column of this cell. +## ```row_t xlnt::cell::row() const``` +Returns the row of this cell. +## ```std::pair xlnt::cell::anchor() const``` +Returns the location of this cell as an ordered pair (left, top). +## ```std::string xlnt::cell::hyperlink() const``` +Returns the URL of this cell's hyperlink. +## ```void xlnt::cell::hyperlink(const std::string &url)``` +Adds a hyperlink to this cell pointing to the URL of the given value. +## ```void xlnt::cell::hyperlink(const std::string &url, const std::string &display)``` +Adds a hyperlink to this cell pointing to the URI of the given value and sets the text value of the cell to the given parameter. +## ```void xlnt::cell::hyperlink(xlnt::cell target)``` +Adds an internal hyperlink to this cell pointing to the given cell. +## ```bool xlnt::cell::has_hyperlink() const``` +Returns true if this cell has a hyperlink set. +## ```class alignment xlnt::cell::computed_alignment() const``` +Returns the alignment that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order. +## ```class border xlnt::cell::computed_border() const``` +Returns the border that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order. +## ```class fill xlnt::cell::computed_fill() const``` +Returns the fill that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order. +## ```class font xlnt::cell::computed_font() const``` +Returns the font that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order. +## ```class number_format xlnt::cell::computed_number_format() const``` +Returns the number format that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order. +## ```class protection xlnt::cell::computed_protection() const``` +Returns the protection that should be used when displaying this cell graphically based on the workbook default, the cell-level format, and the named style applied to the cell in that order. +## ```bool xlnt::cell::has_format() const``` +Returns true if this cell has had a format applied to it. +## ```const class format xlnt::cell::format() const``` +Returns the format applied to this cell. If this cell has no format, an invalid_attribute exception will be thrown. +## ```void xlnt::cell::format(const class format new_format)``` +Applies the cell-level formatting of new_format to this cell. +## ```void xlnt::cell::clear_format()``` +Removes the cell-level formatting from this cell. This doesn't affect the style that may also be applied to the cell. Throws an invalid_attribute exception if no format is applied. +## ```class number_format xlnt::cell::number_format() const``` +Returns the number format of this cell. +## ```void xlnt::cell::number_format(const class number_format &format)``` +Creates a new format in the workbook, sets its number_format to the given format, and applies the format to this cell. +## ```class font xlnt::cell::font() const``` +Returns the font applied to the text in this cell. +## ```void xlnt::cell::font(const class font &font_)``` +Creates a new format in the workbook, sets its font to the given font, and applies the format to this cell. +## ```class fill xlnt::cell::fill() const``` +Returns the fill applied to this cell. +## ```void xlnt::cell::fill(const class fill &fill_)``` +Creates a new format in the workbook, sets its fill to the given fill, and applies the format to this cell. +## ```class border xlnt::cell::border() const``` +Returns the border of this cell. +## ```void xlnt::cell::border(const class border &border_)``` +Creates a new format in the workbook, sets its border to the given border, and applies the format to this cell. +## ```class alignment xlnt::cell::alignment() const``` +Returns the alignment of the text in this cell. +## ```void xlnt::cell::alignment(const class alignment &alignment_)``` +Creates a new format in the workbook, sets its alignment to the given alignment, and applies the format to this cell. +## ```class protection xlnt::cell::protection() const``` +Returns the protection of this cell. +## ```void xlnt::cell::protection(const class protection &protection_)``` +Creates a new format in the workbook, sets its protection to the given protection, and applies the format to this cell. +## ```bool xlnt::cell::has_style() const``` +Returns true if this cell has had a style applied to it. +## ```class style xlnt::cell::style()``` +Returns a wrapper pointing to the named style applied to this cell. +## ```const class style xlnt::cell::style() const``` +Returns a wrapper pointing to the named style applied to this cell. +## ```void xlnt::cell::style(const class style &new_style)``` +Sets the named style applied to this cell to a style named style_name. Equivalent to style(new_style.name()). +## ```void xlnt::cell::style(const std::string &style_name)``` +Sets the named style applied to this cell to a style named style_name. If this style has not been previously created in the workbook, a key_not_found exception will be thrown. +## ```void xlnt::cell::clear_style()``` +Removes the named style from this cell. An invalid_attribute exception will be thrown if this cell has no style. This will not affect the cell format of the cell. +## ```std::string xlnt::cell::formula() const``` +Returns the string representation of the formula applied to this cell. +## ```void xlnt::cell::formula(const std::string &formula)``` +Sets the formula of this cell to the given value. This formula string should begin with '='. +## ```void xlnt::cell::clear_formula()``` +Removes the formula from this cell. After this is called, has_formula() will return false. +## ```bool xlnt::cell::has_formula() const``` +Returns true if this cell has had a formula applied to it. +## ```std::string xlnt::cell::to_string() const``` +Returns a string representing the value of this cell. If the data type is not a string, it will be converted according to the number format. +## ```bool xlnt::cell::is_merged() const``` +Returns true iff this cell has been merged with one or more surrounding cells. +## ```void xlnt::cell::merged(bool merged)``` +Makes this a merged cell iff merged is true. Generally, this shouldn't be called directly. Instead, use worksheet::merge_cells on its parent worksheet. +## ```std::string xlnt::cell::error() const``` +Returns the error string that is stored in this cell. +## ```void xlnt::cell::error(const std::string &error)``` +Directly assigns the value of this cell to be the given error. +## ```cell xlnt::cell::offset(int column, int row)``` +Returns a cell from this cell's parent workbook at a relative offset given by the parameters. +## ```class worksheet xlnt::cell::worksheet()``` +Returns the worksheet that owns this cell. +## ```const class worksheet xlnt::cell::worksheet() const``` +Returns the worksheet that owns this cell. +## ```class workbook& xlnt::cell::workbook()``` +Returns the workbook of the worksheet that owns this cell. +## ```const class workbook& xlnt::cell::workbook() const``` +Returns the workbook of the worksheet that owns this cell. +## ```calendar xlnt::cell::base_date() const``` +Returns the base date of the parent workbook. +## ```std::string xlnt::cell::check_string(const std::string &to_check)``` +Returns to_check after verifying and fixing encoding, size, and illegal characters. +## ```bool xlnt::cell::has_comment()``` +Returns true if this cell has a comment applied. +## ```void xlnt::cell::clear_comment()``` +Deletes the comment applied to this cell if it exists. +## ```class comment xlnt::cell::comment()``` +Gets the comment applied to this cell. +## ```void xlnt::cell::comment(const std::string &text, const std::string &author="Microsoft Office User")``` +Creates a new comment with the given text and optional author and applies it to the cell. +## ```void xlnt::cell::comment(const std::string &comment_text, const class font &comment_font, const std::string &author="Microsoft Office User")``` +Creates a new comment with the given text, formatting, and optional author and applies it to the cell. +## ```void xlnt::cell::comment(const class comment &new_comment)``` +Apply the comment provided as the only argument to the cell. +## ```double xlnt::cell::width() const``` +Returns the width of this cell in pixels. +## ```double xlnt::cell::height() const``` +Returns the height of this cell in pixels. +## ```cell& xlnt::cell::operator=(const cell &rhs)``` +Makes this cell interally point to rhs. The cell data originally pointed to by this cell will be unchanged. +## ```bool xlnt::cell::operator==(const cell &comparand) const``` +Returns true if this cell the same cell as comparand (compared by reference). +## ```bool xlnt::cell::operator==(std::nullptr_t) const``` +Returns true if this cell is uninitialized. diff --git a/docs/api/cell_reference.md b/docs/api/cell_reference.md new file mode 100644 index 0000000000..e4ed5645ce --- /dev/null +++ b/docs/api/cell_reference.md @@ -0,0 +1,55 @@ +# cell_reference +## ```static std::pair xlnt::cell_reference::split_reference(const std::string &reference_string)``` +Splits a coordinate string like "A1" into an equivalent pair like {"A", 1}. +## ```static std::pair xlnt::cell_reference::split_reference(const std::string &reference_string, bool &absolute_column, bool &absolute_row)``` +Splits a coordinate string like "A1" into an equivalent pair like {"A", 1}. Reference parameters absolute_column and absolute_row will be set to true if column part or row part are prefixed by a dollar-sign indicating they are absolute, otherwise false. +## ```xlnt::cell_reference::cell_reference()``` +Default constructor makes a reference to the top-left-most cell, "A1". +## ```xlnt::cell_reference::cell_reference(const char *reference_string)``` +Constructs a cell_reference from a string reprenting a cell coordinate (e.g. $B14). +## ```xlnt::cell_reference::cell_reference(const std::string &reference_string)``` +Constructs a cell_reference from a string reprenting a cell coordinate (e.g. $B14). +## ```xlnt::cell_reference::cell_reference(column_t column, row_t row)``` +Constructs a cell_reference from a 1-indexed column index and row index. +## ```cell_reference& xlnt::cell_reference::make_absolute(bool absolute_column=true, bool absolute_row=true)``` +Converts a coordinate to an absolute coordinate string (e.g. B12 -> $B$12) Defaulting to true, absolute_column and absolute_row can optionally control whether the resulting cell_reference has an absolute column (e.g. B12 -> $B12) and absolute row (e.g. B12 -> B$12) respectively. +## ```bool xlnt::cell_reference::column_absolute() const``` +Returns true if the reference refers to an absolute column, otherwise false. +## ```void xlnt::cell_reference::column_absolute(bool absolute_column)``` +Makes this reference have an absolute column if absolute_column is true, otherwise not absolute. +## ```bool xlnt::cell_reference::row_absolute() const``` +Returns true if the reference refers to an absolute row, otherwise false. +## ```void xlnt::cell_reference::row_absolute(bool absolute_row)``` +Makes this reference have an absolute row if absolute_row is true, otherwise not absolute. +## ```column_t xlnt::cell_reference::column() const``` +Returns a string that identifies the column of this reference (e.g. second column from left is "B") +## ```void xlnt::cell_reference::column(const std::string &column_string)``` +Sets the column of this reference from a string that identifies a particular column. +## ```column_t::index_t xlnt::cell_reference::column_index() const``` +Returns a 1-indexed numeric index of the column of this reference. +## ```void xlnt::cell_reference::column_index(column_t column)``` +Sets the column of this reference from a 1-indexed number that identifies a particular column. +## ```row_t xlnt::cell_reference::row() const``` +Returns a 1-indexed numeric index of the row of this reference. +## ```void xlnt::cell_reference::row(row_t row)``` +Sets the row of this reference from a 1-indexed number that identifies a particular row. +## ```cell_reference xlnt::cell_reference::make_offset(int column_offset, int row_offset) const``` +Returns a cell_reference offset from this cell_reference by the number of columns and rows specified by the parameters. A negative value for column_offset or row_offset results in a reference above or left of this cell_reference, respectively. +## ```std::string xlnt::cell_reference::to_string() const``` +Returns a string like "A1" for cell_reference(1, 1). +## ```range_reference xlnt::cell_reference::to_range() const``` +Returns a 1x1 range_reference containing only this cell_reference. +## ```range_reference xlnt::cell_reference::operator,(const cell_reference &other) const``` +I've always wanted to overload the comma operator. cell_reference("A", 1), cell_reference("B", 1) will return range_reference(cell_reference("A", 1), cell_reference("B", 1)) +## ```bool xlnt::cell_reference::operator==(const cell_reference &comparand) const``` +Returns true if this reference is identical to comparand including in absoluteness of column and row. +## ```bool xlnt::cell_reference::operator==(const std::string &reference_string) const``` +Constructs a cell_reference from reference_string and return the result of their comparison. +## ```bool xlnt::cell_reference::operator==(const char *reference_string) const``` +Constructs a cell_reference from reference_string and return the result of their comparison. +## ```bool xlnt::cell_reference::operator!=(const cell_reference &comparand) const``` +Returns true if this reference is not identical to comparand including in absoluteness of column and row. +## ```bool xlnt::cell_reference::operator!=(const std::string &reference_string) const``` +Constructs a cell_reference from reference_string and return the result of their comparison. +## ```bool xlnt::cell_reference::operator!=(const char *reference_string) const``` +Constructs a cell_reference from reference_string and return the result of their comparison. diff --git a/docs/basics/Cell.md b/docs/basics/Cell.md new file mode 100644 index 0000000000..2f13df6829 --- /dev/null +++ b/docs/basics/Cell.md @@ -0,0 +1 @@ +## Cell diff --git a/docs/basics/Iteration.md b/docs/basics/Iteration.md new file mode 100644 index 0000000000..4d3b83c447 --- /dev/null +++ b/docs/basics/Iteration.md @@ -0,0 +1 @@ +## Iteration diff --git a/docs/basics/MemoryModel.md b/docs/basics/MemoryModel.md new file mode 100644 index 0000000000..f592addc58 --- /dev/null +++ b/docs/basics/MemoryModel.md @@ -0,0 +1,31 @@ + +# Memory Model + +```c++ +#include +#include + +void set_cell(xlnt::cell cell, int value) +{ + cell.value(value); +} + +xlnt::workbook create_wb() +{ + xlnt::workbook wb; + auto ws = wb.active_sheet(); + set_cell(wb.cell("A1"), 2); + return wb; +} + +int main() +{ + auto wb = create_wb(); + std::cout << wb.value() << std::endl; + return 0; +} +``` + +xlnt uses the pimpl idiom for most of its core data structures. This primary reason for choosing this technique was simplifying usage of the library. Instead of using pointers or references, classes can be passed around by value. Internally they hold a pointer to memory which is within the primary workbook implementation struct. Methods called on the wrapper object dereference the opaque pointer and manipulate its data directly. + +For the user, this means that workbooks, worksheets, cells, formats, and styles can be passed and stored by value. diff --git a/docs/basics/README.md b/docs/basics/README.md new file mode 100644 index 0000000000..3e3b288769 --- /dev/null +++ b/docs/basics/README.md @@ -0,0 +1,6 @@ +## Basics + +* [Workbook](/docs/basics/Workbook.md) +* [Worksheet](/docs/basics/Worksheet.md) +* [Cell](/docs/basics/Cell.md) +* [Iteration](/docs/basics/Iteration.md) diff --git a/docs/basics/Workbook.md b/docs/basics/Workbook.md new file mode 100644 index 0000000000..d4138020d2 --- /dev/null +++ b/docs/basics/Workbook.md @@ -0,0 +1 @@ +## Workbook diff --git a/docs/basics/Worksheet.md b/docs/basics/Worksheet.md new file mode 100644 index 0000000000..136663f969 --- /dev/null +++ b/docs/basics/Worksheet.md @@ -0,0 +1 @@ +## Worksheet diff --git a/docs/introduction/Examples.md b/docs/introduction/Examples.md new file mode 100644 index 0000000000..a4680f4271 --- /dev/null +++ b/docs/introduction/Examples.md @@ -0,0 +1,195 @@ +## Examples + +### Simple - reading from an existing xlsx spread sheet. + +The following C plus plus code will read the values from an xlsx file and print the string values to the screen. This is a very simple example to get you started. + +```c++ +#include +#include + +int main() +{ + xlnt::workbook wb; + wb.load("/home/timothymccallum/test.xlsx"); + auto ws = wb.active_sheet(); + std::clog << "Processing spread sheet" << std::endl; + for (auto row : ws.rows(false)) + { + for (auto cell : row) + { + std::clog << cell.to_string() << std::endl; + } + } + std::clog << "Processing complete" << std::endl; + return 0; +} +``` +Save the contents of the above file +``` +/home/timothymccallum/process.cpp +``` +Compile by typing the following command +``` +g++ -std=c++14 -lxlnt process.cpp -o process +``` +Excecute by typing the following command +``` +./process +``` +The output of the program, in my case, is as follows +``` +Processing spread sheet +This is cell A1. +This is cell B1 +… and this is cell C1 +We are now on the second row at cell A2 +B2 +C2 +Processing complete +``` +As you can see the process.cpp file simply walks through the spread sheet values row by row and column by column (A1, B1, C1, A2, B2, C2 and so on). + +### Simple - storing a spread sheet in a 2 dimensional C++ Vector for further processing + +Loading a spread sheet into a Vector provides oppourtunities for you to perform high performance processing. There will be more examples on performing fast look-ups, merging data, performing deduplication and more. For now, let's just learn how to get the spread sheet loaded into memory. + +```c++ +#include +#include +#include + +int main() +{ + xlnt::workbook wb; + wb.load("/home/timothymccallum/test.xlsx"); + auto ws = wb.active_sheet(); + std::clog << "Processing spread sheet" << std::endl; + std::clog << "Creating a single vector which stores the whole spread sheet" << std::endl; + std::vector< std::vector > theWholeSpreadSheet; + for (auto row : ws.rows(false)) + { + std::clog << "Creating a fresh vector for just this row in the spread sheet" << std::endl; + std::vector aSingleRow; + for (auto cell : row) + { + std::clog << "Adding this cell to the row" << std::endl; + aSingleRow.push_back(cell.to_string()); + } + std::clog << "Adding this entire row to the vector which stores the whole spread sheet" << std::endl; + theWholeSpreadSheet.push_back(aSingleRow); + } + std::clog << "Processing complete" << std::endl; + std::clog << "Reading the vector and printing output to the screen" << std::endl; + for (int rowInt = 0; rowInt < theWholeSpreadSheet.size(); rowInt++) + { + for (int colInt = 0; colInt < theWholeSpreadSheet.at(rowInt).size(); colInt++) + { + std::cout << theWholeSpreadSheet.at(rowInt).at(colInt) << std::endl; + } + } + return 0; +} +``` +Save the contents of the above file +``` +/home/timothymccallum/process.cpp +``` +Compile by typing the following command +``` +g++ -std=c++14 -lxlnt process.cpp -o process +``` +Excecute by typing the following command +``` +./process +``` +The output of the program, in my case, is as follows +``` +Processing spread sheet +Creating a single vector which stores the whole spread sheet +Creating a fresh vector for just this row in the spread sheet +Adding this cell to the row +Adding this cell to the row +Adding this cell to the row +Adding this entire row to the vector which stores the whole spread sheet +Creating a fresh vector for just this row in the spread sheet +Adding this cell to the row +Adding this cell to the row +Adding this cell to the row +Adding this entire row to the vector which stores the whole spread sheet +Processing complete +Reading the vector and printing output to the screen +This is cell A1. +This is cell B1 +… and this is cell C1 +We are now on the second row at cell A2 +B2 +C2 +``` +You will have noticed that this process is very fast. If you type the "time" as shown below, you can measure just how fast loading and retrieving your spread sheet is, using xlnt; In this case only a fraction of a second. More on this later. +``` +time ./process +... +real 0m0.044s +``` +### Simple - writing values to a new xlsx spread sheet. + +```c++ +#include +#include +#include +#include + +int main() +{ + //Creating a 2 dimensional vector which we will write values to + std::vector< std::vector > wholeWorksheet; + //Looping through each row (100 rows as per the second argument in the for loop) + for (int outer = 0; outer < 100; outer++) + { + //Creating a fresh vector for a fresh row + std::vector singleRow; + //Looping through each of the columns (100 as per the second argument in the for loop) in this particular row + for(int inner = 0; inner < 100; inner++) + { + //Adding a single value in each cell of the row + std::string val = std::to_string(inner + 1); + singleRow.push_back(val); + } + //Adding the single row to the 2 dimensional vector + wholeWorksheet.push_back(singleRow); + std::clog << "Writing to row " << outer << " in the vector " << std::endl; + } + //Writing to the spread sheet + //Creating the output workbook + std::clog << "Creating workbook" << std::endl; + xlnt::workbook wbOut; + //Setting the destination output file name + std::string dest_filename = "output.xlsx"; + //Creating the output worksheet + xlnt::worksheet wsOut = wbOut.active_sheet(); + //Giving the output worksheet a title/name + wsOut.title("data"); + //We will now be looping through the 2 dimensional vector which we created above + //In this case we have two iterators one for the outer loop (row) and one for the inner loop (column) + std::clog << "Looping through vector and writing to spread sheet" << std::endl; + for (int fOut = 0; fOut < wholeWorksheet.size(); fOut++) + { + std::clog << "Row" << fOut << std::endl; + for (int fIn = 0; fIn < wholeWorksheet.at(fOut).size(); fIn++) + { + //Take notice of the difference between accessing the vector and accessing the work sheet + //As you may already know Excel spread sheets start at row 1 and column 1 (not row 0 and column 0 like you would expect from a C++ vector) + //In short the xlnt cell reference starts at column 1 row 1 (hence the + 1s below) and the vector reference starts at row 0 and column 0 + wsOut.cell(xlnt::cell_reference(fIn + 1, fOut + 1)).value(wholeWorksheet.at(fOut).at(fIn)); + //Further clarification to avoid confusion + //Cell reference arguments are (column number, row number); e.g. cell_reference(fIn + 1, fOut + 1) + //Vector arguments are (row number, column number); e.g. wholeWorksheet.at(fOut).at(fIn) + } + } + std::clog << "Finished writing spread sheet" << std::endl; + wbOut.save(dest_filename); + return 0; +} +``` +This process is also quite quick; a time command showed that xlnt was able to create and write 10, 000 values to the output spread sheet in 0.582 seconds. diff --git a/docs/introduction/Features.md b/docs/introduction/Features.md new file mode 100644 index 0000000000..82e2b53bac --- /dev/null +++ b/docs/introduction/Features.md @@ -0,0 +1,54 @@ + +## Features + +| Feature | Read | Edit | Write | +|---------------------------------------------------------------------|------|------|-------| +| Excel-style Workbook | ✓ | ✓ | ✓ | +| LibreOffice-style Workbook | ✓ | ✓ | ✓ | +| Numbers-style Workbook | ✓ | ✓ | ✓ | +| Encrypted Workbook (Excel 2007-2010) | ✓ | ✓ | | +| Encrypted Workbook (Excel 2013-2016) | ✓ | ✓ | | +| Excel Binary Workbook (.xlsb) | | | | +| Excel Macro-Enabled Workbook (.xlsm) | | | | +| Excel Macro-Enabled Template (.xltm) | | | | +| Document Properties | ✓ | ✓ | ✓ | +| Numeric Cell Values | ✓ | ✓ | ✓ | +| Inline String Cell Values | ✓ | ✓ | ✓ | +| Shared String Cell Values | ✓ | ✓ | ✓ | +| Shared String Text Run Formatting (e.g. varied fonts within a cell) | ✓ | ✓ | ✓ | +| Hyperlink Cell Values | | | | +| Formula Cell Values | | | | +| Formula Evaluation | | | | +| Page Margins | ✓ | ✓ | ✓ | +| Page Setup | | | | +| Print Area | | | | +| Comments | ✓ | ✓ | | +| Header and Footer | | | | +| Custom Views | | | | +| Charts | | | | +| Chartsheets | | | | +| Dialogsheets | | | | +| Themes | ✓ | | ✓ | +| Cell Styles | ✓ | ✓ | ✓ | +| Cell Formats | ✓ | ✓ | ✓ | +| Formatting->Alignment (e.g. right align) | ✓ | ✓ | ✓ | +| Formatting->Border (e.g. red cell outline) | ✓ | ✓ | ✓ | +| Formatting->Fill (e.g. green cell background) | ✓ | ✓ | ✓ | +| Formatting->Font (e.g. blue cell text) | ✓ | ✓ | ✓ | +| Formatting->Number Format (e.g. show 2 decimals) | ✓ | ✓ | ✓ | +| Formatting->Protection (e.g. hide formulas) | ✓ | ✓ | ✓ | +| Column Styles | | | | +| Row Styles | | | | +| Sheet Styles | | | | +| Conditional Formatting | | | | +| Tables | | | | +| Table Formatting | | | | +| Pivot Tables | | | | +| XLSX Thumbnail | ✓ | | ✓ | +| Custom OOXML Properties | | | | +| Custom OOXML Parts | | | | +| Drawing | | | | +| Text Box | | | | +| WordArt | | | | +| Embedded Content (e.g. images) | | | | +| Excel VBA | | | | diff --git a/docs/introduction/Installation.md b/docs/introduction/Installation.md new file mode 100644 index 0000000000..8dddf3c8ab --- /dev/null +++ b/docs/introduction/Installation.md @@ -0,0 +1,79 @@ +# Getting xlnt + +## Binaries + +## Homebrew + +## Arch + +xlnt can be [found](https://aur.archlinux.org/packages/xlnt/) on the AUR. + +## vcpkg +`vcpkg` installs x86 by default +``` +.\vcpkg install xlnt +``` +if you need x64 use the following command +``` +.\vcpkg install xlnt:x64-windows +``` + +## Compiling xlnt 1.x.x from Source on Ubuntu 16.04 LTS (Xenial Xerus) +Time required: Approximately 5 minutes (depending on your internet speed) +``` +sudo apt-get update +sudo apt-get upgrade +sudo apt-get install cmake +sudo apt-get install zlibc +``` +The following steps update the compiler and set the appropriate environment variables - see note [1] below for the reason why we need to update the standard available compiler +``` +sudo add-apt-repository ppa:ubuntu-toolchain-r/test +sudo apt update +sudo apt-get upgrade +sudo apt-get install gcc-6 g++-6 +export CC=/usr/bin/gcc-6 +export CXX=/usr/bin/g++-6 +``` +The following steps will intall xlnt +``` +git clone https://github.com/tfussell/xlnt.git xlnt --recurse-submodules +cd xlnt +cmake . +make -j 2 +sudo make install +``` +The following step will map the shared library names to the location of the corresponding shared library files +``` +sudo ldconfig +``` +xlnt will now be ready to use on your Ubuntu instance. + +[1] +Xlnt requires a minimum of gcc 6.2.0 +The most recent gcc version available using the standard APT repositories is gcc 5.4.0 (obtained through build-essential 12.1ubuntu2). If these older versions of gcc are used an error "workbook.cpp error 1502:31 'extended_property' is not a class, namespace or enumeration" will occur during the xlnt make command. + +## Compiling from Source + +Build configurations for Visual Studio, GNU Make, Ninja, and Xcode can be created using [cmake](https://cmake.org/) v3.2+. A full list of cmake generators can be found [here](https://cmake.org/cmake/help/v3.0/manual/cmake-generators.7.html). A basic build would look like (starting in the root xlnt directory): + +```bash +mkdir build +cd build +cmake .. +make -j8 +``` + +The resulting shared (e.g. libxlnt.dylib) library would be found in the build/lib directory. Other cmake configuration options for xlnt can be found using "cmake -LH". These options include building a static library instead of shared and whether to build sample executables or not. An example of building a static library with an Xcode project: + +```bash +mkdir build +cd build +cmake -D STATIC=ON -G Xcode .. +cmake --build . +cd bin && ./xlnt.test +``` +*Note for Windows: cmake defaults to building a 32-bit library project. To build a 64-bit library, use the Win64 generator* +```bash +cmake -G "Visual Studio 14 2015 Win64" .. +``` diff --git a/docs/introduction/Motivation.md b/docs/introduction/Motivation.md new file mode 100644 index 0000000000..266273bc67 --- /dev/null +++ b/docs/introduction/Motivation.md @@ -0,0 +1 @@ +## Motivation diff --git a/docs/introduction/README.md b/docs/introduction/README.md new file mode 100644 index 0000000000..22f14d8185 --- /dev/null +++ b/docs/introduction/README.md @@ -0,0 +1,6 @@ +## Introduction + +* [Motivation](Motivation.md) +* [Examples](Examples.md) +* [Features](Features.md) +* [Installation](Installation.md) \ No newline at end of file diff --git a/docs/template.ejs b/docs/template.ejs new file mode 100644 index 0000000000..4d03787ea1 --- /dev/null +++ b/docs/template.ejs @@ -0,0 +1,3 @@ +<% for(var i = 0; i < summary.length; i++) {%> +<%- summary[i].content %> +<% } %> diff --git a/docs/tools/Doxyfile b/docs/tools/Doxyfile new file mode 100644 index 0000000000..17f3c18028 --- /dev/null +++ b/docs/tools/Doxyfile @@ -0,0 +1,315 @@ +# Doxyfile 1.8.10 + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- +DOXYFILE_ENCODING = UTF-8 +PROJECT_NAME = "xlnt" +PROJECT_NUMBER = +PROJECT_BRIEF = +PROJECT_LOGO = +OUTPUT_DIRECTORY = +CREATE_SUBDIRS = NO +ALLOW_UNICODE_NAMES = NO +OUTPUT_LANGUAGE = English +BRIEF_MEMBER_DESC = YES +REPEAT_BRIEF = YES +ABBREVIATE_BRIEF = +ALWAYS_DETAILED_SEC = NO +INLINE_INHERITED_MEMB = NO +FULL_PATH_NAMES = YES +STRIP_FROM_PATH = +STRIP_FROM_INC_PATH = +SHORT_NAMES = NO +JAVADOC_AUTOBRIEF = NO +QT_AUTOBRIEF = NO +MULTILINE_CPP_IS_BRIEF = NO +INHERIT_DOCS = YES +SEPARATE_MEMBER_PAGES = NO +TAB_SIZE = 4 +ALIASES = +TCL_SUBST = +OPTIMIZE_OUTPUT_FOR_C = NO +OPTIMIZE_OUTPUT_JAVA = NO +OPTIMIZE_FOR_FORTRAN = NO +OPTIMIZE_OUTPUT_VHDL = NO +EXTENSION_MAPPING = +MARKDOWN_SUPPORT = YES +AUTOLINK_SUPPORT = YES +BUILTIN_STL_SUPPORT = NO +CPP_CLI_SUPPORT = NO +SIP_SUPPORT = NO +IDL_PROPERTY_SUPPORT = YES +DISTRIBUTE_GROUP_DOC = NO +GROUP_NESTED_COMPOUNDS = NO +SUBGROUPING = YES +INLINE_GROUPED_CLASSES = NO +INLINE_SIMPLE_STRUCTS = NO +TYPEDEF_HIDES_STRUCT = NO +LOOKUP_CACHE_SIZE = 0 +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- +EXTRACT_ALL = NO +EXTRACT_PRIVATE = NO +EXTRACT_PACKAGE = NO +EXTRACT_STATIC = NO +EXTRACT_LOCAL_CLASSES = YES +EXTRACT_LOCAL_METHODS = NO +EXTRACT_ANON_NSPACES = NO +HIDE_UNDOC_MEMBERS = NO +HIDE_UNDOC_CLASSES = NO +HIDE_FRIEND_COMPOUNDS = NO +HIDE_IN_BODY_DOCS = NO +INTERNAL_DOCS = NO +CASE_SENSE_NAMES = NO +HIDE_SCOPE_NAMES = NO +HIDE_COMPOUND_REFERENCE= NO +SHOW_INCLUDE_FILES = YES +SHOW_GROUPED_MEMB_INC = NO +FORCE_LOCAL_INCLUDES = NO +INLINE_INFO = YES +SORT_MEMBER_DOCS = YES +SORT_BRIEF_DOCS = NO +SORT_MEMBERS_CTORS_1ST = NO +SORT_GROUP_NAMES = NO +SORT_BY_SCOPE_NAME = NO +STRICT_PROTO_MATCHING = NO +GENERATE_TODOLIST = YES +GENERATE_TESTLIST = YES +GENERATE_BUGLIST = YES +GENERATE_DEPRECATEDLIST= YES +ENABLED_SECTIONS = +MAX_INITIALIZER_LINES = 30 +SHOW_USED_FILES = YES +SHOW_FILES = YES +SHOW_NAMESPACES = YES +FILE_VERSION_FILTER = +LAYOUT_FILE = +CITE_BIB_FILES = +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- +QUIET = YES +WARNINGS = YES +WARN_IF_UNDOCUMENTED = YES +WARN_IF_DOC_ERROR = YES +WARN_NO_PARAMDOC = NO +WARN_FORMAT = "$file:$line: $text" +WARN_LOGFILE = +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- +INPUT = ../include/xlnt +INPUT_ENCODING = UTF-8 +FILE_PATTERNS = +RECURSIVE = YES +EXCLUDE = +EXCLUDE_SYMLINKS = NO +EXCLUDE_PATTERNS = +EXCLUDE_SYMBOLS = +EXAMPLE_PATH = +EXAMPLE_PATTERNS = +EXAMPLE_RECURSIVE = NO +IMAGE_PATH = +INPUT_FILTER = +FILTER_PATTERNS = +FILTER_SOURCE_FILES = NO +FILTER_SOURCE_PATTERNS = +USE_MDFILE_AS_MAINPAGE = +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- +SOURCE_BROWSER = NO +INLINE_SOURCES = NO +STRIP_CODE_COMMENTS = YES +REFERENCED_BY_RELATION = NO +REFERENCES_RELATION = NO +REFERENCES_LINK_SOURCE = YES +SOURCE_TOOLTIPS = YES +USE_HTAGS = NO +VERBATIM_HEADERS = YES +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- +ALPHABETICAL_INDEX = YES +COLS_IN_ALPHA_INDEX = 5 +IGNORE_PREFIX = +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- +GENERATE_HTML = NO +HTML_OUTPUT = html +HTML_FILE_EXTENSION = .html +HTML_HEADER = +HTML_FOOTER = +HTML_STYLESHEET = +HTML_EXTRA_STYLESHEET = +HTML_EXTRA_FILES = +HTML_COLORSTYLE_HUE = 220 +HTML_COLORSTYLE_SAT = 100 +HTML_COLORSTYLE_GAMMA = 80 +HTML_TIMESTAMP = NO +HTML_DYNAMIC_SECTIONS = NO +HTML_INDEX_NUM_ENTRIES = 100 +GENERATE_DOCSET = NO +DOCSET_FEEDNAME = "Doxygen generated docs" +DOCSET_BUNDLE_ID = org.doxygen.Project +DOCSET_PUBLISHER_ID = org.doxygen.Publisher +DOCSET_PUBLISHER_NAME = Publisher +GENERATE_HTMLHELP = NO +CHM_FILE = +HHC_LOCATION = +GENERATE_CHI = NO +CHM_INDEX_ENCODING = +BINARY_TOC = NO +TOC_EXPAND = NO +GENERATE_QHP = NO +QCH_FILE = +QHP_NAMESPACE = org.doxygen.Project +QHP_VIRTUAL_FOLDER = doc +QHP_CUST_FILTER_NAME = +QHP_CUST_FILTER_ATTRS = +QHP_SECT_FILTER_ATTRS = +QHG_LOCATION = +GENERATE_ECLIPSEHELP = NO +ECLIPSE_DOC_ID = org.doxygen.Project +DISABLE_INDEX = NO +GENERATE_TREEVIEW = NO +ENUM_VALUES_PER_LINE = 4 +TREEVIEW_WIDTH = 250 +EXT_LINKS_IN_WINDOW = NO +FORMULA_FONTSIZE = 10 +FORMULA_TRANSPARENT = YES +USE_MATHJAX = NO +MATHJAX_FORMAT = HTML-CSS +MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest +MATHJAX_EXTENSIONS = +MATHJAX_CODEFILE = +SEARCHENGINE = YES +SERVER_BASED_SEARCH = NO +EXTERNAL_SEARCH = NO +SEARCHENGINE_URL = +SEARCHDATA_FILE = searchdata.xml +EXTERNAL_SEARCH_ID = +EXTRA_SEARCH_MAPPINGS = +#--------------------------------------------------------------------------- +# Configuration options related to the LaTeX output +#--------------------------------------------------------------------------- +GENERATE_LATEX = NO +LATEX_OUTPUT = latex +LATEX_CMD_NAME = latex +MAKEINDEX_CMD_NAME = makeindex +COMPACT_LATEX = NO +PAPER_TYPE = a4 +EXTRA_PACKAGES = +LATEX_HEADER = +LATEX_FOOTER = +LATEX_EXTRA_STYLESHEET = +LATEX_EXTRA_FILES = +PDF_HYPERLINKS = YES +USE_PDFLATEX = YES +LATEX_BATCHMODE = NO +LATEX_HIDE_INDICES = NO +LATEX_SOURCE_CODE = NO +LATEX_BIB_STYLE = plain +#--------------------------------------------------------------------------- +# Configuration options related to the RTF output +#--------------------------------------------------------------------------- +GENERATE_RTF = NO +RTF_OUTPUT = rtf +COMPACT_RTF = NO +RTF_HYPERLINKS = NO +RTF_STYLESHEET_FILE = +RTF_EXTENSIONS_FILE = +RTF_SOURCE_CODE = NO +#--------------------------------------------------------------------------- +# Configuration options related to the man page output +#--------------------------------------------------------------------------- +GENERATE_MAN = NO +MAN_OUTPUT = man +MAN_EXTENSION = .3 +MAN_SUBDIR = +MAN_LINKS = NO +#--------------------------------------------------------------------------- +# Configuration options related to the XML output +#--------------------------------------------------------------------------- +GENERATE_XML = YES +XML_OUTPUT = doxyxml +XML_PROGRAMLISTING = YES +#--------------------------------------------------------------------------- +# Configuration options related to the DOCBOOK output +#--------------------------------------------------------------------------- +GENERATE_DOCBOOK = NO +DOCBOOK_OUTPUT = docbook +DOCBOOK_PROGRAMLISTING = NO +#--------------------------------------------------------------------------- +# Configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- +GENERATE_AUTOGEN_DEF = NO +#--------------------------------------------------------------------------- +# Configuration options related to the Perl module output +#--------------------------------------------------------------------------- +GENERATE_PERLMOD = NO +PERLMOD_LATEX = NO +PERLMOD_PRETTY = YES +PERLMOD_MAKEVAR_PREFIX = +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- +ENABLE_PREPROCESSING = YES +MACRO_EXPANSION = YES +EXPAND_ONLY_PREDEF = YES +SEARCH_INCLUDES = YES +INCLUDE_PATH = ../include +INCLUDE_FILE_PATTERNS = +PREDEFINED = XLNT_API= +EXPAND_AS_DEFINED = +SKIP_FUNCTION_MACROS = YES +#--------------------------------------------------------------------------- +# Configuration options related to external references +#--------------------------------------------------------------------------- +TAGFILES = +GENERATE_TAGFILE = +ALLEXTERNALS = NO +EXTERNAL_GROUPS = YES +EXTERNAL_PAGES = YES +PERL_PATH = /usr/bin/perl +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- +CLASS_DIAGRAMS = YES +MSCGEN_PATH = +DIA_PATH = +HIDE_UNDOC_RELATIONS = YES +HAVE_DOT = NO +DOT_NUM_THREADS = 0 +DOT_FONTNAME = Helvetica +DOT_FONTSIZE = 10 +DOT_FONTPATH = +CLASS_GRAPH = YES +COLLABORATION_GRAPH = YES +GROUP_GRAPHS = YES +UML_LOOK = NO +UML_LIMIT_NUM_FIELDS = 10 +TEMPLATE_RELATIONS = NO +INCLUDE_GRAPH = YES +INCLUDED_BY_GRAPH = YES +CALL_GRAPH = NO +CALLER_GRAPH = NO +GRAPHICAL_HIERARCHY = YES +DIRECTORY_GRAPH = YES +DOT_IMAGE_FORMAT = png +INTERACTIVE_SVG = NO +DOT_PATH = +DOTFILE_DIRS = +MSCFILE_DIRS = +DIAFILE_DIRS = +PLANTUML_JAR_PATH = +PLANTUML_INCLUDE_PATH = +DOT_GRAPH_MAX_NODES = 50 +MAX_DOT_GRAPH_DEPTH = 0 +DOT_TRANSPARENT = NO +DOT_MULTI_TARGETS = NO +GENERATE_LEGEND = YES +DOT_CLEANUP = YES diff --git a/docs/tools/generate-md.js b/docs/tools/generate-md.js new file mode 100644 index 0000000000..f0528a29e5 --- /dev/null +++ b/docs/tools/generate-md.js @@ -0,0 +1,100 @@ +var xpath = require('xpath'); +var dom = require('xmldom').DOMParser; +var fs = require('fs'); +var _ = require('underscore'); +var async = require('async'); + +function generate(directory, primary_callback) { + var modules = []; + return fs.readFile(directory + 'index.xml', 'utf8', (err, xml) => { + if (err) throw err; + var doc = new dom().parseFromString(xml); + var nodes = xpath.select('/doxygenindex/compound[@kind="dir"]', doc); + for (var i = 0; i < nodes.length; i++) { + var refid = nodes[i].getAttribute('refid'); + var name = nodes[i].firstChild.firstChild.toString(); + modules.push({name: name, refid: refid}); + } + const root_module = _.find(modules, (module) => { + return _.last(module.name.split('/')) == 'xlnt'; + }); + const root_name = root_module.name; + modules = _.filter(modules, (module) => { + return module.name.indexOf(root_name) >= 0 && module.name !== root_name; + }); + return async.mapSeries(modules, (module, module_callback) => { + return fs.readFile(directory + module.refid + '.xml', 'utf8', (err, xml) => { + if (err) throw err; + var doc = new dom().parseFromString(xml); + var nodes = xpath.select('/doxygen/compounddef/innerfile', doc); + module.source_files = []; + for (var i = 0; i < nodes.length; i++) { + var refid = nodes[i].getAttribute('refid'); + var name = nodes[i].firstChild.toString(); + module.source_files.push({name: name, refid: refid}); + } + return async.map(module.source_files, (source_file, source_file_callback) => { + return fs.readFile(directory + source_file.refid + '.xml', 'utf8', (err, xml) => { + if (err) throw err; + var doc = new dom().parseFromString(xml); + var nodes = xpath.select('/doxygen/compounddef/innerclass', doc); + module.class_files = []; + for (var i = 0; i < nodes.length; i++) { + var refid = nodes[i].getAttribute('refid'); + var name = nodes[i].firstChild.toString(); + module.class_files.push({name: name, refid: refid}); + } + return async.map(module.class_files, (class_file, class_file_callback) => { + return fs.readFile(directory + class_file.refid + '.xml', 'utf8', (err, xml) => { + if (err) throw err; + var doc = new dom().parseFromString(xml); + var nodes = xpath.select('/doxygen/compounddef/sectiondef/memberdef[@prot="public"]', doc); + var members = []; + for (var i = 0; i < nodes.length; i++) { + var member_data = {id: nodes[i].getAttribute('id')}; + var child = nodes[i].firstChild; + while (child != nodes[i].lastChild) { + if (child.textContent.trim()) { + member_data[child.nodeName] = child.textContent.trim(); + } + child = child.nextSibling; + } + members.push(member_data); + } + class_file.members = members; + return class_file_callback(null, class_file); + }); + }, (err, data) => { + return source_file_callback(null, _.flatten(data, true)); + }); + }); + }, (err, data) => { + module.classes = _.flatten(data, true); + return module_callback(null, module); + }); + }); + }, (err, data) => { + return primary_callback(null, _.flatten(data, true)); + }); + }); +} + +generate('doxyxml/', function(err, data) { + console.log('# API Reference'); + for (var i = 0; i < data.length; i++) { + var module = data[i]; + var module_name = _.last(module.name.split('/')); + console.log('##', module_name.charAt(0).toUpperCase() + module_name.slice(1), 'Module'); + for (var j = 0; j < module.classes.length; j++) { + var class_ = module.classes[j]; + console.log('###', _.last(class_.name.split('::'))); + for (var k = 0; k < class_.members.length; k++) { + var member = class_.members[k]; + console.log('####', '```' + member.definition + member.argsstring + '```'); + if (member.briefdescription) { + console.log(member.briefdescription); + } + } + } + } +}); diff --git a/docs/xlnt.3 b/docs/xlnt.3 new file mode 100644 index 0000000000..2fe512e3f3 --- /dev/null +++ b/docs/xlnt.3 @@ -0,0 +1,1859 @@ +.\"t +.\" Automatically generated by Pandoc 1.19.2.2 +.\" +.TH "" "" "" "" "" +.hy +.SH [IMAGE: xlnt +logo (https://user-images.githubusercontent.com/1735211/29433390-f37fa28e-836c-11e7-8a60-f8df4c30b424.png)] +.PD 0 +.P +.PD +.PP +[IMAGE: Travis Build +Status (https://travis-ci.org/tfussell/xlnt.svg?branch=master)] (https://travis-ci.org/tfussell/xlnt) +[IMAGE: AppVeyor Build +status (https://ci.appveyor.com/api/projects/status/2hs79a1xoxy16sol?svg=true)] (https://ci.appveyor.com/project/tfussell/xlnt) +[IMAGE: Coverage +Status (https://coveralls.io/repos/github/tfussell/xlnt/badge.svg?branch=master)] (https://coveralls.io/github/tfussell/xlnt?branch=master) +[IMAGE: ReadTheDocs Documentation +Status (https://readthedocs.org/projects/xlnt/badge/?version=latest)] (http://xlnt.readthedocs.org/en/latest/?badge=latest) +[IMAGE: License (http://img.shields.io/badge/license-MIT-blue.svg?style=flat)] (http://opensource.org/licenses/MIT) +.SS Introduction +.PP +xlnt is a modern C++ library for manipulating spreadsheets in memory and +reading/writing them from/to XLSX files as described in ECMA 376 4th +edition (http://www.ecma-international.org/publications/standards/Ecma-376.htm). +The first public release of xlnt version 1.0 was on May 10th, 2017. +Current work is focused on increasing compatibility, improving +performance, and brainstorming future development goals. +For a high\-level summary of what you can do with this library, see the +feature +list (https://tfussell.gitbooks.io/xlnt/content/docs/introduction/Features.html). +Contributions are welcome in the form of pull requests or discussions on +the repository\[aq]s Issues +page (https://github.com/tfussell/xlnt/issues). +.SS Example +.PP +Including xlnt in your project, creating a new spreadsheet, and saving +it as "example.xlsx" +.IP +.nf +\f[C] +#include\ + +int\ main() +{ +\ \ \ \ xlnt::workbook\ wb; +\ \ \ \ xlnt::worksheet\ ws\ =\ wb.active_sheet(); +\ \ \ \ ws.cell("A1").value(5); +\ \ \ \ ws.cell("B2").value("string\ data"); +\ \ \ \ ws.cell("C3").formula("=RAND()"); +\ \ \ \ ws.merge_cells("C3:C4"); +\ \ \ \ ws.freeze_panes("B2"); +\ \ \ \ wb.save("example.xlsx"); +\ \ \ \ return\ 0; +} +//\ compile\ with\ \-std=c++14\ \-Ixlnt/include\ \-lxlnt +\f[] +.fi +.SS Documentation +.PP +Documentation for the current release of xlnt is available +here (https://tfussell.gitbooks.io/xlnt/content/). +.SS License +.PP +xlnt is released to the public for free under the terms of the MIT +License. +See LICENSE.md (https://github.com/tfussell/xlnt/blob/master/LICENSE.md) +for the full text of the license and the licenses of xlnt\[aq]s +third\-party dependencies. +LICENSE.md (https://github.com/tfussell/xlnt/blob/master/LICENSE.md) +should be distributed alongside any assemblies that use xlnt in source +or compiled form. +.SS Introduction +.IP \[bu] 2 +Motivation (Motivation.md) +.IP \[bu] 2 +Examples (Examples.md) +.IP \[bu] 2 +Features (Features.md) +.IP \[bu] 2 +Installation (Installation.md) +.SS Motivation +.SS Examples +.SS Simple \- reading from an existing xlsx spread sheet. +.PP +The following C plus plus code will read the values from an xlsx file +and print the string values to the screen. +This is a very simple example to get you started. +.IP +.nf +\f[C] +#include\ +#include\ + +int\ main() +{ +\ \ \ \ xlnt::workbook\ wb; +\ \ \ \ wb.load("/home/timothymccallum/test.xlsx"); +\ \ \ \ auto\ ws\ =\ wb.active_sheet(); +\ \ \ \ std::clog\ <<\ "Processing\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ for\ (auto\ row\ :\ ws.rows(false))\ +\ \ \ \ {\ +\ \ \ \ \ \ \ \ for\ (auto\ cell\ :\ row)\ +\ \ \ \ {\ +\ \ \ \ \ \ \ \ std::clog\ <<\ cell.to_string()\ <<\ std::endl; +\ \ \ \ } +\ \ \ \ } +\ \ \ \ std::clog\ <<\ "Processing\ complete"\ <<\ std::endl; +\ \ \ \ return\ 0; +} +\f[] +.fi +.PP +Save the contents of the above file +.IP +.nf +\f[C] +/home/timothymccallum/process.cpp +\f[] +.fi +.PP +Compile by typing the following command +.IP +.nf +\f[C] +g++\ \-std=c++14\ \-lxlnt\ process.cpp\ \-o\ process +\f[] +.fi +.PP +Excecute by typing the following command +.IP +.nf +\f[C] +\&./process +\f[] +.fi +.PP +The output of the program, in my case, is as follows +.IP +.nf +\f[C] +Processing\ spread\ sheet +This\ is\ cell\ A1. +This\ is\ cell\ B1 +\&...\ and\ this\ is\ cell\ C1 +We\ are\ now\ on\ the\ second\ row\ at\ cell\ A2 +B2 +C2 +Processing\ complete +\f[] +.fi +.PP +As you can see the process.cpp file simply walks through the spread +sheet values row by row and column by column (A1, B1, C1, A2, B2, C2 and +so on). +.SS Simple \- storing a spread sheet in a 2 dimensional C++ Vector for +further processing +.PP +Loading a spread sheet into a Vector provides oppourtunities for you to +perform high performance processing. +There will be more examples on performing fast look\-ups, merging data, +performing deduplication and more. +For now, let\[aq]s just learn how to get the spread sheet loaded into +memory. +.IP +.nf +\f[C] +#include\ +#include\ +#include\ + +int\ main() +{ +\ \ \ \ xlnt::workbook\ wb; +\ \ \ \ wb.load("/home/timothymccallum/test.xlsx"); +\ \ \ \ auto\ ws\ =\ wb.active_sheet(); +\ \ \ \ std::clog\ <<\ "Processing\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ std::clog\ <<\ "Creating\ a\ single\ vector\ which\ stores\ the\ whole\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ std::vector<\ std::vector\ >\ theWholeSpreadSheet; +\ \ \ \ for\ (auto\ row\ :\ ws.rows(false))\ +\ \ \ \ {\ +\ \ \ \ \ \ \ \ std::clog\ <<\ "Creating\ a\ fresh\ vector\ for\ just\ this\ row\ in\ the\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ std::vector\ aSingleRow; +\ \ \ \ for\ (auto\ cell\ :\ row)\ +\ \ \ \ {\ +\ \ \ \ \ \ \ \ std::clog\ <<\ "Adding\ this\ cell\ to\ the\ row"\ <<\ std::endl; +\ \ \ \ \ \ \ \ aSingleRow.push_back(cell.to_string()); +\ \ \ \ } +\ \ \ \ std::clog\ <<\ "Adding\ this\ entire\ row\ to\ the\ vector\ which\ stores\ the\ whole\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ theWholeSpreadSheet.push_back(aSingleRow); +\ \ \ \ } +\ \ \ \ std::clog\ <<\ "Processing\ complete"\ <<\ std::endl; +\ \ \ \ std::clog\ <<\ "Reading\ the\ vector\ and\ printing\ output\ to\ the\ screen"\ <<\ std::endl; +\ \ \ \ for\ (int\ rowInt\ =\ 0;\ rowInt\ <\ theWholeSpreadSheet.size();\ rowInt++) +\ \ \ \ { +\ \ \ \ \ \ \ \ for\ (int\ colInt\ =\ 0;\ colInt\ <\ theWholeSpreadSheet.at(rowInt).size();\ colInt++) +\ \ \ \ { +\ \ \ \ \ \ \ \ std::cout\ <<\ theWholeSpreadSheet.at(rowInt).at(colInt)\ <<\ std::endl; +\ \ \ \ \ \ \ \ } +\ \ \ \ } +\ \ \ \ return\ 0; +} +\f[] +.fi +.PP +Save the contents of the above file +.IP +.nf +\f[C] +/home/timothymccallum/process.cpp +\f[] +.fi +.PP +Compile by typing the following command +.IP +.nf +\f[C] +g++\ \-std=c++14\ \-lxlnt\ process.cpp\ \-o\ process +\f[] +.fi +.PP +Excecute by typing the following command +.IP +.nf +\f[C] +\&./process +\f[] +.fi +.PP +The output of the program, in my case, is as follows +.IP +.nf +\f[C] +Processing\ spread\ sheet +Creating\ a\ single\ vector\ which\ stores\ the\ whole\ spread\ sheet +Creating\ a\ fresh\ vector\ for\ just\ this\ row\ in\ the\ spread\ sheet +Adding\ this\ cell\ to\ the\ row +Adding\ this\ cell\ to\ the\ row +Adding\ this\ cell\ to\ the\ row +Adding\ this\ entire\ row\ to\ the\ vector\ which\ stores\ the\ whole\ spread\ sheet +Creating\ a\ fresh\ vector\ for\ just\ this\ row\ in\ the\ spread\ sheet +Adding\ this\ cell\ to\ the\ row +Adding\ this\ cell\ to\ the\ row +Adding\ this\ cell\ to\ the\ row +Adding\ this\ entire\ row\ to\ the\ vector\ which\ stores\ the\ whole\ spread\ sheet +Processing\ complete +Reading\ the\ vector\ and\ printing\ output\ to\ the\ screen +This\ is\ cell\ A1. +This\ is\ cell\ B1 +\&...\ and\ this\ is\ cell\ C1 +We\ are\ now\ on\ the\ second\ row\ at\ cell\ A2 +B2 +C2 +\f[] +.fi +.PP +You will have noticed that this process is very fast. +If you type the "time" as shown below, you can measure just how fast +loading and retrieving your spread sheet is, using xlnt; In this case +only a fraction of a second. +More on this later. +.IP +.nf +\f[C] +time\ ./process\ +\&... +real\ \ \ \ 0m0.044s +\f[] +.fi +.SS Simple \- writing values to a new xlsx spread sheet. +.IP +.nf +\f[C] +#include\ +#include\ +#include\ +#include\ + +int\ main() +{ +\ \ \ \ //Creating\ a\ 2\ dimensional\ vector\ which\ we\ will\ write\ values\ to +\ \ \ \ std::vector<\ std::vector\ >\ wholeWorksheet; +\ \ \ \ //Looping\ through\ each\ row\ (100\ rows\ as\ per\ the\ second\ argument\ in\ the\ for\ loop) +\ \ \ \ for\ (int\ outer\ =\ 0;\ outer\ <\ 100;\ outer++) +\ \ \ \ { +\ \ \ \ \ \ \ \ //Creating\ a\ fresh\ vector\ for\ a\ fresh\ row +\ \ \ \ std::vector\ singleRow; +\ \ \ \ //Looping\ through\ each\ of\ the\ columns\ (100\ as\ per\ the\ second\ argument\ in\ the\ for\ loop)\ in\ this\ particular\ row +\ \ \ \ for(int\ inner\ =\ 0;\ inner\ <\ 100;\ inner++) +\ \ \ \ { +\ \ \ \ \ \ \ \ //Adding\ a\ single\ value\ in\ each\ cell\ of\ the\ row\ +\ \ \ \ \ \ \ \ std::string\ val\ =\ std::to_string(inner\ +\ 1); +\ \ \ \ \ \ \ \ singleRow.push_back(val);\ \ \ \ \ \ \ \ \ \ \ \ +\ \ \ \ } +\ \ \ \ //Adding\ the\ single\ row\ to\ the\ 2\ dimensional\ vector +\ \ \ \ wholeWorksheet.push_back(singleRow); +\ \ \ \ std::clog\ <<\ "Writing\ to\ row\ "\ <<\ outer\ <<\ "\ in\ the\ vector\ "\ <<\ std::endl; +\ \ \ \ } +\ \ \ \ //Writing\ to\ the\ spread\ sheet +\ \ \ \ //Creating\ the\ output\ workbook\ +\ \ \ \ std::clog\ <<\ "Creating\ workbook"\ <<\ std::endl; +\ \ \ \ xlnt::workbook\ wbOut; +\ \ \ \ //Setting\ the\ destination\ output\ file\ name +\ \ \ \ std::string\ dest_filename\ =\ "output.xlsx"; +\ \ \ \ //Creating\ the\ output\ worksheet +\ \ \ \ xlnt::worksheet\ wsOut\ =\ wbOut.active_sheet(); +\ \ \ \ //Giving\ the\ output\ worksheet\ a\ title/name +\ \ \ \ wsOut.title("data"); +\ \ \ \ //We\ will\ now\ be\ looping\ through\ the\ 2\ dimensional\ vector\ which\ we\ created\ above +\ \ \ \ //In\ this\ case\ we\ have\ two\ iterators\ one\ for\ the\ outer\ loop\ (row)\ and\ one\ for\ the\ inner\ loop\ (column) +\ \ \ \ std::clog\ <<\ "Looping\ through\ vector\ and\ writing\ to\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ for\ (int\ fOut\ =\ 0;\ fOut\ <\ wholeWorksheet.size();\ fOut++) +\ \ \ \ { +\ \ \ \ \ \ \ \ std::clog\ <<\ "Row"\ <<\ fOut\ <<\ std::endl; +\ \ \ \ \ \ \ \ for\ (int\ fIn\ =\ 0;\ fIn\ <\ wholeWorksheet.at(fOut).size();\ fIn++) +\ \ \ \ \ \ \ \ { +\ \ \ \ \ \ \ \ \ \ \ \ //Take\ notice\ of\ the\ difference\ between\ accessing\ the\ vector\ and\ accessing\ the\ work\ sheet +\ \ \ \ \ \ \ \ //As\ you\ may\ already\ know\ Excel\ spread\ sheets\ start\ at\ row\ 1\ and\ column\ 1\ (not\ row\ 0\ and\ column\ 0\ like\ you\ would\ expect\ from\ a\ C++\ vector)\ +\ \ \ \ \ \ \ \ //In\ short\ the\ xlnt\ cell\ reference\ starts\ at\ column\ 1\ row\ 1\ (hence\ the\ +\ 1s\ below)\ and\ the\ vector\ reference\ starts\ at\ row\ 0\ and\ column\ 0 +\ \ \ \ \ \ \ \ wsOut.cell(xlnt::cell_reference(fIn\ +\ 1,\ fOut\ +\ 1)).value(wholeWorksheet.at(fOut).at(fIn)); +\ \ \ \ \ \ \ \ //Further\ clarification\ to\ avoid\ confusion +\ \ \ \ \ \ \ \ //Cell\ reference\ arguments\ are\ (column\ number,\ row\ number);\ e.g.\ cell_reference(fIn\ +\ 1,\ fOut\ +\ 1) +\ \ \ \ \ \ \ \ //Vector\ arguments\ are\ (row\ number,\ column\ number);\ e.g.\ wholeWorksheet.at(fOut).at(fIn) +\ \ \ \ } +\ \ \ \ } +\ \ \ \ std::clog\ <<\ "Finished\ writing\ spread\ sheet"\ <<\ std::endl; +\ \ \ \ wbOut.save(dest_filename);\ +\ \ \ \ return\ 0; +} +\f[] +.fi +.PP +This process is also quite quick; a time command showed that xlnt was +able to create and write 10, 000 values to the output spread sheet in +0.582 seconds. +.SS Features +.PP +.TS +tab(@); +l l l l. +T{ +Feature +T}@T{ +Read +T}@T{ +Edit +T}@T{ +Write +T} +_ +T{ +Excel\-style Workbook +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +LibreOffice\-style Workbook +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Numbers\-style Workbook +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Encrypted Workbook (Excel 2007\-2010) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +T} +T{ +Encrypted Workbook (Excel 2013\-2016) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +T} +T{ +Excel Binary Workbook (.xlsb) +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Excel Macro\-Enabled Workbook (.xlsm) +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Excel Macro\-Enabled Template (.xltm) +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Document Properties +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Numeric Cell Values +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Inline String Cell Values +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Shared String Cell Values +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Shared String Text Run Formatting (e.g. +varied fonts within a cell) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Hyperlink Cell Values +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Formula Cell Values +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Formula Evaluation +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Page Margins +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Page Setup +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Print Area +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Comments +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +T} +T{ +Header and Footer +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Custom Views +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Charts +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Chartsheets +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Dialogsheets +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Themes +T}@T{ +✓ +T}@T{ +T}@T{ +✓ +T} +T{ +Cell Styles +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Cell Formats +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Formatting\->Alignment (e.g. +right align) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Formatting\->Border (e.g. +red cell outline) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Formatting\->Fill (e.g. +green cell background) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Formatting\->Font (e.g. +blue cell text) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Formatting\->Number Format (e.g. +show 2 decimals) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Formatting\->Protection (e.g. +hide formulas) +T}@T{ +✓ +T}@T{ +✓ +T}@T{ +✓ +T} +T{ +Column Styles +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Row Styles +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Sheet Styles +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Conditional Formatting +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Tables +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Table Formatting +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Pivot Tables +T}@T{ +T}@T{ +T}@T{ +T} +T{ +XLSX Thumbnail +T}@T{ +✓ +T}@T{ +T}@T{ +✓ +T} +T{ +Custom OOXML Properties +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Custom OOXML Parts +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Drawing +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Text Box +T}@T{ +T}@T{ +T}@T{ +T} +T{ +WordArt +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Embedded Content (e.g. +images) +T}@T{ +T}@T{ +T}@T{ +T} +T{ +Excel VBA +T}@T{ +T}@T{ +T}@T{ +T} +.TE +.SH Getting xlnt +.SS Binaries +.SS Homebrew +.SS Arch +.SS vcpkg +.SS Compiling xlnt 1.x.x from Source on Ubuntu 16.04 LTS (Xenial Xerus) +.PP +Time required: Approximately 5 minutes (depending on your internet +speed) +.IP +.nf +\f[C] +sudo\ apt\-get\ update +sudo\ apt\-get\ upgrade +sudo\ apt\-get\ install\ cmake +sudo\ apt\-get\ install\ zlibc +\f[] +.fi +.PP +The following steps update the compiler and set the appropriate +environment variables \- see note [1] below for the reason why we need +to update the standard available compiler +.IP +.nf +\f[C] +sudo\ add\-apt\-repository\ ppa:ubuntu\-toolchain\-r/test +sudo\ apt\ update +sudo\ apt\-get\ upgrade +sudo\ apt\-get\ install\ gcc\-6\ g++\-6 +export\ CC=/usr/bin/gcc\-6\ \ +export\ CXX=/usr/bin/g++\-6 +\f[] +.fi +.PP +The following steps will intall xlnt Download the zip file from the xlnt +repository +.IP +.nf +\f[C] +cd\ ~ +unzip\ Downloads/xlnt\-master.zip +cd\ xlnt\-master +cmake\ . +make\ \-j\ 2 +sudo\ make\ install +\f[] +.fi +.PP +The following step will map the shared library names to the location of +the corresponding shared library files +.IP +.nf +\f[C] +sudo\ ldconfig +\f[] +.fi +.PP +xlnt will now be ready to use on your Ubuntu instance. +.PP +[1] Xlnt requires a minimum of gcc 6.2.0 The most recent gcc version +available using the standard APT repositories is gcc 5.4.0 (obtained +through build\-essential 12.1ubuntu2). +If these older versions of gcc are used an error "workbook.cpp error +1502:31 \[aq]extended_property\[aq] is not a class, namespace or +enumeration" will occur during the xlnt make command. +.SS Compiling from Source +.PP +Build configurations for Visual Studio, GNU Make, Ninja, and Xcode can +be created using cmake (https://cmake.org/) v3.2+. +A full list of cmake generators can be found +here (https://cmake.org/cmake/help/v3.0/manual/cmake-generators.7.html). +A basic build would look like (starting in the root xlnt directory): +.IP +.nf +\f[C] +mkdir\ build +cd\ build +cmake\ .. +make\ \-j8 +\f[] +.fi +.PP +The resulting shared (e.g. +libxlnt.dylib) library would be found in the build/lib directory. +Other cmake configuration options for xlnt can be found using "cmake +\-LH". +These options include building a static library instead of shared and +whether to build sample executables or not. +An example of building a static library with an Xcode project: +.IP +.nf +\f[C] +mkdir\ build +cd\ build +cmake\ \-D\ STATIC=ON\ \-G\ Xcode\ .. +cmake\ \-\-build\ . +cd\ bin\ &&\ ./xlnt.test +\f[] +.fi +.PP +\f[I]Note for Windows: cmake defaults to building a 32\-bit library +project. To build a 64\-bit library, use the Win64 generator\f[] +.IP +.nf +\f[C] +cmake\ \-G\ "Visual\ Studio\ 14\ 2015\ Win64"\ .. +\f[] +.fi +.SS Basics +.IP \[bu] 2 +Workbook (/docs/basics/Workbook.md) +.IP \[bu] 2 +Worksheet (/docs/basics/Worksheet.md) +.IP \[bu] 2 +Cell (/docs/basics/Cell.md) +.IP \[bu] 2 +Iteration (/docs/basics/Iteration.md) +.SS Workbook +.SS Worksheet +.SS Cell +.SS Iteration +.SS Advanced +.IP \[bu] 2 +Formatting (Formatting.md) +.IP \[bu] 2 +Properties (Properties.md) +.IP \[bu] 2 +Printing (Printing.md) +.IP \[bu] 2 +Encryption (Encryption.md) +.IP \[bu] 2 +Views (Views.md) +.SH Formatting +.SS Format vs. Style +.IP +.nf +\f[C] +#include\ +#include\ + +int\ main() +{ +\ \ \ \ xlnt::workbook\ wb; +\ \ \ \ auto\ cell\ =\ wb.active_sheet().cell("A1"); +\ \ \ \ return\ 0; +} +\f[] +.fi +.PP +In the context of xlnt, format and style have specific distinct +meanings. +A style in xlnt corresponds to a named style created in the "Cell +styles" dropdown in Excel. +It must have a name and optionally any of: alignment, border, fill, +font, number format, protection. +A format in xlnt corresponds to the alignment, border, fill, font, +number format, and protection settings applied to a cell via +right\-click\->"Format Cells". +A cell can have both a format and a style. +The style properties will generally override the format properties. +.SS Number Formatting +.IP +.nf +\f[C] +#include\ +#include\ + +int\ main() +{ +\ \ \ \ xlnt::workbook\ wb; +\ \ \ \ auto\ cell\ =\ wb.active_sheet().cell("A1"); +\ \ \ \ cell.number_format(xlnt::number_format::percentage()); +\ \ \ \ cell.value(0.513); +\ \ \ \ std::cout\ <<\ cell.to_string()\ <<\ std::endl; +\ \ \ \ return\ 0; +} +\f[] +.fi +.PP +An xlnt::number_format is the format code used when displaying a value +in a cell. +For example, a number_format of "0.00" implies that the number 13.726 +should be displayed as "13.73". +Many number formats are built\-in to Excel and can be access with +xlnt::number_format static constructors. +Other custom number formats can be created by passing a string to the +xlnt::number_format constructor (#cell-const-cell-amp). +.SH Properties +.IP +.nf +\f[C] +xlnt::workbook\ wb; + +wb.core_property(xlnt::core_property::category,\ "hors\ categorie"); +wb.core_property(xlnt::core_property::content_status,\ "good"); +wb.core_property(xlnt::core_property::created,\ xlnt::datetime(2017,\ 1,\ 15)); +wb.core_property(xlnt::core_property::creator,\ "me"); +wb.core_property(xlnt::core_property::description,\ "description"); +wb.core_property(xlnt::core_property::identifier,\ "id"); +wb.core_property(xlnt::core_property::keywords,\ {\ "wow",\ "such"\ }); +wb.core_property(xlnt::core_property::language,\ "Esperanto"); +wb.core_property(xlnt::core_property::last_modified_by,\ "someone"); +wb.core_property(xlnt::core_property::last_printed,\ xlnt::datetime(2017,\ 1,\ 15)); +wb.core_property(xlnt::core_property::modified,\ xlnt::datetime(2017,\ 1,\ 15)); +wb.core_property(xlnt::core_property::revision,\ "3"); +wb.core_property(xlnt::core_property::subject,\ "subject"); +wb.core_property(xlnt::core_property::title,\ "title"); +wb.core_property(xlnt::core_property::version,\ "1.0"); + +wb.extended_property(xlnt::extended_property::application,\ "xlnt"); +wb.extended_property(xlnt::extended_property::app_version,\ "0.9.3"); +wb.extended_property(xlnt::extended_property::characters,\ 123); +wb.extended_property(xlnt::extended_property::characters_with_spaces,\ 124); +wb.extended_property(xlnt::extended_property::company,\ "Incorporated\ Inc."); +wb.extended_property(xlnt::extended_property::dig_sig,\ "?"); +wb.extended_property(xlnt::extended_property::doc_security,\ 0); +wb.extended_property(xlnt::extended_property::heading_pairs,\ true); +wb.extended_property(xlnt::extended_property::hidden_slides,\ false); +wb.extended_property(xlnt::extended_property::h_links,\ 0); +wb.extended_property(xlnt::extended_property::hyperlink_base,\ 0); +wb.extended_property(xlnt::extended_property::hyperlinks_changed,\ true); +wb.extended_property(xlnt::extended_property::lines,\ 42); +wb.extended_property(xlnt::extended_property::links_up_to_date,\ false); +wb.extended_property(xlnt::extended_property::manager,\ "johnny"); +wb.extended_property(xlnt::extended_property::m_m_clips,\ "?"); +wb.extended_property(xlnt::extended_property::notes,\ "note"); +wb.extended_property(xlnt::extended_property::pages,\ 19); +wb.extended_property(xlnt::extended_property::paragraphs,\ 18); +wb.extended_property(xlnt::extended_property::presentation_format,\ "format"); +wb.extended_property(xlnt::extended_property::scale_crop,\ true); +wb.extended_property(xlnt::extended_property::shared_doc,\ false); +wb.extended_property(xlnt::extended_property::slides,\ 17); +wb.extended_property(xlnt::extended_property::template_,\ "template!"); +wb.extended_property(xlnt::extended_property::titles_of_parts,\ {\ "title"\ }); +wb.extended_property(xlnt::extended_property::total_time,\ 16); +wb.extended_property(xlnt::extended_property::words,\ 101); + +wb.custom_property("test",\ {\ 1,\ 2,\ 3\ }); +wb.custom_property("Editor",\ "John\ Smith"); + +wb.save("lots_of_properties.xlsx"); +\f[] +.fi +.SS Printing +.SS Encryption +.SS Views +.SS API +.IP \[bu] 2 +cell (cell.md) +.IP \[bu] 2 +cell_reference (cell_reference.md) +.SH cell +.SS \f[C]using\ xlnt::cell::type\ =\ \ cell_typeundefined\f[] +.PP +Alias xlnt::cell_type to xlnt::cell::type since it looks nicer. +.SS \f[C]friend\ class\ detail::xlsx_consumerundefined\f[] +.SS \f[C]friend\ class\ detail::xlsx_producerundefined\f[] +.SS \f[C]friend\ struct\ detail::cell_implundefined\f[] +.SS \f[C]static\ const\ std::unordered_map&\ xlnt::cell::error_codes()\f[] +.PP +Returns a map of error strings such as #DIV/0! and their associated +indices. +.SS \f[C]xlnt::cell::cell(const\ cell\ &)=default\f[] +.PP +Default copy constructor. +.SS \f[C]bool\ xlnt::cell::has_value()\ const\f[] +.PP +Returns true if value has been set and has not been cleared using +cell::clear_value(). +.SS \f[C]T\ xlnt::cell::value()\ const\f[] +.PP +Returns the value of this cell as an instance of type T. +Overloads exist for most C++ fundamental types like bool, int, etc. +as well as for std::string and xlnt datetime types: date, time, +datetime, and timedelta. +.SS \f[C]void\ xlnt::cell::clear_value()\f[] +.PP +Makes this cell have a value of type null. +All other cell attributes are retained. +.SS \f[C]void\ xlnt::cell::value(std::nullptr_t)\f[] +.PP +Sets the type of this cell to null. +.SS \f[C]void\ xlnt::cell::value(bool\ boolean_value)\f[] +.PP +Sets the value of this cell to the given boolean value. +.SS \f[C]void\ xlnt::cell::value(int\ int_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(unsigned\ int\ int_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(long\ long\ int\ int_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(unsigned\ long\ long\ int\ int_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(float\ float_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(double\ float_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(long\ double\ float_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ date\ &date_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ time\ &time_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ datetime\ &datetime_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ timedelta\ &timedelta_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ std::string\ &string_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ char\ *string_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ rich_text\ &text_value)\f[] +.PP +Sets the value of this cell to the given value. +.SS \f[C]void\ xlnt::cell::value(const\ cell\ other_cell)\f[] +.PP +Sets the value and formatting of this cell to that of other_cell. +.SS \f[C]void\ xlnt::cell::value(const\ std::string\ &string_value,\ bool\ infer_type)\f[] +.PP +Analyzes string_value to determine its type, convert it to that type, +and set the value of this cell to that converted value. +.SS \f[C]type\ xlnt::cell::data_type()\ const\f[] +.PP +Returns the type of this cell. +.SS \f[C]void\ xlnt::cell::data_type(type\ t)\f[] +.PP +Sets the type of this cell. +This should usually be done indirectly by setting the value of the cell +to a value of that type. +.SS \f[C]bool\ xlnt::cell::garbage_collectible()\ const\f[] +.PP +There\[aq]s no reason to keep a cell which has no value and is not a +placeholder. +Returns true if this cell has no value, style, isn\[aq]t merged, etc. +.SS \f[C]bool\ xlnt::cell::is_date()\ const\f[] +.PP +Returns true iff this cell\[aq]s number format matches a date format. +.SS \f[C]cell_reference\ xlnt::cell::reference()\ const\f[] +.PP +Returns a cell_reference that points to the location of this cell. +.SS \f[C]column_t\ xlnt::cell::column()\ const\f[] +.PP +Returns the column of this cell. +.SS \f[C]row_t\ xlnt::cell::row()\ const\f[] +.PP +Returns the row of this cell. +.SS \f[C]std::pair\ xlnt::cell::anchor()\ const\f[] +.PP +Returns the location of this cell as an ordered pair (left, top). +.SS \f[C]std::string\ xlnt::cell::hyperlink()\ const\f[] +.PP +Returns the URL of this cell\[aq]s hyperlink. +.SS \f[C]void\ xlnt::cell::hyperlink(const\ std::string\ &url)\f[] +.PP +Adds a hyperlink to this cell pointing to the URL of the given value. +.SS \f[C]void\ xlnt::cell::hyperlink(const\ std::string\ &url,\ const\ std::string\ &display)\f[] +.PP +Adds a hyperlink to this cell pointing to the URI of the given value and +sets the text value of the cell to the given parameter. +.SS \f[C]void\ xlnt::cell::hyperlink(xlnt::cell\ target)\f[] +.PP +Adds an internal hyperlink to this cell pointing to the given cell. +.SS \f[C]bool\ xlnt::cell::has_hyperlink()\ const\f[] +.PP +Returns true if this cell has a hyperlink set. +.SS \f[C]class\ alignment\ xlnt::cell::computed_alignment()\ const\f[] +.PP +Returns the alignment that should be used when displaying this cell +graphically based on the workbook default, the cell\-level format, and +the named style applied to the cell in that order. +.SS \f[C]class\ border\ xlnt::cell::computed_border()\ const\f[] +.PP +Returns the border that should be used when displaying this cell +graphically based on the workbook default, the cell\-level format, and +the named style applied to the cell in that order. +.SS \f[C]class\ fill\ xlnt::cell::computed_fill()\ const\f[] +.PP +Returns the fill that should be used when displaying this cell +graphically based on the workbook default, the cell\-level format, and +the named style applied to the cell in that order. +.SS \f[C]class\ font\ xlnt::cell::computed_font()\ const\f[] +.PP +Returns the font that should be used when displaying this cell +graphically based on the workbook default, the cell\-level format, and +the named style applied to the cell in that order. +.SS \f[C]class\ number_format\ xlnt::cell::computed_number_format()\ const\f[] +.PP +Returns the number format that should be used when displaying this cell +graphically based on the workbook default, the cell\-level format, and +the named style applied to the cell in that order. +.SS \f[C]class\ protection\ xlnt::cell::computed_protection()\ const\f[] +.PP +Returns the protection that should be used when displaying this cell +graphically based on the workbook default, the cell\-level format, and +the named style applied to the cell in that order. +.SS \f[C]bool\ xlnt::cell::has_format()\ const\f[] +.PP +Returns true if this cell has had a format applied to it. +.SS \f[C]const\ class\ format\ xlnt::cell::format()\ const\f[] +.PP +Returns the format applied to this cell. +If this cell has no format, an invalid_attribute exception will be +thrown. +.SS \f[C]void\ xlnt::cell::format(const\ class\ format\ new_format)\f[] +.PP +Applies the cell\-level formatting of new_format to this cell. +.SS \f[C]void\ xlnt::cell::clear_format()\f[] +.PP +Removes the cell\-level formatting from this cell. +This doesn\[aq]t affect the style that may also be applied to the cell. +Throws an invalid_attribute exception if no format is applied. +.SS \f[C]class\ number_format\ xlnt::cell::number_format()\ const\f[] +.PP +Returns the number format of this cell. +.SS \f[C]void\ xlnt::cell::number_format(const\ class\ number_format\ &format)\f[] +.PP +Creates a new format in the workbook, sets its number_format to the +given format, and applies the format to this cell. +.SS \f[C]class\ font\ xlnt::cell::font()\ const\f[] +.PP +Returns the font applied to the text in this cell. +.SS \f[C]void\ xlnt::cell::font(const\ class\ font\ &font_)\f[] +.PP +Creates a new format in the workbook, sets its font to the given font, +and applies the format to this cell. +.SS \f[C]class\ fill\ xlnt::cell::fill()\ const\f[] +.PP +Returns the fill applied to this cell. +.SS \f[C]void\ xlnt::cell::fill(const\ class\ fill\ &fill_)\f[] +.PP +Creates a new format in the workbook, sets its fill to the given fill, +and applies the format to this cell. +.SS \f[C]class\ border\ xlnt::cell::border()\ const\f[] +.PP +Returns the border of this cell. +.SS \f[C]void\ xlnt::cell::border(const\ class\ border\ &border_)\f[] +.PP +Creates a new format in the workbook, sets its border to the given +border, and applies the format to this cell. +.SS \f[C]class\ alignment\ xlnt::cell::alignment()\ const\f[] +.PP +Returns the alignment of the text in this cell. +.SS \f[C]void\ xlnt::cell::alignment(const\ class\ alignment\ &alignment_)\f[] +.PP +Creates a new format in the workbook, sets its alignment to the given +alignment, and applies the format to this cell. +.SS \f[C]class\ protection\ xlnt::cell::protection()\ const\f[] +.PP +Returns the protection of this cell. +.SS \f[C]void\ xlnt::cell::protection(const\ class\ protection\ &protection_)\f[] +.PP +Creates a new format in the workbook, sets its protection to the given +protection, and applies the format to this cell. +.SS \f[C]bool\ xlnt::cell::has_style()\ const\f[] +.PP +Returns true if this cell has had a style applied to it. +.SS \f[C]class\ style\ xlnt::cell::style()\f[] +.PP +Returns a wrapper pointing to the named style applied to this cell. +.SS \f[C]const\ class\ style\ xlnt::cell::style()\ const\f[] +.PP +Returns a wrapper pointing to the named style applied to this cell. +.SS \f[C]void\ xlnt::cell::style(const\ class\ style\ &new_style)\f[] +.PP +Sets the named style applied to this cell to a style named style_name. +Equivalent to style(new_style.name()). +.SS \f[C]void\ xlnt::cell::style(const\ std::string\ &style_name)\f[] +.PP +Sets the named style applied to this cell to a style named style_name. +If this style has not been previously created in the workbook, a +key_not_found exception will be thrown. +.SS \f[C]void\ xlnt::cell::clear_style()\f[] +.PP +Removes the named style from this cell. +An invalid_attribute exception will be thrown if this cell has no style. +This will not affect the cell format of the cell. +.SS \f[C]std::string\ xlnt::cell::formula()\ const\f[] +.PP +Returns the string representation of the formula applied to this cell. +.SS \f[C]void\ xlnt::cell::formula(const\ std::string\ &formula)\f[] +.PP +Sets the formula of this cell to the given value. +This formula string should begin with \[aq]=\[aq]. +.SS \f[C]void\ xlnt::cell::clear_formula()\f[] +.PP +Removes the formula from this cell. +After this is called, has_formula() will return false. +.SS \f[C]bool\ xlnt::cell::has_formula()\ const\f[] +.PP +Returns true if this cell has had a formula applied to it. +.SS \f[C]std::string\ xlnt::cell::to_string()\ const\f[] +.PP +Returns a string representing the value of this cell. +If the data type is not a string, it will be converted according to the +number format. +.SS \f[C]bool\ xlnt::cell::is_merged()\ const\f[] +.PP +Returns true iff this cell has been merged with one or more surrounding +cells. +.SS \f[C]void\ xlnt::cell::merged(bool\ merged)\f[] +.PP +Makes this a merged cell iff merged is true. +Generally, this shouldn\[aq]t be called directly. +Instead, use worksheet::merge_cells on its parent worksheet. +.SS \f[C]std::string\ xlnt::cell::error()\ const\f[] +.PP +Returns the error string that is stored in this cell. +.SS \f[C]void\ xlnt::cell::error(const\ std::string\ &error)\f[] +.PP +Directly assigns the value of this cell to be the given error. +.SS \f[C]cell\ xlnt::cell::offset(int\ column,\ int\ row)\f[] +.PP +Returns a cell from this cell\[aq]s parent workbook at a relative offset +given by the parameters. +.SS \f[C]class\ worksheet\ xlnt::cell::worksheet()\f[] +.PP +Returns the worksheet that owns this cell. +.SS \f[C]const\ class\ worksheet\ xlnt::cell::worksheet()\ const\f[] +.PP +Returns the worksheet that owns this cell. +.SS \f[C]class\ workbook&\ xlnt::cell::workbook()\f[] +.PP +Returns the workbook of the worksheet that owns this cell. +.SS \f[C]const\ class\ workbook&\ xlnt::cell::workbook()\ const\f[] +.PP +Returns the workbook of the worksheet that owns this cell. +.SS \f[C]calendar\ xlnt::cell::base_date()\ const\f[] +.PP +Returns the base date of the parent workbook. +.SS \f[C]std::string\ xlnt::cell::check_string(const\ std::string\ &to_check)\f[] +.PP +Returns to_check after verifying and fixing encoding, size, and illegal +characters. +.SS \f[C]bool\ xlnt::cell::has_comment()\f[] +.PP +Returns true if this cell has a comment applied. +.SS \f[C]void\ xlnt::cell::clear_comment()\f[] +.PP +Deletes the comment applied to this cell if it exists. +.SS \f[C]class\ comment\ xlnt::cell::comment()\f[] +.PP +Gets the comment applied to this cell. +.SS \f[C]void\ xlnt::cell::comment(const\ std::string\ &text,\ const\ std::string\ &author="Microsoft\ Office\ User")\f[] +.PP +Creates a new comment with the given text and optional author and +applies it to the cell. +.SS \f[C]void\ xlnt::cell::comment(const\ std::string\ &comment_text,\ const\ class\ font\ &comment_font,\ const\ std::string\ &author="Microsoft\ Office\ User")\f[] +.PP +Creates a new comment with the given text, formatting, and optional +author and applies it to the cell. +.SS \f[C]void\ xlnt::cell::comment(const\ class\ comment\ &new_comment)\f[] +.PP +Apply the comment provided as the only argument to the cell. +.SS \f[C]double\ xlnt::cell::width()\ const\f[] +.PP +Returns the width of this cell in pixels. +.SS \f[C]double\ xlnt::cell::height()\ const\f[] +.PP +Returns the height of this cell in pixels. +.SS \f[C]cell&\ xlnt::cell::operator=(const\ cell\ &rhs)\f[] +.PP +Makes this cell interally point to rhs. +The cell data originally pointed to by this cell will be unchanged. +.SS \f[C]bool\ xlnt::cell::operator==(const\ cell\ &comparand)\ const\f[] +.PP +Returns true if this cell the same cell as comparand (compared by +reference). +.SS \f[C]bool\ xlnt::cell::operator==(std::nullptr_t)\ const\f[] +.PP +Returns true if this cell is uninitialized. +.SH cell_reference +.SS \f[C]static\ std::pair\ xlnt::cell_reference::split_reference(const\ std::string\ &reference_string)\f[] +.PP +Splits a coordinate string like "A1" into an equivalent pair like {"A", +1}. +.SS \f[C]static\ std::pair\ xlnt::cell_reference::split_reference(const\ std::string\ &reference_string,\ bool\ &absolute_column,\ bool\ &absolute_row)\f[] +.PP +Splits a coordinate string like "A1" into an equivalent pair like {"A", +1}. +Reference parameters absolute_column and absolute_row will be set to +true if column part or row part are prefixed by a dollar\-sign +indicating they are absolute, otherwise false. +.SS \f[C]xlnt::cell_reference::cell_reference()\f[] +.PP +Default constructor makes a reference to the top\-left\-most cell, "A1". +.SS \f[C]xlnt::cell_reference::cell_reference(const\ char\ *reference_string)\f[] +.PP +Constructs a cell_reference from a string reprenting a cell coordinate +(e.g. +$B14). +.SS \f[C]xlnt::cell_reference::cell_reference(const\ std::string\ &reference_string)\f[] +.PP +Constructs a cell_reference from a string reprenting a cell coordinate +(e.g. +$B14). +.SS \f[C]xlnt::cell_reference::cell_reference(column_t\ column,\ row_t\ row)\f[] +.PP +Constructs a cell_reference from a 1\-indexed column index and row +index. +.SS \f[C]cell_reference&\ xlnt::cell_reference::make_absolute(bool\ absolute_column=true,\ bool\ absolute_row=true)\f[] +.PP +Converts a coordinate to an absolute coordinate string (e.g. +B12 \-> $B$12) Defaulting to true, absolute_column and absolute_row can +optionally control whether the resulting cell_reference has an absolute +column (e.g. +B12 \-> $B12) and absolute row (e.g. +B12 \-> B$12) respectively. +.SS \f[C]bool\ xlnt::cell_reference::column_absolute()\ const\f[] +.PP +Returns true if the reference refers to an absolute column, otherwise +false. +.SS \f[C]void\ xlnt::cell_reference::column_absolute(bool\ absolute_column)\f[] +.PP +Makes this reference have an absolute column if absolute_column is true, +otherwise not absolute. +.SS \f[C]bool\ xlnt::cell_reference::row_absolute()\ const\f[] +.PP +Returns true if the reference refers to an absolute row, otherwise +false. +.SS \f[C]void\ xlnt::cell_reference::row_absolute(bool\ absolute_row)\f[] +.PP +Makes this reference have an absolute row if absolute_row is true, +otherwise not absolute. +.SS \f[C]column_t\ xlnt::cell_reference::column()\ const\f[] +.PP +Returns a string that identifies the column of this reference (e.g. +second column from left is "B") +.SS \f[C]void\ xlnt::cell_reference::column(const\ std::string\ &column_string)\f[] +.PP +Sets the column of this reference from a string that identifies a +particular column. +.SS \f[C]column_t::index_t\ xlnt::cell_reference::column_index()\ const\f[] +.PP +Returns a 1\-indexed numeric index of the column of this reference. +.SS \f[C]void\ xlnt::cell_reference::column_index(column_t\ column)\f[] +.PP +Sets the column of this reference from a 1\-indexed number that +identifies a particular column. +.SS \f[C]row_t\ xlnt::cell_reference::row()\ const\f[] +.PP +Returns a 1\-indexed numeric index of the row of this reference. +.SS \f[C]void\ xlnt::cell_reference::row(row_t\ row)\f[] +.PP +Sets the row of this reference from a 1\-indexed number that identifies +a particular row. +.SS \f[C]cell_reference\ xlnt::cell_reference::make_offset(int\ column_offset,\ int\ row_offset)\ const\f[] +.PP +Returns a cell_reference offset from this cell_reference by the number +of columns and rows specified by the parameters. +A negative value for column_offset or row_offset results in a reference +above or left of this cell_reference, respectively. +.SS \f[C]std::string\ xlnt::cell_reference::to_string()\ const\f[] +.PP +Returns a string like "A1" for cell_reference(1, 1). +.SS \f[C]range_reference\ xlnt::cell_reference::to_range()\ const\f[] +.PP +Returns a 1x1 range_reference containing only this cell_reference. +.SS \f[C]range_reference\ xlnt::cell_reference::operator,(const\ cell_reference\ &other)\ const\f[] +.PP +I\[aq]ve always wanted to overload the comma operator. +cell_reference("A", 1), cell_reference("B", 1) will return +range_reference(cell_reference("A", 1), cell_reference("B", 1)) +.SS \f[C]bool\ xlnt::cell_reference::operator==(const\ cell_reference\ &comparand)\ const\f[] +.PP +Returns true if this reference is identical to comparand including in +absoluteness of column and row. +.SS \f[C]bool\ xlnt::cell_reference::operator==(const\ std::string\ &reference_string)\ const\f[] +.PP +Constructs a cell_reference from reference_string and return the result +of their comparison. +.SS \f[C]bool\ xlnt::cell_reference::operator==(const\ char\ *reference_string)\ const\f[] +.PP +Constructs a cell_reference from reference_string and return the result +of their comparison. +.SS \f[C]bool\ xlnt::cell_reference::operator!=(const\ cell_reference\ &comparand)\ const\f[] +.PP +Returns true if this reference is not identical to comparand including +in absoluteness of column and row. +.SS \f[C]bool\ xlnt::cell_reference::operator!=(const\ std::string\ &reference_string)\ const\f[] +.PP +Constructs a cell_reference from reference_string and return the result +of their comparison. +.SS \f[C]bool\ xlnt::cell_reference::operator!=(const\ char\ *reference_string)\ const\f[] +.PP +Constructs a cell_reference from reference_string and return the result +of their comparison. +.SH Change Log +.PP +This project adheres to Semantic Versioning (http://semver.org/). +Every release is documented on the Github +Releases (https://github.com/tfussell/xlnt/releases) page. +.SH Contributing to xlnt +.PP +xlnt welcomes contributions from everyone regardless of skill level +(provided you can write C++ or documentation). +.SS Getting Started +.PP +Look through the list of issues to find something interesting to work +on. +Help is appreciated with any issues, but important timely issues are +labeled as "help wanted". +Issues labeled "docs" might be good for those who want to contribute +without having to know too much C++. +You might also find something that the code is missing without an +associated issue. +That\[aq]s fine to work on to, but it might be best to make an issue +first in case someone else is working on it. +.SS Contributions +.PP +Contributions to xlnt should be made in the form of pull requests on +GitHub. +Each pull request will be reviewed and either merged into the current +development branch or given feedback for changes that would be required +to do so. +.PP +All code in this repository is under the MIT License. +You should agree to these terms before submitting any code to xlnt. +.SS Pull Request Checklist +.IP \[bu] 2 +Branch from the head of the current development branch. +Until version 1.0 is released, this the master branch. +.IP \[bu] 2 +Commits should be as small as possible, while ensuring that each commit +is correct independently (i.e. +each commit should compile and pass all tests). +Commits that don\[aq]t follow the coding style indicated in +\&.clang\-format (e.g. +indentation) are less likely to be accepted until they are fixed. +.IP \[bu] 2 +If your pull request is not getting reviewed or you need a specific +person to review it, you can \@\-reply a reviewer asking for a review in +the pull request or a comment. +.IP \[bu] 2 +Add tests relevant to the fixed defect or new feature. +It\[aq]s best to do this before making any changes, make sure that the +tests fail, then make changes ensuring that it ultimately passes the +tests (i.e. +TDD). +xlnt uses cxxtest for testing. +Tests are contained in a tests directory inside each module (e.g. +source/workbook/tests/test\f[I]workbook.hpp) in the form of a header +file. Each test is a separate function with a name that starts like +"test\f[]". +See for information about CxxTest or +take a look at existing tests. +.SS Conduct +.PP +Just try to be nice\-\-we\[aq]re all volunteers here. +.SS Communication +.PP +Add a comment to an existing issue on GitHub, open a new issue for +defects or feature requests, or contact \@tfussell if you want. +.SH License +.SS xlnt (https://github.com/tfussell/xlnt) +.RS +.PP +MIT License (https://github.com/tfussell/xlnt/blob/master/LICENSE.md) +.RE +.IP +.nf +\f[C] +Copyright\ (c)\ 2014\-2017\ Thomas\ Fussell + +Permission\ is\ hereby\ granted,\ free\ of\ charge,\ to\ any\ person\ obtaining\ a +copy\ of\ this\ software\ and\ associated\ documentation\ files\ (the +"Software"),\ to\ deal\ in\ the\ Software\ without\ restriction,\ including +without\ limitation\ the\ rights\ to\ use,\ copy,\ modify,\ merge,\ publish, +distribute,\ sublicense,\ and/or\ sell\ copies\ of\ the\ Software,\ and\ to +permit\ persons\ to\ whom\ the\ Software\ is\ furnished\ to\ do\ so,\ subject\ to +the\ following\ conditions: + +The\ above\ copyright\ notice\ and\ this\ permission\ notice\ shall\ be\ included +in\ all\ copies\ or\ substantial\ portions\ of\ the\ Software. + +THE\ SOFTWARE\ IS\ PROVIDED\ "AS\ IS",\ WITHOUT\ WARRANTY\ OF\ ANY\ KIND,\ EXPRESS +OR\ IMPLIED,\ INCLUDING\ BUT\ NOT\ LIMITED\ TO\ THE\ WARRANTIES\ OF +MERCHANTABILITY,\ FITNESS\ FOR\ A\ PARTICULAR\ PURPOSE\ AND\ NONINFRINGEMENT. +IN\ NO\ EVENT\ SHALL\ THE\ AUTHORS\ OR\ COPYRIGHT\ HOLDERS\ BE\ LIABLE\ FOR\ ANY +CLAIM,\ DAMAGES\ OR\ OTHER\ LIABILITY,\ WHETHER\ IN\ AN\ ACTION\ OF\ CONTRACT, +TORT\ OR\ OTHERWISE,\ ARISING\ FROM,\ OUT\ OF\ OR\ IN\ CONNECTION\ WITH\ THE +SOFTWARE\ OR\ THE\ USE\ OR\ OTHER\ DEALINGS\ IN\ THE\ SOFTWARE. +\f[] +.fi +.SS POLE (http://www.dimin.net/software/pole/) +.RS +.PP +BSD 2\-Clause +License (https://bitbucket.org/dimin/pole/src/c15e513bdce4c3a52b3dbc925d4d2bb520dc71d8/pole/LICENSE) +.RE +.IP +.nf +\f[C] +POLE\ \-\ Portable\ C++\ library\ to\ access\ OLE\ Storage +Copyright\ (C)\ 2002\-2007\ Ariya\ Hidayat\ (ariya\@kde.org).\ All\ rights\ reserved. + +Redistribution\ and\ use\ in\ source\ and\ binary\ forms,\ with\ or\ without +modification,\ are\ permitted\ provided\ that\ the\ following\ conditions +are\ met: + +1.\ Redistributions\ of\ source\ code\ must\ retain\ the\ above\ copyright +\ \ \ notice,\ this\ list\ of\ conditions\ and\ the\ following\ disclaimer. +2.\ Redistributions\ in\ binary\ form\ must\ reproduce\ the\ above\ copyright +\ \ \ notice,\ this\ list\ of\ conditions\ and\ the\ following\ disclaimer\ in\ the +\ \ \ documentation\ and/or\ other\ materials\ provided\ with\ the\ distribution. + +THIS\ SOFTWARE\ IS\ PROVIDED\ BY\ THE\ AUTHOR\ "AS\ IS"\ AND\ ANY\ EXPRESS\ OR +IMPLIED\ WARRANTIES,\ INCLUDING,\ BUT\ NOT\ LIMITED\ TO,\ THE\ IMPLIED\ WARRANTIES +OF\ MERCHANTABILITY\ AND\ FITNESS\ FOR\ A\ PARTICULAR\ PURPOSE\ ARE\ DISCLAIMED. +IN\ NO\ EVENT\ SHALL\ THE\ AUTHOR\ BE\ LIABLE\ FOR\ ANY\ DIRECT,\ INDIRECT, +INCIDENTAL,\ SPECIAL,\ EXEMPLARY,\ OR\ CONSEQUENTIAL\ DAMAGES\ (INCLUDING,\ BUT +NOT\ LIMITED\ TO,\ PROCUREMENT\ OF\ SUBSTITUTE\ GOODS\ OR\ SERVICES;\ LOSS\ OF\ USE, +DATA,\ OR\ PROFITS;\ OR\ BUSINESS\ INTERRUPTION)\ HOWEVER\ CAUSED\ AND\ ON\ ANY +THEORY\ OF\ LIABILITY,\ WHETHER\ IN\ CONTRACT,\ STRICT\ LIABILITY,\ OR\ TORT +(INCLUDING\ NEGLIGENCE\ OR\ OTHERWISE)\ ARISING\ IN\ ANY\ WAY\ OUT\ OF\ THE\ USE\ OF +THIS\ SOFTWARE,\ EVEN\ IF\ ADVISED\ OF\ THE\ POSSIBILITY\ OF\ SUCH\ DAMAGE. +\f[] +.fi +.SS libstudxml (http://www.codesynthesis.com/projects/libstudxml/) +.RS +.PP +MIT License (http://www.codesynthesis.com/licenses/mit.txt) +.RE +.IP +.nf +\f[C] +Summary:\ Everything\ is\ licensed\ under\ the\ MIT\ License\ (text\ below). + +Code\ found\ in\ the\ xml/details/expat/\ directory\ is\ distributed\ under +the\ MIT\ License\ (see\ the\ xml/details/expat/LICENSE\ file\ for\ copyright +information). + +Code\ found\ in\ the\ xml/details/genx/\ directory\ is\ distributed\ under +the\ MIT\ License\ (see\ the\ xml/details/genx/LICENSE\ file\ for\ copyright +information). + +The\ rest\ is\ Copyright\ (c)\ 2013\-2014\ Code\ Synthesis\ Tools\ CC\ and\ is +distributed\ under\ the\ MIT\ License: + +Permission\ is\ hereby\ granted,\ free\ of\ charge,\ to\ any\ person\ obtaining +a\ copy\ of\ this\ software\ and\ associated\ documentation\ files\ (the +"Software"),\ to\ deal\ in\ the\ Software\ without\ restriction,\ including +without\ limitation\ the\ rights\ to\ use,\ copy,\ modify,\ merge,\ publish, +distribute,\ sublicense,\ and/or\ sell\ copies\ of\ the\ Software,\ and\ to +permit\ persons\ to\ whom\ the\ Software\ is\ furnished\ to\ do\ so,\ subject\ to +the\ following\ conditions: + +The\ above\ copyright\ notice\ and\ this\ permission\ notice\ shall\ be\ included +in\ all\ copies\ or\ substantial\ portions\ of\ the\ Software. + +THE\ SOFTWARE\ IS\ PROVIDED\ "AS\ IS",\ WITHOUT\ WARRANTY\ OF\ ANY\ KIND, +EXPRESS\ OR\ IMPLIED,\ INCLUDING\ BUT\ NOT\ LIMITED\ TO\ THE\ WARRANTIES\ OF +MERCHANTABILITY,\ FITNESS\ FOR\ A\ PARTICULAR\ PURPOSE\ AND\ NONINFRINGEMENT. +IN\ NO\ EVENT\ SHALL\ THE\ AUTHORS\ OR\ COPYRIGHT\ HOLDERS\ BE\ LIABLE\ FOR\ ANY +CLAIM,\ DAMAGES\ OR\ OTHER\ LIABILITY,\ WHETHER\ IN\ AN\ ACTION\ OF\ CONTRACT, +TORT\ OR\ OTHERWISE,\ ARISING\ FROM,\ OUT\ OF\ OR\ IN\ CONNECTION\ WITH\ THE +SOFTWARE\ OR\ THE\ USE\ OR\ OTHER\ DEALINGS\ IN\ THE\ SOFTWARE. +\f[] +.fi +.SS CxxTest (http://cxxtest.com/) +.RS +.PP +LGPL License (https://github.com/CxxTest/cxxtest/blob/master/COPYING) +.RE +.IP +.nf +\f[C] +\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ GNU\ LESSER\ GENERAL\ PUBLIC\ LICENSE +\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Version\ 3,\ 29\ June\ 2007 + +\ Copyright\ (C)\ 2007\ Free\ Software\ Foundation,\ Inc.\ +\ Everyone\ is\ permitted\ to\ copy\ and\ distribute\ verbatim\ copies +\ of\ this\ license\ document,\ but\ changing\ it\ is\ not\ allowed. + + +\ \ This\ version\ of\ the\ GNU\ Lesser\ General\ Public\ License\ incorporates +the\ terms\ and\ conditions\ of\ version\ 3\ of\ the\ GNU\ General\ Public +License,\ supplemented\ by\ the\ additional\ permissions\ listed\ below. + +\ \ 0.\ Additional\ Definitions. + +\ \ As\ used\ herein,\ "this\ License"\ refers\ to\ version\ 3\ of\ the\ GNU\ Lesser +General\ Public\ License,\ and\ the\ "GNU\ GPL"\ refers\ to\ version\ 3\ of\ the\ GNU +General\ Public\ License. + +\ \ "The\ Library"\ refers\ to\ a\ covered\ work\ governed\ by\ this\ License, +other\ than\ an\ Application\ or\ a\ Combined\ Work\ as\ defined\ below. + +\ \ An\ "Application"\ is\ any\ work\ that\ makes\ use\ of\ an\ interface\ provided +by\ the\ Library,\ but\ which\ is\ not\ otherwise\ based\ on\ the\ Library. +Defining\ a\ subclass\ of\ a\ class\ defined\ by\ the\ Library\ is\ deemed\ a\ mode +of\ using\ an\ interface\ provided\ by\ the\ Library. + +\ \ A\ "Combined\ Work"\ is\ a\ work\ produced\ by\ combining\ or\ linking\ an +Application\ with\ the\ Library.\ \ The\ particular\ version\ of\ the\ Library +with\ which\ the\ Combined\ Work\ was\ made\ is\ also\ called\ the\ "Linked +Version". + +\ \ The\ "Minimal\ Corresponding\ Source"\ for\ a\ Combined\ Work\ means\ the +Corresponding\ Source\ for\ the\ Combined\ Work,\ excluding\ any\ source\ code +for\ portions\ of\ the\ Combined\ Work\ that,\ considered\ in\ isolation,\ are +based\ on\ the\ Application,\ and\ not\ on\ the\ Linked\ Version. + +\ \ The\ "Corresponding\ Application\ Code"\ for\ a\ Combined\ Work\ means\ the +object\ code\ and/or\ source\ code\ for\ the\ Application,\ including\ any\ data +and\ utility\ programs\ needed\ for\ reproducing\ the\ Combined\ Work\ from\ the +Application,\ but\ excluding\ the\ System\ Libraries\ of\ the\ Combined\ Work. + +\ \ 1.\ Exception\ to\ Section\ 3\ of\ the\ GNU\ GPL. + +\ \ You\ may\ convey\ a\ covered\ work\ under\ sections\ 3\ and\ 4\ of\ this\ License +without\ being\ bound\ by\ section\ 3\ of\ the\ GNU\ GPL. + +\ \ 2.\ Conveying\ Modified\ Versions. + +\ \ If\ you\ modify\ a\ copy\ of\ the\ Library,\ and,\ in\ your\ modifications,\ a +facility\ refers\ to\ a\ function\ or\ data\ to\ be\ supplied\ by\ an\ Application +that\ uses\ the\ facility\ (other\ than\ as\ an\ argument\ passed\ when\ the +facility\ is\ invoked),\ then\ you\ may\ convey\ a\ copy\ of\ the\ modified +version: + +\ \ \ a)\ under\ this\ License,\ provided\ that\ you\ make\ a\ good\ faith\ effort\ to +\ \ \ ensure\ that,\ in\ the\ event\ an\ Application\ does\ not\ supply\ the +\ \ \ function\ or\ data,\ the\ facility\ still\ operates,\ and\ performs +\ \ \ whatever\ part\ of\ its\ purpose\ remains\ meaningful,\ or + +\ \ \ b)\ under\ the\ GNU\ GPL,\ with\ none\ of\ the\ additional\ permissions\ of +\ \ \ this\ License\ applicable\ to\ that\ copy. + +\ \ 3.\ Object\ Code\ Incorporating\ Material\ from\ Library\ Header\ Files. + +\ \ The\ object\ code\ form\ of\ an\ Application\ may\ incorporate\ material\ from +a\ header\ file\ that\ is\ part\ of\ the\ Library.\ \ You\ may\ convey\ such\ object +code\ under\ terms\ of\ your\ choice,\ provided\ that,\ if\ the\ incorporated +material\ is\ not\ limited\ to\ numerical\ parameters,\ data\ structure +layouts\ and\ accessors,\ or\ small\ macros,\ inline\ functions\ and\ templates +(ten\ or\ fewer\ lines\ in\ length),\ you\ do\ both\ of\ the\ following: + +\ \ \ a)\ Give\ prominent\ notice\ with\ each\ copy\ of\ the\ object\ code\ that\ the +\ \ \ Library\ is\ used\ in\ it\ and\ that\ the\ Library\ and\ its\ use\ are +\ \ \ covered\ by\ this\ License. + +\ \ \ b)\ Accompany\ the\ object\ code\ with\ a\ copy\ of\ the\ GNU\ GPL\ and\ this\ license +\ \ \ document. + +\ \ 4.\ Combined\ Works. + +\ \ You\ may\ convey\ a\ Combined\ Work\ under\ terms\ of\ your\ choice\ that, +taken\ together,\ effectively\ do\ not\ restrict\ modification\ of\ the +portions\ of\ the\ Library\ contained\ in\ the\ Combined\ Work\ and\ reverse +engineering\ for\ debugging\ such\ modifications,\ if\ you\ also\ do\ each\ of +the\ following: + +\ \ \ a)\ Give\ prominent\ notice\ with\ each\ copy\ of\ the\ Combined\ Work\ that +\ \ \ the\ Library\ is\ used\ in\ it\ and\ that\ the\ Library\ and\ its\ use\ are +\ \ \ covered\ by\ this\ License. + +\ \ \ b)\ Accompany\ the\ Combined\ Work\ with\ a\ copy\ of\ the\ GNU\ GPL\ and\ this\ license +\ \ \ document. + +\ \ \ c)\ For\ a\ Combined\ Work\ that\ displays\ copyright\ notices\ during +\ \ \ execution,\ include\ the\ copyright\ notice\ for\ the\ Library\ among +\ \ \ these\ notices,\ as\ well\ as\ a\ reference\ directing\ the\ user\ to\ the +\ \ \ copies\ of\ the\ GNU\ GPL\ and\ this\ license\ document. + +\ \ \ d)\ Do\ one\ of\ the\ following: + +\ \ \ \ \ \ \ 0)\ Convey\ the\ Minimal\ Corresponding\ Source\ under\ the\ terms\ of\ this +\ \ \ \ \ \ \ License,\ and\ the\ Corresponding\ Application\ Code\ in\ a\ form +\ \ \ \ \ \ \ suitable\ for,\ and\ under\ terms\ that\ permit,\ the\ user\ to +\ \ \ \ \ \ \ recombine\ or\ relink\ the\ Application\ with\ a\ modified\ version\ of +\ \ \ \ \ \ \ the\ Linked\ Version\ to\ produce\ a\ modified\ Combined\ Work,\ in\ the +\ \ \ \ \ \ \ manner\ specified\ by\ section\ 6\ of\ the\ GNU\ GPL\ for\ conveying +\ \ \ \ \ \ \ Corresponding\ Source. + +\ \ \ \ \ \ \ 1)\ Use\ a\ suitable\ shared\ library\ mechanism\ for\ linking\ with\ the +\ \ \ \ \ \ \ Library.\ \ A\ suitable\ mechanism\ is\ one\ that\ (a)\ uses\ at\ run\ time +\ \ \ \ \ \ \ a\ copy\ of\ the\ Library\ already\ present\ on\ the\ user\[aq]s\ computer +\ \ \ \ \ \ \ system,\ and\ (b)\ will\ operate\ properly\ with\ a\ modified\ version +\ \ \ \ \ \ \ of\ the\ Library\ that\ is\ interface\-compatible\ with\ the\ Linked +\ \ \ \ \ \ \ Version. + +\ \ \ e)\ Provide\ Installation\ Information,\ but\ only\ if\ you\ would\ otherwise +\ \ \ be\ required\ to\ provide\ such\ information\ under\ section\ 6\ of\ the +\ \ \ GNU\ GPL,\ and\ only\ to\ the\ extent\ that\ such\ information\ is +\ \ \ necessary\ to\ install\ and\ execute\ a\ modified\ version\ of\ the +\ \ \ Combined\ Work\ produced\ by\ recombining\ or\ relinking\ the +\ \ \ Application\ with\ a\ modified\ version\ of\ the\ Linked\ Version.\ (If +\ \ \ you\ use\ option\ 4d0,\ the\ Installation\ Information\ must\ accompany +\ \ \ the\ Minimal\ Corresponding\ Source\ and\ Corresponding\ Application +\ \ \ Code.\ If\ you\ use\ option\ 4d1,\ you\ must\ provide\ the\ Installation +\ \ \ Information\ in\ the\ manner\ specified\ by\ section\ 6\ of\ the\ GNU\ GPL +\ \ \ for\ conveying\ Corresponding\ Source.) + +\ \ 5.\ Combined\ Libraries. + +\ \ You\ may\ place\ library\ facilities\ that\ are\ a\ work\ based\ on\ the +Library\ side\ by\ side\ in\ a\ single\ library\ together\ with\ other\ library +facilities\ that\ are\ not\ Applications\ and\ are\ not\ covered\ by\ this +License,\ and\ convey\ such\ a\ combined\ library\ under\ terms\ of\ your +choice,\ if\ you\ do\ both\ of\ the\ following: + +\ \ \ a)\ Accompany\ the\ combined\ library\ with\ a\ copy\ of\ the\ same\ work\ based +\ \ \ on\ the\ Library,\ uncombined\ with\ any\ other\ library\ facilities, +\ \ \ conveyed\ under\ the\ terms\ of\ this\ License. + +\ \ \ b)\ Give\ prominent\ notice\ with\ the\ combined\ library\ that\ part\ of\ it +\ \ \ is\ a\ work\ based\ on\ the\ Library,\ and\ explaining\ where\ to\ find\ the +\ \ \ accompanying\ uncombined\ form\ of\ the\ same\ work. + +\ \ 6.\ Revised\ Versions\ of\ the\ GNU\ Lesser\ General\ Public\ License. + +\ \ The\ Free\ Software\ Foundation\ may\ publish\ revised\ and/or\ new\ versions +of\ the\ GNU\ Lesser\ General\ Public\ License\ from\ time\ to\ time.\ Such\ new +versions\ will\ be\ similar\ in\ spirit\ to\ the\ present\ version,\ but\ may +differ\ in\ detail\ to\ address\ new\ problems\ or\ concerns. + +\ \ Each\ version\ is\ given\ a\ distinguishing\ version\ number.\ If\ the +Library\ as\ you\ received\ it\ specifies\ that\ a\ certain\ numbered\ version +of\ the\ GNU\ Lesser\ General\ Public\ License\ "or\ any\ later\ version" +applies\ to\ it,\ you\ have\ the\ option\ of\ following\ the\ terms\ and +conditions\ either\ of\ that\ published\ version\ or\ of\ any\ later\ version +published\ by\ the\ Free\ Software\ Foundation.\ If\ the\ Library\ as\ you +received\ it\ does\ not\ specify\ a\ version\ number\ of\ the\ GNU\ Lesser +General\ Public\ License,\ you\ may\ choose\ any\ version\ of\ the\ GNU\ Lesser +General\ Public\ License\ ever\ published\ by\ the\ Free\ Software\ Foundation. + +\ \ If\ the\ Library\ as\ you\ received\ it\ specifies\ that\ a\ proxy\ can\ decide +whether\ future\ versions\ of\ the\ GNU\ Lesser\ General\ Public\ License\ shall +apply,\ that\ proxy\[aq]s\ public\ statement\ of\ acceptance\ of\ any\ version\ is +permanent\ authorization\ for\ you\ to\ choose\ that\ version\ for\ the +Library. +\f[] +.fi +.SS PartIO (https://www.disneyanimation.com/technology/partio.html) +.RS +.PP +BSD 3\-Clause License (with specific non\-attribution +clause) (https://github.com/wdas/partio/blob/master/src/lib/io/ZIP.h) +.RE +.IP +.nf +\f[C] +Copyright\ 2010\ Disney\ Enterprises,\ Inc.\ All\ rights\ reserved + +Redistribution\ and\ use\ in\ source\ and\ binary\ forms,\ with\ or\ without +modification,\ are\ permitted\ provided\ that\ the\ following\ conditions\ are +met: + +*\ Redistributions\ of\ source\ code\ must\ retain\ the\ above\ copyright +notice,\ this\ list\ of\ conditions\ and\ the\ following\ disclaimer. + +*\ Redistributions\ in\ binary\ form\ must\ reproduce\ the\ above\ copyright +notice,\ this\ list\ of\ conditions\ and\ the\ following\ disclaimer\ in +the\ documentation\ and/or\ other\ materials\ provided\ with\ the +distribution. + +*\ The\ names\ "Disney",\ "Walt\ Disney\ Pictures",\ "Walt\ Disney\ Animation +Studios"\ or\ the\ names\ of\ its\ contributors\ may\ NOT\ be\ used\ to +endorse\ or\ promote\ products\ derived\ from\ this\ software\ without +specific\ prior\ written\ permission\ from\ Walt\ Disney\ Pictures. + +Disclaimer:\ THIS\ SOFTWARE\ IS\ PROVIDED\ BY\ WALT\ DISNEY\ PICTURES\ AND +CONTRIBUTORS\ "AS\ IS"\ AND\ ANY\ EXPRESS\ OR\ IMPLIED\ WARRANTIES,\ INCLUDING, +BUT\ NOT\ LIMITED\ TO,\ THE\ IMPLIED\ WARRANTIES\ OF\ MERCHANTABILITY,\ FITNESS +FOR\ A\ PARTICULAR\ PURPOSE,\ NONINFRINGEMENT\ AND\ TITLE\ ARE\ DISCLAIMED. +IN\ NO\ EVENT\ SHALL\ WALT\ DISNEY\ PICTURES,\ THE\ COPYRIGHT\ HOLDER\ OR +CONTRIBUTORS\ BE\ LIABLE\ FOR\ ANY\ DIRECT,\ INDIRECT,\ INCIDENTAL,\ SPECIAL, +EXEMPLARY,\ OR\ CONSEQUENTIAL\ DAMAGES\ (INCLUDING,\ BUT\ NOT\ LIMITED\ TO, +PROCUREMENT\ OF\ SUBSTITUTE\ GOODS\ OR\ SERVICES;\ LOSS\ OF\ USE,\ DATA,\ OR +PROFITS;\ OR\ BUSINESS\ INTERRUPTION)\ HOWEVER\ CAUSED\ AND\ BASED\ ON\ ANY +THEORY\ OF\ LIABILITY,\ WHETHER\ IN\ CONTRACT,\ STRICT\ LIABILITY,\ OR\ TORT +(INCLUDING\ NEGLIGENCE\ OR\ OTHERWISE)\ ARISING\ IN\ ANY\ WAY\ OUT\ OF\ THE\ USE +OF\ THIS\ SOFTWARE,\ EVEN\ IF\ ADVISED\ OF\ THE\ POSSIBILITY\ OF\ SUCH\ DAMAGES. +\f[] +.fi +.SS miniz (https://github.com/richgel999/miniz) +.RS +.PP +Public Domain/MIT +License (https://github.com/richgel999/miniz/blob/master/LICENSE) +.RE +.IP +.nf +\f[C] +This\ is\ free\ and\ unencumbered\ software\ released\ into\ the\ public\ domain. + +Anyone\ is\ free\ to\ copy,\ modify,\ publish,\ use,\ compile,\ sell,\ or +distribute\ this\ software,\ either\ in\ source\ code\ form\ or\ as\ a\ compiled +binary,\ for\ any\ purpose,\ commercial\ or\ non\-commercial,\ and\ by\ any +means. + +In\ jurisdictions\ that\ recognize\ copyright\ laws,\ the\ author\ or\ authors +of\ this\ software\ dedicate\ any\ and\ all\ copyright\ interest\ in\ the +software\ to\ the\ public\ domain.\ We\ make\ this\ dedication\ for\ the\ benefit +of\ the\ public\ at\ large\ and\ to\ the\ detriment\ of\ our\ heirs\ and +successors.\ We\ intend\ this\ dedication\ to\ be\ an\ overt\ act\ of +relinquishment\ in\ perpetuity\ of\ all\ present\ and\ future\ rights\ to\ this +software\ under\ copyright\ law. + +THE\ SOFTWARE\ IS\ PROVIDED\ "AS\ IS",\ WITHOUT\ WARRANTY\ OF\ ANY\ KIND, +EXPRESS\ OR\ IMPLIED,\ INCLUDING\ BUT\ NOT\ LIMITED\ TO\ THE\ WARRANTIES\ OF +MERCHANTABILITY,\ FITNESS\ FOR\ A\ PARTICULAR\ PURPOSE\ AND\ NONINFRINGEMENT. +IN\ NO\ EVENT\ SHALL\ THE\ AUTHORS\ BE\ LIABLE\ FOR\ ANY\ CLAIM,\ DAMAGES\ OR +OTHER\ LIABILITY,\ WHETHER\ IN\ AN\ ACTION\ OF\ CONTRACT,\ TORT\ OR\ OTHERWISE, +ARISING\ FROM,\ OUT\ OF\ OR\ IN\ CONNECTION\ WITH\ THE\ SOFTWARE\ OR\ THE\ USE\ OR +OTHER\ DEALINGS\ IN\ THE\ SOFTWARE. + +For\ more\ information,\ please\ refer\ to\ + +Copyright\ 2013\-2014\ RAD\ Game\ Tools\ and\ Valve\ Software +Copyright\ 2010\-2014\ Rich\ Geldreich\ and\ Tenacious\ Software\ LLC +All\ Rights\ Reserved. + +Permission\ is\ hereby\ granted,\ free\ of\ charge,\ to\ any\ person\ obtaining\ a\ copy +of\ this\ software\ and\ associated\ documentation\ files\ (the\ "Software"),\ to\ deal +in\ the\ Software\ without\ restriction,\ including\ without\ limitation\ the\ rights +to\ use,\ copy,\ modify,\ merge,\ publish,\ distribute,\ sublicense,\ and/or\ sell +copies\ of\ the\ Software,\ and\ to\ permit\ persons\ to\ whom\ the\ Software\ is +furnished\ to\ do\ so,\ subject\ to\ the\ following\ conditions: + +The\ above\ copyright\ notice\ and\ this\ permission\ notice\ shall\ be\ included\ in +all\ copies\ or\ substantial\ portions\ of\ the\ Software. + +THE\ SOFTWARE\ IS\ PROVIDED\ "AS\ IS",\ WITHOUT\ WARRANTY\ OF\ ANY\ KIND,\ EXPRESS\ OR +IMPLIED,\ INCLUDING\ BUT\ NOT\ LIMITED\ TO\ THE\ WARRANTIES\ OF\ MERCHANTABILITY, +FITNESS\ FOR\ A\ PARTICULAR\ PURPOSE\ AND\ NONINFRINGEMENT.\ IN\ NO\ EVENT\ SHALL\ THE +AUTHORS\ OR\ COPYRIGHT\ HOLDERS\ BE\ LIABLE\ FOR\ ANY\ CLAIM,\ DAMAGES\ OR\ OTHER +LIABILITY,\ WHETHER\ IN\ AN\ ACTION\ OF\ CONTRACT,\ TORT\ OR\ OTHERWISE,\ ARISING\ FROM, +OUT\ OF\ OR\ IN\ CONNECTION\ WITH\ THE\ SOFTWARE\ OR\ THE\ USE\ OR\ OTHER\ DEALINGS\ IN +THE\ SOFTWARE. +\f[] +.fi diff --git a/include/xlnt/cell/cell.hpp b/include/xlnt/cell/cell.hpp new file mode 100644 index 0000000000..5fcda9b5a2 --- /dev/null +++ b/include/xlnt/cell/cell.hpp @@ -0,0 +1,712 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#pragma once + +#include +#include +#include + +#include +#include +#include +#include + +namespace xlnt { + +enum class calendar; + +class alignment; +class base_format; +class border; +class cell_reference; +class comment; +class fill; +class font; +class format; +class number_format; +class protection; +class range; +class relationship; +class style; +class workbook; +class worksheet; +class xlsx_consumer; +class xlsx_producer; +class phonetic_pr; + +struct date; +struct datetime; +struct time; +struct timedelta; + +namespace detail { + +class xlsx_consumer; +class xlsx_producer; + +struct cell_impl; + +} // namespace detail + +///

+/// Describes a unit of data in a worksheet at a specific coordinate and its +/// associated properties. +/// +/// +/// Properties of interest include style, type, value, and address. +/// The Cell class is required to know its value and type, display options, +/// and any other features of an Excel cell.Utilities for referencing +/// cells using Excel's 'A1' column/row nomenclature are also provided. +/// +class XLNT_API cell +{ +public: + /// + /// Alias xlnt::cell_type to xlnt::cell::type since it looks nicer. + /// + using type = cell_type; + + /// + /// Returns a map of error strings such as \#DIV/0! and their associated indices. + /// + static const std::unordered_map &error_codes(); + + /// + /// Default copy constructor. + /// + cell(const cell &) = default; + + // value + + /// + /// Returns true if value has been set and has not been cleared using cell::clear_value(). + /// + bool has_value() const; + + /// + /// Returns the value of this cell as an instance of type T. + /// Overloads exist for most C++ fundamental types like bool, int, etc. as well + /// as for std::string and xlnt datetime types: date, time, datetime, and timedelta. + /// + template + T value() const; + + /// + /// Makes this cell have a value of type null. + /// All other cell attributes are retained. + /// + void clear_value(); + + /// + /// Sets the type of this cell to null. + /// + void value(std::nullptr_t); + + /// + /// Sets the value of this cell to the given boolean value. + /// + void value(bool boolean_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(int int_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(unsigned int int_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(long long int int_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(unsigned long long int int_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(float float_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(double float_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const date &date_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const time &time_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const datetime &datetime_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const timedelta &timedelta_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const std::string &string_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const char *string_value); + + /// + /// Sets the value of this cell to the given value. + /// + void value(const rich_text &text_value); + + /// + /// Sets the value and formatting of this cell to that of other_cell. + /// + void value(const cell other_cell); + + /// + /// Analyzes string_value to determine its type, convert it to that type, + /// and set the value of this cell to that converted value. + /// + void value(const std::string &string_value, bool infer_type); + + /// + /// Returns the type of this cell. + /// + type data_type() const; + + /// + /// Sets the type of this cell. This should usually be done indirectly + /// by setting the value of the cell to a value of that type. + /// + void data_type(type t); + + // properties + + /// + /// There's no reason to keep a cell which has no value and is not a placeholder. + /// Returns true if this cell has no value, style, isn't merged, etc. + /// + bool garbage_collectible() const; + + /// + /// Returns true iff this cell's number format matches a date format. + /// + bool is_date() const; + + // position + + /// + /// Returns a cell_reference that points to the location of this cell. + /// + cell_reference reference() const; + + /// + /// Returns the column of this cell. + /// + column_t column() const; + + /// + /// Returns the numeric index (A == 1) of the column of this cell. + /// + column_t::index_t column_index() const; + + /// + /// Returns the row of this cell. + /// + row_t row() const; + + /// + /// Returns the location of this cell as an ordered pair (left, top). + /// + std::pair anchor() const; + + // hyperlink + + /// + /// Returns the relationship of this cell's hyperlink. + /// + class hyperlink hyperlink() const; + + /// + /// Adds a hyperlink to this cell pointing to the URI of the given value and sets + /// the text value of the cell to the given parameter. + /// + void hyperlink(const std::string &url, const std::string &display = ""); + + /// + /// Adds an internal hyperlink to this cell pointing to the given cell. + /// + void hyperlink(xlnt::cell target, const std::string &display = ""); + + /// + /// Adds an internal hyperlink to this cell pointing to the given range. + /// + void hyperlink(xlnt::range target, const std::string &display = ""); + + /// + /// Returns true if this cell has a hyperlink set. + /// + bool has_hyperlink() const; + + // computed formatting + + /// + /// Returns the alignment that should be used when displaying this cell + /// graphically based on the workbook default, the cell-level format, + /// and the named style applied to the cell in that order. + /// + class alignment computed_alignment() const; + + /// + /// Returns the border that should be used when displaying this cell + /// graphically based on the workbook default, the cell-level format, + /// and the named style applied to the cell in that order. + /// + class border computed_border() const; + + /// + /// Returns the fill that should be used when displaying this cell + /// graphically based on the workbook default, the cell-level format, + /// and the named style applied to the cell in that order. + /// + class fill computed_fill() const; + + /// + /// Returns the font that should be used when displaying this cell + /// graphically based on the workbook default, the cell-level format, + /// and the named style applied to the cell in that order. + /// + class font computed_font() const; + + /// + /// Returns the number format that should be used when displaying this cell + /// graphically based on the workbook default, the cell-level format, + /// and the named style applied to the cell in that order. + /// + class number_format computed_number_format() const; + + /// + /// Returns the protection that should be used when displaying this cell + /// graphically based on the workbook default, the cell-level format, + /// and the named style applied to the cell in that order. + /// + class protection computed_protection() const; + + // format + + /// + /// Returns true if this cell has had a format applied to it. + /// + bool has_format() const; + + /// + /// Returns the format applied to this cell. If this cell has no + /// format, an invalid_attribute exception will be thrown. + /// + const class format format() const; + + /// + /// Applies the cell-level formatting of new_format to this cell. + /// + void format(const class format new_format); + + /// + /// Removes the cell-level formatting from this cell. + /// This doesn't affect the style that may also be applied to the cell. + /// Throws an invalid_attribute exception if no format is applied. + /// + void clear_format(); + + /// + /// Returns the number format of this cell. + /// + class number_format number_format() const; + + /// + /// Creates a new format in the workbook, sets its number_format + /// to the given format, and applies the format to this cell. + /// + void number_format(const class number_format &format); + + /// + /// Returns the font applied to the text in this cell. + /// + class font font() const; + + /// + /// Creates a new format in the workbook, sets its font + /// to the given font, and applies the format to this cell. + /// + void font(const class font &font_); + + /// + /// Returns the fill applied to this cell. + /// + class fill fill() const; + + /// + /// Creates a new format in the workbook, sets its fill + /// to the given fill, and applies the format to this cell. + /// + void fill(const class fill &fill_); + + /// + /// Returns the border of this cell. + /// + class border border() const; + + /// + /// Creates a new format in the workbook, sets its border + /// to the given border, and applies the format to this cell. + /// + void border(const class border &border_); + + /// + /// Returns the alignment of the text in this cell. + /// + class alignment alignment() const; + + /// + /// Creates a new format in the workbook, sets its alignment + /// to the given alignment, and applies the format to this cell. + /// + void alignment(const class alignment &alignment_); + + /// + /// Returns the protection of this cell. + /// + class protection protection() const; + + /// + /// Creates a new format in the workbook, sets its protection + /// to the given protection, and applies the format to this cell. + /// + void protection(const class protection &protection_); + + // style + + /// + /// Returns true if this cell has had a style applied to it. + /// + bool has_style() const; + + /// + /// Returns a wrapper pointing to the named style applied to this cell. + /// + class style style(); + + /// + /// Returns a wrapper pointing to the named style applied to this cell. + /// + const class style style() const; + + /// + /// Sets the named style applied to this cell to a style named style_name. + /// Equivalent to style(new_style.name()). + /// + void style(const class style &new_style); + + /// + /// Sets the named style applied to this cell to a style named style_name. + /// If this style has not been previously created in the workbook, a + /// key_not_found exception will be thrown. + /// + void style(const std::string &style_name); + + /// + /// Removes the named style from this cell. + /// An invalid_attribute exception will be thrown if this cell has no style. + /// This will not affect the cell format of the cell. + /// + void clear_style(); + + // formula + + /// + /// Returns the string representation of the formula applied to this cell. + /// + std::string formula() const; + + /// + /// Sets the formula of this cell to the given value. + /// This formula string should begin with '='. + /// + void formula(const std::string &formula); + + /// + /// Removes the formula from this cell. After this is called, has_formula() will return false. + /// + void clear_formula(); + + /// + /// Returns true if this cell has had a formula applied to it. + /// + bool has_formula() const; + + // printing + + /// + /// Returns a string representing the value of this cell. If the data type is not a string, + /// it will be converted according to the number format. + /// + std::string to_string() const; + + // merging + + /// + /// Returns true iff this cell has been merged with one or more + /// surrounding cells. + /// + bool is_merged() const; + + /// + /// Makes this a merged cell iff merged is true. + /// Generally, this shouldn't be called directly. Instead, + /// use worksheet::merge_cells on its parent worksheet. + /// + void merged(bool merged); + + // phonetics + + /// + /// Returns true if this cell is set to show phonetic information. + /// + bool phonetics_visible() const; + + /// + /// Enables the display of phonetic information on this cell. + /// + void show_phonetics(bool phonetics); + + /// + /// Returns the error string that is stored in this cell. + /// + std::string error() const; + + /// + /// Directly assigns the value of this cell to be the given error. + /// + void error(const std::string &error); + + /// + /// Returns a cell from this cell's parent workbook at + /// a relative offset given by the parameters. + /// + cell offset(int column, int row); + + /// + /// Returns the worksheet that owns this cell. + /// + class worksheet worksheet(); + + /// + /// Returns the worksheet that owns this cell. + /// + const class worksheet worksheet() const; + + /// + /// Returns the workbook of the worksheet that owns this cell. + /// + class workbook &workbook(); + + /// + /// Returns the workbook of the worksheet that owns this cell. + /// + const class workbook &workbook() const; + + /// + /// Returns the base date of the parent workbook. + /// + calendar base_date() const; + + /// + /// Returns to_check after verifying and fixing encoding, size, and illegal characters. + /// + std::string check_string(const std::string &to_check); + + // comment + + /// + /// Returns true if this cell has a comment applied. + /// + bool has_comment(); + + /// + /// Deletes the comment applied to this cell if it exists. + /// + void clear_comment(); + + /// + /// Gets the comment applied to this cell. + /// + class comment comment(); + + /// + /// Creates a new comment with the given text and optional author and + /// applies it to the cell. + /// + void comment(const std::string &text, + const std::string &author = "Microsoft Office User"); + + /// + /// Creates a new comment with the given text, formatting, and optional + /// author and applies it to the cell. + /// + void comment(const std::string &comment_text, + const class font &comment_font, + const std::string &author = "Microsoft Office User"); + + /// + /// Apply the comment provided as the only argument to the cell. + /// + void comment(const class comment &new_comment); + + /// + /// Returns the width of this cell in pixels. + /// + double width() const; + + /// + /// Returns the height of this cell in pixels. + /// + double height() const; + + // operators + + /// + /// Makes this cell interally point to rhs. + /// The cell data originally pointed to by this cell will be unchanged. + /// + cell &operator=(const cell &rhs); + + /// + /// Returns true if this cell the same cell as comparand (compared by reference). + /// + bool operator==(const cell &comparand) const; + + /// + /// Returns false if this cell the same cell as comparand (compared by reference). + /// + bool operator!=(const cell &comparand) const; + +private: + friend class style; + friend class worksheet; + friend class detail::xlsx_consumer; + friend class detail::xlsx_producer; + friend struct detail::cell_impl; + + /// + /// Returns a non-const reference to the format of this cell. + /// This is for internal use only. + /// + class format modifiable_format(); + + /// + /// Delete the default zero-argument constructor. + /// + cell() = delete; + + /// + /// Private constructor to create a cell from its implementation. + /// + cell(detail::cell_impl *d); + + /// + /// A pointer to this cell's implementation. + /// + detail::cell_impl *d_; +}; + +/// +/// Returns true if this cell is uninitialized. +/// +XLNT_API bool operator==(std::nullptr_t, const cell &cell); + +/// +/// Returns true if this cell is uninitialized. +/// +XLNT_API bool operator==(const cell &cell, std::nullptr_t); + +/// +/// Convenience function for writing cell to an ostream. +/// Uses cell::to_string() internally. +/// +XLNT_API std::ostream &operator<<(std::ostream &stream, const xlnt::cell &cell); + +template <> +bool cell::value() const; + +template <> +int cell::value() const; + +template <> +unsigned int cell::value() const; + +template <> +long long int cell::value() const; + +template <> +unsigned long long cell::value() const; + +template <> +float cell::value() const; + +template <> +double cell::value() const; + +template <> +date cell::value() const; + +template <> +time cell::value

Rbc|6Pk=d@`fS0GaM^>R4BtkAuT@t9go;~m|%=jzV{|3m^D6NN4wz; zVa+-^y8l__^I6ekQ>sF8|8*T^x~=(LN}AK+%Z@|@kNfm^onPvC=lp`||2&Tb<|P)n z2-1LZwX7OJ>Oc8eX%O%Evy%`{!?XG{y1@Z@FHA@BYz&ue4ZSSWjV$ zrWi}M9@&@fK5lA>WVT)D=P%uaCsB%W#Ww=BiN--6^IHh$QIVc6v!8M(s>Gn$m4i_P zn6eY(d^)ek$k8`7S84|BNnusH*x46%5qxjU6t*MKM+isP`dO2=yWJsPZ#P!%kGOsZ z$MDRYrpA-bd|SBU91?t}75*^zs-sJAD5E;If?JX;#GRE3tns};Um7cGq?5k@%m8h7z|Wn@l{i-7gXT6fUOLKOTNk{zF+T`7D7aBqk?>z!sT z@U^mR{MfQB*7tqfT9*Vu2^4o}LUu-_rDD69rmi>7x2A+L%^1onHnv!V8WU^5sa5{o z!^~0K745}^KQaBIY(i%mba!-SweYx>ppE5#(#oGg(Wzv^ z&+bc7%Rq!-ay|9{ zj7T$X{iy*pwFi5hL+Ci)Q(Co^{O2&L=ntF7{47hdh_xr|%CR2V0lUyX?l zoPG%$VVa=?OD7hCtBuuqr0kckBR?{y+@tJ}G=G4NuDPslqGgPlOX%Abd1ZGgo1IMe zzv}@VfVszP+xB5M4)y6t76S@;L?NBWP;@M^JHFMG!>*pb!+#9gVI|IXr#HpFpZ+c@ zFQ?OA=*Ht{r^|yjiL`a?-F5Dly4>llCP~*9H7yJN&A!5GH5FZj8IhdRpaz&}hfVKB zR)9aH46>mE4CXmmw$~@t!3B|IMP$tKS9<->>pF_#Hka&1?jVgR>y5uHu@NnYsic%N zM5bj&b{O;-{sE$k1BbPzXM16G-_;fJUKJyM{{CIfA?kcV9|-f;uH5qYKvw}|Yot2T z`Jw;+VuIsd1GbgUAnH4n!0ubj5+{^TO3v{@Rms4cFqdiW-~r2qWi8_P4+t6}ZTa6S zQD|iHqh;q$IdqHffSd04r|b5Gb%t3%Oe8kU2-ng3?9@Y=d5)PI{&ST03r5NoB}|++ z{e?PJnVOnIaG7Su-4U+ofSTFYEzt$6`;L|^$I3#5E6+2=fZey*a5!^eXzbboC|SR=jORuXIeY-lptT?u_ru6bk? z5&N^4;f=UGRt}0`uU9-Bc_AIi>{ID4U}R+6eSV^F9O3KR-D&Wv@RO8-S;_VjZaL+U zdkv#p=23ZPuzUC{rFwGa#WZp8n1nR{B17V`*7qfk&^*hgY>M?)#}6r)gdNdP*aZ@a zKChL&8kbFclGiFIFCp@n|Cn!cG^-|O-7RqUHDbekKD{JWG7f_QlccdN97`Tk%h#cf zh5o3}6ux;X^~xr<>}x#*pambwP=o1}U#XqscQ}5l&BBCjB-}tYGBR5k*@g53?(>6G z!)Nm9)UB>oZ%_5eBU)kgIX#Rg?`1$Xm?P%jkCAGJdxK61!=7zlNR&4ZD6}0FnM}wU zX2Q)Sv=q3Fi-66b07ad$R7q&DeiS)l46iL0we^o>RJTDCenSx`hcru0EwT`dKO%P{ zr~Cx>&p4BHTgJIu`QH`U?XnmZ-uxu@>&;J~2G6DU`_^ZeRsWsSk1`fBuS2$z4t{Ov z--Bd7f!Yxz!Yplijc|=>JTl->T|)^-x&g}gSgcN!!ga9DR_gpsAa-im z#H?-D2`3EYPGe-2w?2NRG!Rr&NZz?wP0j0Im``3EHP9!Q4C+_U$~l!-?1=NCw3!9uwucM~IP6Lc-NYY2e@qeutZFvxE(FRXTUHc;(9p;wBdn-$4)+|h?|H;D7F z#Pvm#*+f9(jsB0RAcxQg=g}zQXU0~Cjr#Vrs+z5vWLfj+n&Eb;Jrp5Fm)^y?&uU^2 zoA*^d6>0L?JFY~tG1_wJHG?7cdX6>1?-h0ljqOe^f?q?_&@`u zzyIt(32rjEJsr0*b%=)LCf(A7QH`?UHou((B;dR3AtLwR5=@}sLLBRu<=(eHmb%|u zK+GlO%H{1j4x!Ty7v2bszc;pL>1eyb&UikV(P_S9Y+%N%)f3sKk^E2T8He8oUn}8t zp5O616%%4;P;I#mhpyuA*_Jwxd24WZBr}iDa-j3Whu5uywZzT_P53i1#VMQ_(Ma; zikk5#%0Wln$}YA$S||EdoxD=#^gLPP-q7DVi;1nbX1qE+Q;x4tf2OW2Rg@*~8rj%N zhYv#|Hf9y7nzvpldW;ht;F$ag&dZ?nmjw$aB2w7aD8pcpNm)2)M#q639cLaTENMDr zvK>L;yT_eL|E81d?UGYHw*D9}%}ZMJ*d29W_`TE|B@U$o(PfI#i1lka&X7sw;e1ba z{GI-REAW)3t<9ppFlvdD!&i~?O?kRte4TwJsxkRx_>v+iMLsLdW#P7>O+>De8xzRcD2W2}&s6n5q>8nFZTY=Mq> zEMa|VmX7lumNfV9_jf;giPG!zL}E$^E`F)9QUqW2tC_j}(kbce;zK8jgcD%N@%AVj z0%QaaxlzX>I-CPxxxt-aumpzW1yDhr3mQ;5jhnl>vju~S5!dwl zZ*dRcfB)ux!1~aYgO@*E-1i4w+4yN#4lj@FO|^h9txsM^KB;@HL2&T0OY*6EZAZSS zkX$55z2L-nOXw;VyVnI~n)|+L&&9Ps{vU}l`NqT~bd2#u^lkP7N-9@t#Q3>&`*pgQ zEYFmC1_uiLmi8R(WIRZfjxau0*9r7$t(iBQGnGg#ORRYIm;J3po5MLE^N8An+2>C5 zQ8lqog09Uj;(==QuWM1uI^?_(?WYfLRP4EK9ytJPFzT&J#|~YOuBc7Z*7f7}+4TDP zq(dzx=a;m8Z#`yAp-eE=6`ZBU`#e~gTCt14^ZxoD-t>n~<=Iudp zIf)gzasGePVn)$4jeEO_4589^LT7_baeFbfeJaxIbz}3x?Y;1K#ei62;q3Q}fAFL4 z6T@tq-o)-2Id0~S7(#w9khnnc7}%cQ#7GV6YFBv>v(DYpyun_D_I5U)F}S#V}ZXTFs!O zHMx(_cFBB4HAzxN4iVeJd;mo{prd|a9o$>QvLm)bU2Xs6Y?G;JnW3ZDVn`Z zo#ejCFje*$xa4Ul!rEKl6Zq*(M3Oh>xBQ0CDr4%_unl$Vb63r@DI1{Gsu!P3CZPOJ zXLsW^xqn0TH{hN%TeT%JO`D3A`tF;uQ$j&!OccKx5S8X>rT^D~?ni&zU+-)IYRSs9 zElnNkWoOq2E6!HE$W(F{^)gn3kCkOur|ZMOkPEyy&LN6gri6dh>E_V0(F1W5INCT& zaSvHBJ~;^rX_ja`wmwoO@UGVPYHu5oWB(%LDRxJ)1-gOiJ+ucjCO+cKH4LpC6B&4| z63GU{P=0H%W>ENZ9ynkXwze>cE^HwN{NQqM23x&R;@C&Q_ zAG|krYgu{@Fwd=-xm{Rj*ZLG!bVnoqOxrohZ3OE2##Eih55vs(wbV_(xPQ!S78hNK74lq zWcVCFl?*#m*(05L?07fe!d;81(VnjBuxb2Ed8dT`2!$05IyDO)ka~P@}lA*D_xrOa5J;Y&Zw&UF(#;{jin(7o4CR zqXe>nY=s}6yCZ7itliQe(0!QeI$EpN1sf?w^!0k!@!kn1n$frM{Z5rr^Dkm*mYg7S z4`p{GE(R6ge7Qn`&zp?36OPJKzZdFDbKZTpDxUk!>@!fx8JL}{4I*@qg2i<*^O_)) zjkt}QpRCn=YHO_l`Wr>fq7B%8eX6Z56EUrv(^ZHi;Uh}juT&XVbFRge!{-yt)@+*c$GtuxqZ2y~IRovsnPfxE%cpqq7N zrAbEFYj#kuDq`uAeoXzL?w9@C!At5yaah@VNp!~9^oZJZIdru5oKb}E31zIFWmQGR zd%uqs3cs`n_T0w(ep=%jG5X_pPu_^i{kX})vJd{X^|E@r|8&LepYz`gWCC2nFN@-@ z`v?r}DWwF+fevu`>8;c1ZUMf0FC z`+^N5+iwpBrC10>hOGAvnEqg1|M6_WHSn5*|Lk+cdsC6YcW4#ocfh;9;8cd?J-3{) ziNQDUg972}n7j;Q>HMv!gsjM?-vgW&?=?-fPe`{m9%@1L=UxTjjybO76Fy&{^Ip9( zYcESSVrs_Q0Jgh4`li)RlGd)|&~slYQfd5W)%W~~yu2JJQh(>@>*J9&>HZH|jifzY zw(1-Idw0hMpqdjsG1!9A(^Bt~q{>sOA;X2GE8OI>pqLnWPDapr!hd6$FhepET7^_w z3g!nW0tnIf$q>KOmW|?BjJ-QVY@h{Q-Kg5RU`6-oa>Q114l(K^XZ4X&k)umDK;7fUJY{0=DbDAjc3=!cnop; zi|_7+*-BB(W93;GFp$>vM4K)hPXc9)3VJ`+d=Oq!iU}V2v9xuQ$*%jAW#lt9=(oPB z-A_p)DY~%fp;|)Yr>}rhkWC*BZ>rASD`}R;w^G&;t*fU;Dq$?nfnCIHohU;J*|uI-Jzbt25we~Mw;$G5Ovw+F zbOW-ZKNZP^GSw1kvvTs7pC=MsNFJn0(JTi2wB%`VzlULthIxUaz8A+vBL~HFgW*_w ztF<-S9;!XH&DJpN*# zMGWm_t4m^7W4Bf8&xbd|nCGV^$3+4Ey#fas9{tv4TNSOoaElC|Vqy4dMVo&p`f`6} zxlrdFEb}&ELtX<(?6A%vMcwss<&7_Sb)kMA|F3Jvl3;ybd5=+A zQ%A+AJ%^YwA4lu<2o7q#!n7YwNxOL9p1oIzV)vKxE?D;ZDTe2%!!rPz&)$FUi&zwR z*WhbA$-YaX8@|TkLuj2#S0QV^@%wI^=W73^BdHnlx1-~IFfI4}LlH)XB1O8G0l=uH z-b0AX>JU4}Sq5&u;%vBpm(OG#>b}cVq(&&71V;{BL4I(}%7L&cL48fO>ag6Jxj&%F zqeH3yci-3P*ukzkqcrS4sWn(H=~k_QaP6UdA&#v^r-d?Q5($waXXlW}=k6mf%swlC z8edtsF{jQ{DI318WoH6nMT1A6`7hEy8R^rrwqT0~8Iv>TN)|FLP{P?~({j@S?=dIh z8yN`YX-iuf6B4v(_(zayP5eQdd$Vjgf@p59JQ}=P!_pVB*@Z2U{}7~#F#-kG&z-I) z>4usrX^hyP(IKc?1O0)EO$#u?z)t?he& z0?@sK23m5L#%4fH>XHAzIV|UNpFt0Z)T~+*+?7yGoSxz?#;%EZaJZ}TsGr7-7#;(T z>g9@ZS`Ffg2mz=sxU3ulmOJJ*^LO(Wy0~{B3D*bx!}NE{h@Xp^Qor~t4B64*6@j&c zeAnkdm$VIIYLWi#h1l2>mO;g83 zw^Bh-?tb^1AS`BPbyy_dRYBtO2EL0O&n<(e4foN;AZg$;7s%~J!(D{r7 zD}B~rtgyK(Ywb8##5oGLz=zSxb9T-{(HEvf^XA!k+dc;X;0AGG|8Xi3_qSyM>n<|` zNcEs@Jc+QJw2S>u1swP7oQ%ey`+LvEF^~Uo>P-8n*&%z+y?N)}lE#{B<33I&yU1)k z{Zf#mvDapeas4VGW>jKIVx2S$d@L&XLvr?^(IuwSsd3`UmpU;s%L0oadDVGq_p88w z*yKQ}rNguZQz#>-IyEN?x}jRCnVFy2AsM*uDR!34t0}X9Oo-~N4cw8;<4S?o!Ir!}8{nZks{??{ z-b=feJ31pf1hESbj^o}`2U=SmjB;+pu~>@EQumQV)+*Ub9=@I5H1Taihb==SG~qR< zvQJx1S+^N_j8_}~+J=oUb2EAZzPB|`*c2*kWTO%Fq8=cfKnL0~cVEgn2z@bWeQN*H z8!3dEM|@6eF@-E144`&*wY0?LbQhrRrV;?J#%A3dZ&OU}vG4F}LX-#ZTbkoXzEVa< zMn)dK#NeERWWmvKvKGxuzH{_EyFSjBIi< zF>A*E` ztANBVQ8Xux_Cz`K8zz3g2~lZ^B1Dwsz_lY)J!@x1D9V*Rsi2Guq8zMd$ppnqWlR^g z80`!dmPU5w!H) z)&4w~re!!!`0}N)Vd+bAcT++CbQ9`to1)gu`*6XM*FVrPy_r7i^jTmxxG|W`*jj)! zcxJZ3~(=u_SzbCUX~1t94wHaWN~Zbw3eM-NAu!?N%b9@ zJ?F0O+jp%eW$*B8+z_oz$+70L#w~Tf-TT_G^O@-g)vl<{{nxJiNyp%~{;udS$|y4j zrW9YE_F%COn=~SDEI%dwRjyH!Z2LE-XYr7k8~pbtj*i7uU(G8rPSJwb&a6zGFQ%;@ zg<7tO`AjfWJ!!6;=kLv(#6T4B zy~+Hi>DKvx*a)5m3Ig$NV|V+e7upx2MtTgYHqM7Vz|du{^}JhM--8n3>IAYkbZUFQ zXp?$V@2qW|d;)Ib4LPBB?d^_%)Y(gLDW0cgvo<=fdps6FjeeF7?zd)UrW5lCjL%@n zYmg4P(x~M!c-7cUdJD3EL-MnLG+}Xa0Y`P)(P7E&q#V*}r?-1Zxb#@noe%(v_##hh zf1KZBbx3P%!=xF(JxH$ftnVBdDfUoM8Gy*SnY9mooBcg8y4q&!W=U%EJS)9gy%QY1 z!I;9mcaUwCmZ*j-v6;PRv_gD74E<|N>UmvD^VwF+m{x+@v)R|6n`oHOTBF z&qA-Ve6p$|ezxm|hXNv6m`bLYoA1t_lB3GS?wk*xV}+%D(OoyHQ_F8`?2G;I>hQPi z%erI9eu^lVK%rJ4`s4AS2^Akx!dxlXw+94uC6>N#7CuXBGNO-eWD@9lgGXY}gScn5 z8*v(Pv7})SRDDW`QEV8~LkI8oKM#EAQ=^>+WjlXr!eB({9G6!D?GbIbD^`AXfFVA+ z>TGRE|CP0)3lPN7(_fGri80!rn5v9^ji91jT+}{}m<`-VUh#R6V_M zA^^g#5clL{>-mlCGE>pf_8?5kL{d2w!8rECLLrj%er*qWk;b^|6g%-<&Mtf*5o{NZ z_^1YeaNC}hY=yOoTUuJ8@4%^bf25CYs804-_v2<#-xJq=?3`a7x(Nx`zL2)DFMS~~ zhtNE~qNa&8Ju&T_P+o*%CKpNtv61_qwY9|`gj@yaYoS%*eiNMVYyJIpcShUj=^)@% z-ovq!UPmS7O_KtIuty1UgL#*I5C%<7)wtW0ukq@1^53D!=KnM+{TYbkB-{4ZK#=h?vCG3-p@E7w8cXtX`uO#c z>aH4%#GyIMMhso3K)lvMLT3Cuv5kYu=ti#KDa`Mzy7?w|pznigvZJiCVw#l*U!t_K z#I6&p$e)P*)Lm!B0i?Fj+s~8C#LRwk%UT6!$3j55XMI+=>}68koPi{F3QM*TL_JuPIIXS}T2+2gG2#KYYp(|Qh>x{!kA=&z zYbYY*g5={Rd*3?)fb4CWgago4>lp%T!V<$K6-2Z56oYcvcljPvpTX3Y4<`h^L#XSr z{p%&~5j8U)a*@$$O@+t=ByY1gio>(*zYY9@9?n4UonVNkkvqiMqhZt1mo^%dWmfshxccdS+bT*^v7ufXl#FXfvvso8EeanFAl~?g+Z2|Z|qdo zf}Otc-R)UMUVJNb`2S6gl~IMQR0aRA%Q6hrbm80Z_0}IW_9?W$??!yQqOd6(6JJA{ zy4Lk?^Z!tBtAo0(kw2*W^nW?TG_zp8$UtrY`+S}{2S8>VZ^ewx&#W>c1z(}57c=mIT zjRzQ*PD^=_-<(dSEouBXICg{Ff5R?nSsA^)Zs=f`1x6}wzf}3L6`Q(Y*`#crBh#0h;Yh<>0Rix~3^RS-k?GX^Rr|Ynm{)YO}!ks=9bst*! zd6(&N8gqG7%p8CUD)@Jcl3tp)2S2Zsa<}Z5$1ow%nZ>7S%VVz&JB)hu#6F96&$+uV zX&?U4o`*C=_s?SzFF9+&A5R|Kcm88v1=Cw2u~%DPg5&xX{Prp5BT+c=41b%fTAb`N zB!VXzsZuNgjn!f$2qHo2NNoS;Q8nXu(c=(+i|VDUF1ODT!;Eren(~s6OwNA?R2Sh& zQt$tx^TEZ|gl?2PiCiOlh_*P4&eQonWG<(q^*UfS3Ch=BgOhQR#q`Y_IN=DrtC92{-7HS zQGOzwdM`9~W(LS?X7o4Z4Z=v$5q1!Hmg%WOXt`*E!b)g-8x55Ib2%}daxb>+vSrN1 zUYKBHe|obYzcI#8t6>^195&Y*o4>V&BjG;UyRUBKA_TsReTgVuq_NlQw2Az(a;oWm!r|k<%CRR!ro&4MxXx=ZD%jC#bJJld~P=-WBE1+s-I3z~-*R}Jz8TS&vICgHpRPy-OMS*`opny7H0YGWe#y8*OUEnZBHzo!}n1K zY~?H2c#J$$-@e}xVr|FV-rW7sPq06ER!&9jr1!D?&t6E)h5?$V_DocKJgX<(X;D}O zYA4+3M*n_9V;?W+?WujdW6uO5GfM{(m0)s~lfpYz#6{rA5O#LzX)a+*G&JUun}tM6 z$7*xH<~;62oyFg7C7se@Gp}T_1=``3uRrCe#mXLEnMI2vwP6PsqWHdyO6AdGQ$lQC z-q;dH8NsUnj?P-kj`_H){Q%AMb|RtrBWWPg)=j>fY%<6yP{0oR9+Z{{>&N-_bpDKY6W{X>#k?ks69%Tiu%b8=W3NgXu?>*S9Y z{sPK_DD@RmMOg+-GH2e8Q;hL(UBeDod2SyB1k^LHC<m=tN^TodC=JEAA7mHpyhTT7NBkCEdt*CFa z$h3CDD2gZJ0%dudkPBV3UlG08^a(q@uJA@wmk5lbfYGt1obIYC--3Cs?OSXeg!5f0fx&Q*vzW_y@m$$;|`?8_gb;FTS*H@EnF8i_i&rp>^KY!bN zH@U9dvi_bpt(ZsrVx{NdS43YbFsP~IYaDOwyAkmdQkoU9vpW6(b^mO3Q^Cx_K4;8o(N!3tNz;$OM5BOZBJ0)X$NFDPdnWR!Q(%dk<=ZwAxRI+J+3BL^*uOlqwikx zC*7){JxLp|tK#|D%#c;*$CdnbM$@tYIdl|FP&N!Zz`NxDFF?@0U^f{h$iGW`du#Pb zcas!C2O5VxR!aAI8*-@Ik)$7R7wRH{5%TJ?$derA|CF{OJ8gi1vB>X^<#|(e@YA8V zn;7|SnU6qgqsL{WPuH=ow6*ts8;OFKH%0f%LZ-KvgjZdSDvjNpP;gtci;g;{xg+iZtg3lKC{8t9Tzo>Eh;rK{TQ$&aqpOv3?v^&O+nwV&A zDO#ueFnrlqyeU{OFt^JS9xk_h%T$6keloZhm6!$v8itBG`;lt%ebe--R+AN}_Rc$L zITq*P`tD2K$&AtuobnaKI2t?t@roU~Z@3MKGHjEjOGbt9CGW=>IZcF3sqlCfh!o<} zcDS=CtZ_`9D!Ri5c0QDJ3YuI7<@UKU>ul`^q=j3#>zU=Ih{(jm8p+40wo85fp4FcprxnXh&&TCN zG`6ou9~5uWUaMAdyDKfyG}IAeK|;>aFZ59@!3Z#MQdrVL6BcNNa=(5rCe7MdZJG6R zx%bV@CnbzJO}MgveK=#K{*|-W+dG(D<<_a}_o>imQTvH1;`&uLq-0a|Z{$pdw(3Ot zOqQj`j4QGzVB?S_u@9!g>q&1(?F)|U>Qo7g%&(?jm5sqyJCBKMo%^wcfZ%^K3f^}Y z#eOqNOgni(G4mN6^3+i;9cFysP|h6c;h~cU+ycf=YAIh3wtSgPx&PqyG3)zS#o88g zLw5Y~`1w8?h5ebz<`>T1Z@POJN@(ukD>B&~A0!Vb?k7146@P?~Vl0lk_3;WG zci4tI%XvDsGRpe0lyc9ZZeTBHk;j~$GDC?&xtG4ih>yN!rncriQ38Û$6M$W)< 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ΠlrWw;~FTxS6o)dtG`< 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%0DivFDmrTPKl*fs~>NJW~| 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 +#include + +int main() +{ + xlnt::workbook wb; + + const auto password = std::string("secret"); + wb.load(path_helper::sample_file("encrypted.xlsx"), password); + wb.save("decrypted.xlsx"); + + return 0; +} diff --git a/samples/disabled/add_comments.cpp b/samples/disabled/add_comments.cpp new file mode 100644 index 0000000000..ddae8427d1 --- /dev/null +++ b/samples/disabled/add_comments.cpp @@ -0,0 +1 @@ +add_comments.cpp \ No newline at end of file diff --git a/samples/disabled/basic_conditional_formatting.cpp b/samples/disabled/basic_conditional_formatting.cpp new file mode 100644 index 0000000000..f5358dbce8 --- /dev/null +++ b/samples/disabled/basic_conditional_formatting.cpp @@ -0,0 +1 @@ +basic_conditional_formatting.cpp \ No newline at end of file diff --git a/samples/disabled/comment_error.cpp b/samples/disabled/comment_error.cpp new file mode 100644 index 0000000000..6899f521d2 --- /dev/null +++ b/samples/disabled/comment_error.cpp @@ -0,0 +1 @@ +comment_error.cpp \ No newline at end of file diff --git a/samples/disabled/copy_style.cpp b/samples/disabled/copy_style.cpp new file mode 100644 index 0000000000..1887d2a803 --- /dev/null +++ b/samples/disabled/copy_style.cpp @@ -0,0 +1 @@ +copy_style.cpp \ No newline at end of file diff --git a/samples/disabled/create.cpp b/samples/disabled/create.cpp new file mode 100644 index 0000000000..6e8eca082c --- /dev/null +++ b/samples/disabled/create.cpp @@ -0,0 +1,45 @@ +#include +#include +#include + +#include + +int main() +{ + const std::vector> amounts = + { + { "Anne", 17.31 }, + { "Brent", 21.99 }, + { "Catelyn", 94.47 }, + { "Diedrich", 101.05 } + }; + + xlnt::workbook wb; + auto ws = wb.get_active_sheet(); + + ws.get_cell("A1").set_value("Name"); + ws.get_cell("B1").set_value("Amount"); + + std::size_t row = 2; + auto money_format = xlnt::number_format::from_builtin_id(44); + auto &style = wb.create_style("Currency"); + style.set_builtin_id(4); + style.set_number_format(money_format); + + for (const auto &amount : amounts) + { + ws.get_cell(xlnt::cell_reference(1, row)).set_value(amount.first); + ws.get_cell(xlnt::cell_reference(2, row)).set_value(amount.second); + ws.get_cell(xlnt::cell_reference(2, row)).set_style("Currency"); + + row++; + } + + std::string sum_formula = "=SUM(B2:B" + std::to_string(row - 1) + ")"; + ws.get_cell(xlnt::cell_reference(2, row)).set_style("Currency"); + ws.get_cell(xlnt::cell_reference(2, row)).set_formula(sum_formula); + + wb.save("create.xlsx"); + + return 0; +} diff --git a/samples/disabled/default_styles.cpp b/samples/disabled/default_styles.cpp new file mode 100644 index 0000000000..7d8d06023b --- /dev/null +++ b/samples/disabled/default_styles.cpp @@ -0,0 +1 @@ +default_styles.cpp \ No newline at end of file diff --git a/samples/disabled/font_legacy_colors.cpp b/samples/disabled/font_legacy_colors.cpp new file mode 100644 index 0000000000..270ba3da1d --- /dev/null +++ b/samples/disabled/font_legacy_colors.cpp @@ -0,0 +1 @@ +font_legacy_colors.cpp \ No newline at end of file diff --git a/samples/disabled/font_rgb_colors.cpp b/samples/disabled/font_rgb_colors.cpp new file mode 100644 index 0000000000..881a4feed3 --- /dev/null +++ b/samples/disabled/font_rgb_colors.cpp @@ -0,0 +1 @@ +font_rgb_colors.cpp \ No newline at end of file diff --git a/samples/disabled/group_columns.cpp b/samples/disabled/group_columns.cpp new file mode 100644 index 0000000000..39a0028250 --- /dev/null +++ b/samples/disabled/group_columns.cpp @@ -0,0 +1 @@ +group_columns.cpp \ No newline at end of file diff --git a/samples/disabled/header_footer.cpp b/samples/disabled/header_footer.cpp new file mode 100644 index 0000000000..8282c82819 --- /dev/null +++ b/samples/disabled/header_footer.cpp @@ -0,0 +1 @@ +header_footer.cpp \ No newline at end of file diff --git a/samples/disabled/image.cpp b/samples/disabled/image.cpp new file mode 100644 index 0000000000..d047359cad --- /dev/null +++ b/samples/disabled/image.cpp @@ -0,0 +1 @@ +image.cpp \ No newline at end of file diff --git a/samples/disabled/merge_unmerge.cpp b/samples/disabled/merge_unmerge.cpp new file mode 100644 index 0000000000..a95748d857 --- /dev/null +++ b/samples/disabled/merge_unmerge.cpp @@ -0,0 +1 @@ +merge_unmerge.cpp \ No newline at end of file diff --git a/samples/disabled/page_setup.cpp b/samples/disabled/page_setup.cpp new file mode 100644 index 0000000000..07db4da0a6 --- /dev/null +++ b/samples/disabled/page_setup.cpp @@ -0,0 +1 @@ +page_setup.cpp \ No newline at end of file diff --git a/samples/disabled/parse_formulae.cpp b/samples/disabled/parse_formulae.cpp new file mode 100644 index 0000000000..fc3279b9f9 --- /dev/null +++ b/samples/disabled/parse_formulae.cpp @@ -0,0 +1 @@ +parse_formulae.cpp \ No newline at end of file diff --git a/samples/disabled/print_options.cpp b/samples/disabled/print_options.cpp new file mode 100644 index 0000000000..ae580894a1 --- /dev/null +++ b/samples/disabled/print_options.cpp @@ -0,0 +1 @@ +print_options.cpp \ No newline at end of file diff --git a/samples/disabled/read.cpp b/samples/disabled/read.cpp new file mode 100644 index 0000000000..8cde6278f7 --- /dev/null +++ b/samples/disabled/read.cpp @@ -0,0 +1,36 @@ +#include +#include + +// Read sample1.xlsx and print out a 2-dimensional +// representation of each sheet. Cells are separated by commas. +// Each new line is a new row. +int main() +{ + // Create a new workbook by reading sample1.xlsx in the current directory. + xlnt::workbook wb; + wb.load("sample1.xlsx"); + + // The workbook class has begin and end methods so it can be iterated upon. + // Each item is a sheet in the workbook. + for(const auto sheet : wb) + { + // Print the title of the sheet on its own line. + std::cout << sheet.get_title() << ": " << std::endl; + + // Iterating on a range, such as from worksheet::rows, yields cell_vectors. + // Cell vectors don't actually contain cells to reduce overhead. + // Instead they hold a reference to a worksheet and the current cell_reference. + // Internally, calling worksheet::get_cell with the current cell_reference yields the next cell. + // This allows easy and fast iteration over a row (sometimes a column) in the worksheet. + for(auto row : sheet.rows()) + { + for(auto cell : row) + { + // cell::operator<< adds a string represenation of the cell's value to the stream. + std::cout << cell << ", "; + } + + std::cout << std::endl; + } + } +} diff --git a/samples/disabled/row_column_style.cpp b/samples/disabled/row_column_style.cpp new file mode 100644 index 0000000000..5a34070e14 --- /dev/null +++ b/samples/disabled/row_column_style.cpp @@ -0,0 +1 @@ +row_column_style.cpp \ No newline at end of file diff --git a/samples/disabled/style_application.cpp b/samples/disabled/style_application.cpp new file mode 100644 index 0000000000..2fbdef10cd --- /dev/null +++ b/samples/disabled/style_application.cpp @@ -0,0 +1 @@ +style_application.cpp \ No newline at end of file diff --git a/samples/disabled/style_side_effects.cpp b/samples/disabled/style_side_effects.cpp new file mode 100644 index 0000000000..251f729c0e --- /dev/null +++ b/samples/disabled/style_side_effects.cpp @@ -0,0 +1 @@ +style_side_effects.cpp \ No newline at end of file diff --git a/samples/disabled/using_formulae.cpp b/samples/disabled/using_formulae.cpp new file mode 100644 index 0000000000..b58b45d90f --- /dev/null +++ b/samples/disabled/using_formulae.cpp @@ -0,0 +1 @@ +using_formulae.cpp \ No newline at end of file diff --git a/samples/disabled/using_number_formats.cpp b/samples/disabled/using_number_formats.cpp new file mode 100644 index 0000000000..7bbca6009a --- /dev/null +++ b/samples/disabled/using_number_formats.cpp @@ -0,0 +1 @@ +using_number_formats.cpp \ No newline at end of file diff --git a/samples/disabled/validate_cells.cpp b/samples/disabled/validate_cells.cpp new file mode 100644 index 0000000000..7d57605744 --- /dev/null +++ b/samples/disabled/validate_cells.cpp @@ -0,0 +1 @@ +validate_cells.cpp \ No newline at end of file diff --git a/samples/disabled/worksheet_properties.cpp b/samples/disabled/worksheet_properties.cpp new file mode 100644 index 0000000000..cf416d425c --- /dev/null +++ b/samples/disabled/worksheet_properties.cpp @@ -0,0 +1 @@ +worksheet_properties.cpp \ No newline at end of file diff --git a/samples/disabled/write.cpp b/samples/disabled/write.cpp new file mode 100644 index 0000000000..d1071fceb6 --- /dev/null +++ b/samples/disabled/write.cpp @@ -0,0 +1,44 @@ +#include +#include + +// Make 3 sheets containing 10,000 cells with unique numeric values. +int main() +{ + // create the workbook + xlnt::workbook workbook; + + // workbooks have a single sheet called "Sheet" initially so let's get rid of it + auto to_remove = workbook.get_sheet_by_name("Sheet"); + workbook.remove_sheet(to_remove); + + // this loop will create three sheets and populate them with data + for(int i = 0; i < 3; i++) + { + // the title will be "Sample2-1", "Sample2-2", or "Sample2-3" + // if we don't specify a title, these would be "Sheet#" where + // # is the lowest number that doesn't have a corresponding sheet yet. + auto sheet = workbook.create_sheet("Sample2-" + std::to_string(i)); + + for(int row = 1; row < 101; row++) + { + for(int column = 1; column < 101; column++) + { + // Since we can't overload subscript to accept both number, + // create a cell_reference which "points" to the current cell. + xlnt::cell_reference ref(column, row); + + // This is important! + // The cell class is really just a wrapper around a pointer. + // For this reason, we can store them by value and still modify + // the data in the containing worksheet. + auto cell = sheet[ref]; + + // set_value has overloads for many types such as strings and ints + cell.set_value(row * 100 + column); + } + } + } + + // This will be written to the current directory. + workbook.save("sample2.xlsx"); +} diff --git a/samples/documentation.cpp b/samples/documentation.cpp new file mode 100644 index 0000000000..4e76c98dad --- /dev/null +++ b/samples/documentation.cpp @@ -0,0 +1,226 @@ +// Copyright (c) 2017-2018 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include "helpers/path_helper.hpp" + +// Readme +// from https://tfussell.gitbooks.io/xlnt/content/ and https://github.com/tfussell/xlnt/blob/master/README.md +void sample_readme_example1() +{ + xlnt::workbook wb; + xlnt::worksheet ws = wb.active_sheet(); + + ws.cell("A1").value(5); + ws.cell("B2").value("string data"); + ws.cell("C3").formula("=RAND()"); + + ws.merge_cells("C3:C4"); + ws.freeze_panes("B2"); + + wb.save("sample.xlsx"); +} + +// Simple - reading from an existing xlsx spread sheet. +// from https://tfussell.gitbooks.io/xlnt/content/docs/introduction/Examples.html +void sample_read_and_print_example() +{ + xlnt::workbook wb; + wb.load(path_helper::sample_file("documentation-print.xlsx")); // modified to use the test data directory + auto ws = wb.active_sheet(); + std::clog << "Processing spread sheet" << std::endl; + for (auto row : ws.rows(false)) + { + for (auto cell : row) + { + std::clog << cell.to_string() << std::endl; + } + } + std::clog << "Processing complete" << std::endl; +} + +// Simple - storing a spread sheet in a 2 dimensional C++ Vector for further processing +// from https://tfussell.gitbooks.io/xlnt/content/docs/introduction/Examples.html +void sample_read_into_vector_example() +{ + xlnt::workbook wb; + wb.load(path_helper::sample_file("documentation-print.xlsx")); // modified to use the test data directory + auto ws = wb.active_sheet(); + std::clog << "Processing spread sheet" << std::endl; + std::clog << "Creating a single vector which stores the whole spread sheet" << std::endl; + std::vector> theWholeSpreadSheet; + for (auto row : ws.rows(false)) + { + std::clog << "Creating a fresh vector for just this row in the spread sheet" << std::endl; + std::vector aSingleRow; + for (auto cell : row) + { + std::clog << "Adding this cell to the row" << std::endl; + aSingleRow.push_back(cell.to_string()); + } + std::clog << "Adding this entire row to the vector which stores the whole spread sheet" << std::endl; + theWholeSpreadSheet.push_back(aSingleRow); + } + std::clog << "Processing complete" << std::endl; + std::clog << "Reading the vector and printing output to the screen" << std::endl; + for (int rowInt = 0; rowInt < theWholeSpreadSheet.size(); rowInt++) + { + for (int colInt = 0; colInt < theWholeSpreadSheet.at(rowInt).size(); colInt++) + { + std::cout << theWholeSpreadSheet.at(rowInt).at(colInt) << std::endl; + } + } +} + +// Simple - writing values to a new xlsx spread sheet. +// from https://tfussell.gitbooks.io/xlnt/content/docs/introduction/Examples.html +void sample_write_sheet_to_file_example() +{ + // Creating a 2 dimensional vector which we will write values to + std::vector> wholeWorksheet; + //Looping through each row (100 rows as per the second argument in the for loop) + for (int outer = 0; outer < 100; outer++) + { + //Creating a fresh vector for a fresh row + std::vector singleRow; + //Looping through each of the columns (100 as per the second argument in the for loop) in this particular row + for (int inner = 0; inner < 100; inner++) + { + //Adding a single value in each cell of the row + std::string val = std::to_string(inner + 1); + singleRow.push_back(val); + } + //Adding the single row to the 2 dimensional vector + wholeWorksheet.push_back(singleRow); + std::clog << "Writing to row " << outer << " in the vector " << std::endl; + } + //Writing to the spread sheet + //Creating the output workbook + std::clog << "Creating workbook" << std::endl; + xlnt::workbook wbOut; + //Setting the destination output file name + std::string dest_filename = "output.xlsx"; + //Creating the output worksheet + xlnt::worksheet wsOut = wbOut.active_sheet(); + //Giving the output worksheet a title/name + wsOut.title("data"); + //We will now be looping through the 2 dimensional vector which we created above + //In this case we have two iterators one for the outer loop (row) and one for the inner loop (column) + std::clog << "Looping through vector and writing to spread sheet" << std::endl; + for (int fOut = 0; fOut < wholeWorksheet.size(); fOut++) + { + std::clog << "Row" << fOut << std::endl; + for (int fIn = 0; fIn < wholeWorksheet.at(fOut).size(); fIn++) + { + //Take notice of the difference between accessing the vector and accessing the work sheet + //As you may already know Excel spread sheets start at row 1 and column 1 (not row 0 and column 0 like you would expect from a C++ vector) + //In short the xlnt cell reference starts at column 1 row 1 (hence the + 1s below) and the vector reference starts at row 0 and column 0 + wsOut.cell(xlnt::cell_reference(fIn + 1, fOut + 1)).value(wholeWorksheet.at(fOut).at(fIn)); + //Further clarification to avoid confusion + //Cell reference arguments are (column number, row number); e.g. cell_reference(fIn + 1, fOut + 1) + //Vector arguments are (row number, column number); e.g. wholeWorksheet.at(fOut).at(fIn) + } + } + std::clog << "Finished writing spread sheet" << std::endl; + wbOut.save(dest_filename); +} + +// Number Formatting +// from https://tfussell.gitbooks.io/xlnt/content/docs/advanced/Formatting.html +void sample_number_formatting_example() +{ + xlnt::workbook wb; + auto cell = wb.active_sheet().cell("A1"); + cell.number_format(xlnt::number_format::percentage()); + cell.value(0.513); + std::cout << '\n' + << cell.to_string() << std::endl; +} +// Properties +// from https://tfussell.gitbooks.io/xlnt/content/docs/advanced/Properties.html +void sample_properties_example() +{ + xlnt::workbook wb; + wb.core_property(xlnt::core_property::category, "hors categorie"); + wb.core_property(xlnt::core_property::content_status, "good"); + wb.core_property(xlnt::core_property::created, xlnt::datetime(2017, 1, 15)); + wb.core_property(xlnt::core_property::creator, "me"); + wb.core_property(xlnt::core_property::description, "description"); + wb.core_property(xlnt::core_property::identifier, "id"); + wb.core_property(xlnt::core_property::keywords, {"wow", "such"}); + wb.core_property(xlnt::core_property::language, "Esperanto"); + wb.core_property(xlnt::core_property::last_modified_by, "someone"); + wb.core_property(xlnt::core_property::last_printed, xlnt::datetime(2017, 1, 15)); + wb.core_property(xlnt::core_property::modified, xlnt::datetime(2017, 1, 15)); + wb.core_property(xlnt::core_property::revision, "3"); + wb.core_property(xlnt::core_property::subject, "subject"); + wb.core_property(xlnt::core_property::title, "title"); + wb.core_property(xlnt::core_property::version, "1.0"); + wb.extended_property(xlnt::extended_property::application, "xlnt"); + wb.extended_property(xlnt::extended_property::app_version, "0.9.3"); + wb.extended_property(xlnt::extended_property::characters, 123); + wb.extended_property(xlnt::extended_property::characters_with_spaces, 124); + wb.extended_property(xlnt::extended_property::company, "Incorporated Inc."); + wb.extended_property(xlnt::extended_property::dig_sig, "?"); + wb.extended_property(xlnt::extended_property::doc_security, 0); + wb.extended_property(xlnt::extended_property::heading_pairs, true); + wb.extended_property(xlnt::extended_property::hidden_slides, false); + wb.extended_property(xlnt::extended_property::h_links, 0); + wb.extended_property(xlnt::extended_property::hyperlink_base, 0); + wb.extended_property(xlnt::extended_property::hyperlinks_changed, true); + wb.extended_property(xlnt::extended_property::lines, 42); + wb.extended_property(xlnt::extended_property::links_up_to_date, false); + wb.extended_property(xlnt::extended_property::manager, "johnny"); + wb.extended_property(xlnt::extended_property::m_m_clips, "?"); + wb.extended_property(xlnt::extended_property::notes, "note"); + wb.extended_property(xlnt::extended_property::pages, 19); + wb.extended_property(xlnt::extended_property::paragraphs, 18); + wb.extended_property(xlnt::extended_property::presentation_format, "format"); + wb.extended_property(xlnt::extended_property::scale_crop, true); + wb.extended_property(xlnt::extended_property::shared_doc, false); + wb.extended_property(xlnt::extended_property::slides, 17); + wb.extended_property(xlnt::extended_property::template_, "template!"); + wb.extended_property(xlnt::extended_property::titles_of_parts, {"title"}); + wb.extended_property(xlnt::extended_property::total_time, 16); + wb.extended_property(xlnt::extended_property::words, 101); + wb.custom_property("test", {1, 2, 3}); + wb.custom_property("Editor", "John Smith"); + wb.save("lots_of_properties.xlsx"); +} + +int main() +{ + sample_readme_example1(); + std::clog << '\n'; + sample_read_and_print_example(); + std::clog << '\n'; + sample_read_into_vector_example(); + std::clog << '\n'; + sample_write_sheet_to_file_example(); + std::clog << '\n'; + sample_number_formatting_example(); + std::clog << '\n'; + sample_properties_example(); + std::clog.flush(); + return 0; +} \ No newline at end of file diff --git a/samples/img2xlsx.cpp b/samples/img2xlsx.cpp new file mode 100644 index 0000000000..9bad6b786c --- /dev/null +++ b/samples/img2xlsx.cpp @@ -0,0 +1,242 @@ +// Copyright (c) 2017-2018 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include +#include +#include + +#include + +#define STB_IMAGE_IMPLEMENTATION +#include "stb_image.h" + +namespace { + +// This sample demonstrates the use of some complex formatting methods to create +// a workbook in which each cell has a fill based on the pixels of an image +// thereby appearing as a mosaic of the given image. Two methods for achieving +// this effect are demonstrated: cell-level format and conditional formatting. + +// Clean up the code with some alias declarations +using byte = std::uint8_t; +using pixel = std::array; +using pixmap = std::vector>; + +// Specify whether the CF or cell format method should be used +static const bool use_conditional_formatting = false; + +// Returns a 2D vector of pixels from a given filename. Accepts all file types +// supported by stb_image (JPEG, PNG, TGA, BMP, PSD, GIF, HDR, PIC, PNM). +pixmap load_image(const std::string &filename) +{ + int width = 0; + int height = 0; + int bpp = 0; + + // Must be freed after use with stbi_image_free + auto image_data = stbi_load(filename.c_str(), &width, &height, &bpp, 0); + + if (image_data == nullptr) + { + throw xlnt::exception("bad image or file not found: " + filename); + } + + pixmap result; + + for (auto row = 0; row < height; ++row) + { + std::vector row_pixels; + + for (auto column = 0; column < width; ++column) + { + auto r = image_data[row * width * bpp + column * bpp]; + auto g = image_data[row * width * bpp + column * bpp + 1]; + auto b = image_data[row * width * bpp + column * bpp + 2]; + auto current_pixel = pixel({ r, g, b }); + row_pixels.push_back(current_pixel); + } + + result.push_back(row_pixels); + } + + stbi_image_free(image_data); + + return result; +} + +// Builds and returns a workbook in which each cell has a value +// equal to the color of the pixel in the given image. A conditional format +// is created for every color to set the background fill of each cell to the +// color of its value. This is very slow for large images but is intended +// to illustrate a realistic use of conditional formatting. +xlnt::workbook build_workbook_cf(const pixmap &image) +{ + // Create a default workbook with a single worksheet + xlnt::workbook wb; + // Get the active sheet (the only sheet in this case) + auto ws = wb.active_sheet(); + // The reference to the cell which is being operated upon + auto current_cell = xlnt::cell_reference("A1"); + // The range of cells which will be modified. This is required for conditional formats + auto range = ws.range(xlnt::range_reference(1, 1, + static_cast(image[0].size()), + static_cast(image.size()))); + + // Track the previously created conditonal formats so they are only created once + std::unordered_set defined_colors; + + // Iterate over each row in the source image + for (const auto &image_row : image) + { + // Iterate over each pixel in the image row + for (const auto &image_pixel : image_row) + { + // Build an xlnt compatible RGB color from the pixel byte array + const auto color = xlnt::rgb_color(image_pixel[0], image_pixel[1], image_pixel[2]); + + // Only create the conditional format if it doesn't yet exist + if (defined_colors.count(color.hex_string()) == 0) + { + // The condition under which the conditional format applies to a cell + // In this case, the condition is satisfied when the text of the cell + // contains the hex string representing the pixel color. + const auto condition = xlnt::condition::text_contains(color.hex_string()); + // Create a new conditional format with the above condition on the image pixel range + auto format = range.conditional_format(condition); + // Define the fill for the conditional format + format.fill(xlnt::pattern_fill().background(color)); + + // Record the created of this CF + defined_colors.insert(color.hex_string()); + } + + // Dereference the cell at the current position and set its value to the pixel color + ws.cell(current_cell).value(color.hex_string()); + // Increment the column + current_cell.column_index(current_cell.column_index() + 1); + } + + // Reached the end of the row--move to the first column of the next row + current_cell.row(current_cell.row() + 1); + current_cell.column_index("A"); + + // Show some progress, it can take a while... + std::cout << current_cell.row() << " " << defined_colors.size() << std::endl; + } + + // Return the resulting workbook + return wb; +} + +// Builds and returns a workbook in which each cell has a value +// equal to the color of the pixel in the given image. To accomplish this, +// a named style is created for every color in the image and is applied +// to each cell corresponding to pixels of that color. +xlnt::workbook build_workbook_normal(const pixmap &image) +{ + // Create a default workbook with a single worksheet + xlnt::workbook wb; + // Get the active sheet (the only sheet in this case) + auto ws = wb.active_sheet(); + // The reference to the cell which is being operated upon + auto current_cell = xlnt::cell_reference("A1"); + + // Iterate over each row in the source image + for (const auto &image_row : image) + { + // Iterate over each pixel in the image row + for (const auto &image_pixel : image_row) + { + // Build an xlnt compatible RGB color from the pixel byte array + const auto color = xlnt::rgb_color(image_pixel[0], image_pixel[1], image_pixel[2]); + + // Only create the style if it doesn't yet exist in the workbook + if (!wb.has_style(color.hex_string())) + { + // A style is constructed on a workbook by providing a unique name + auto color_style = wb.create_style(color.hex_string()); + // Set the fill to a solid fill of the pixel color + color_style.fill(xlnt::fill::solid(color)); + } + + // Dereference the cell at the current position and use the previously created color style + ws.cell(current_cell).style(color.hex_string()); + // Increment the column + current_cell.column_index(current_cell.column_index() + 1); + } + + // Reached the end of the row--move to the first column of the next row + current_cell.row(current_cell.row() + 1); + current_cell.column_index("A"); + + // Show some progress, it can take a while... + std::cout << current_cell.row() << std::endl; + } + + // Return the resulting workbook + return wb; +} + +// Builds and returns a workbook in which each cell has a value +// equal to the color of the pixel in the given image using the +// conditional formatting or cell-level formatting depending on +// the value of use_conditional_formatting defined at the top of +// this file. +xlnt::workbook build_workbook(const pixmap &image) +{ + if (use_conditional_formatting) + { + return build_workbook_cf(image); + } + else + { + return build_workbook_normal(image); + } +} + +} // namespace + +// Entry point +int main(int argc, char *argv[]) +{ + // Ensure that there is a correct number of arguments + if (argc < 3) + { + std::cout << "usage: img2xlsx " << std::endl; + return 0; + } + + // The first argument is the name of the input image + const auto input = std::string(argv[1]); + // Load the input image. An exception will be thrown if it doesn't exist. + const auto image = load_image(input); + // Build the workbook from the image + auto workbook = build_workbook(image); + // The second argument is the name of the file to save the workbook as. + const auto output = std::string(argv[2]); + // Save the workbook + workbook.save(output); + + return 0; +} diff --git a/samples/stb_image.h b/samples/stb_image.h new file mode 100644 index 0000000000..ae2ada6a6b --- /dev/null +++ b/samples/stb_image.h @@ -0,0 +1,7177 @@ +/* stb_image - v2.15 - public domain image loader - http://nothings.org/stb_image.h + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) partial animated GIF support + limited 16-bit PSD support + minor bugs, code cleanup, and compiler warnings + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes + Fabian "ryg" Giesen + Arseny Kapoulkine + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Phil Jordan + Dave Moore Roy Eltham Hayaki Saito Nathan Reed + Won Chun Luke Graham Johan Duparc Nick Verigakis + the Horde3D community Thomas Ruf Ronny Chevalier Baldur Karlsson + Janez Zemva John Bartholomew Michal Cichon github:rlyeh + Jonathan Blow Ken Hamada Tero Hanninen github:romigrou + Laurent Gomila Cort Stratton Sergio Gonzalez github:svdijk + Aruelien Pocheville Thibault Reuille Cass Everitt github:snagar + Ryamond Barbiero Paul Du Bois Engin Manap github:Zelex + Michaelangel007@github Philipp Wiesemann Dale Weiler github:grim210 + Oriol Ferrer Mesia Josh Tobin Matthew Gregan github:sammyhw + Blazej Dariusz Roszkowski Gregory Mullen github:phprus + +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 16-bit-per-channel PNG +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - no 1-bit BMP +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data) +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise. +// If req_comp is non-zero, *comp has the number of components that _would_ +// have been output otherwise. E.g. if you set req_comp to 4, you will always +// get RGBA output, but you can check *comp to see if it's trivially opaque +// because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *comp will be unchanged. The function stbi_failure_reason() +// can be queried for an extremely brief, end-user unfriendly explanation +// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid +// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy to use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// make more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image now supports loading HDR images in general, and currently +// the Radiance .HDR file format, although the support is provided +// generically. You can still load any file through the existing interface; +// if you attempt to load an HDR file, it will be automatically remapped to +// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// By default we convert iphone-formatted PNGs back to RGB, even though +// they are internally encoded differently. You can disable this conversion +// by by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through (which +// is BGR stored in RGB). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// + + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for req_comp + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif +// @TODO the other variants + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// NOT THREADSAFE +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); + +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + + +#ifdef _MSC_VER +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +static int stbi__sse2_available() +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +static int stbi__sse2_available() +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +// assume GCC or Clang on ARM targets +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + fseek((FILE*) user, n, SEEK_CUR); +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +// this is not threadsafe +static const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} + +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load = flag_true_if_should_flip; +} + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + if (ri.bits_per_channel != 8) { + STBI_ASSERT(ri.bits_per_channel == 16); + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int w = *x, h = *y; + int channels = req_comp ? req_comp : *comp; + int row,col,z; + stbi_uc *image = (stbi_uc *) result; + + // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once + for (row = 0; row < (h>>1); row++) { + for (col = 0; col < w; col++) { + for (z = 0; z < channels; z++) { + stbi_uc temp = image[(row * w + col) * channels + z]; + image[(row * w + col) * channels + z] = image[((h - row - 1) * w + col) * channels + z]; + image[((h - row - 1) * w + col) * channels + z] = temp; + } + } + } + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + if (ri.bits_per_channel != 16) { + STBI_ASSERT(ri.bits_per_channel == 8); + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int w = *x, h = *y; + int channels = req_comp ? req_comp : *comp; + int row,col,z; + stbi__uint16 *image = (stbi__uint16 *) result; + + // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once + for (row = 0; row < (h>>1); row++) { + for (col = 0; col < w; col++) { + for (z = 0; z < channels; z++) { + stbi__uint16 temp = image[(row * w + col) * channels + z]; + image[(row * w + col) * channels + z] = image[((h - row - 1) * w + col) * channels + z]; + image[((h - row - 1) * w + col) * channels + z] = temp; + } + } + } + } + + return (stbi__uint16 *) result; +} + +#ifndef STBI_NO_HDR +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int w = *x, h = *y; + int depth = req_comp ? req_comp : *comp; + int row,col,z; + float temp; + + // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once + for (row = 0; row < (h>>1); row++) { + for (col = 0; col < w; col++) { + for (z = 0; z < depth; z++) { + temp = result[(row * w + col) * depth + z]; + result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z]; + result[((h - row - 1) * w + col) * depth + z] = temp; + } + } + } + } +} +#endif + +#ifndef STBI_NO_STDIO + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_file(&s,f); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} + +static void stbi__skip(stbi__context *s, int n) +{ + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} + +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} + +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} + +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + return z + (stbi__get16le(s) << 16); +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0], dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]), dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break; + default: STBI_ASSERT(0); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} + +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0], dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]), dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; } break; + default: STBI_ASSERT(0); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0,code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (stbi_uc) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1 << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k << 8) + (run << 4) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + + sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB + k = stbi_lrot(j->code_buffer, n); + STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask))); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & ~sgn); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + diff = t ? stbi__extend_receive(j, t) : 0; + + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) (dc << j->succ_low); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) << shift); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) << shift); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) << 12) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0] << 2; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = sixteen ? stbi__get16be(z->s) : stbi__get8(z->s); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!stbi__at_eof(j->s)) { + int x = stbi__get8(j->s); + if (x == 255) { + j->marker = stbi__get8(j->s); + break; + } + } + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) stbi__err("bad DNL height", "Corrupt JPEG"); + } else { + if (!stbi__process_marker(j, m)) return 0; + } + m = stbi__get_marker(j); + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4]; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc k = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], k); + out[1] = stbi__blinn_8x8(coutput[1][i], k); + out[2] = stbi__blinn_8x8(coutput[2][i], k); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc k = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], k); + out[1] = stbi__blinn_8x8(255 - out[1], k); + out[2] = stbi__blinn_8x8(255 - out[2], k); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc k = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], k); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], k); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], k); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) *out++ = y[i], *out++ = 255; + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[288]; + stbi__uint16 value[288]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + if (z->zbuffer >= z->zbuffer_end) return 0; + return *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + STBI_ASSERT(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s == 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + STBI_ASSERT(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) stbi__fill_bits(a); + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (int) (z->zout - z->zout_start); + limit = old_limit = (int) (z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + return 1; + } + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (zout + len > a->zout_end) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) + c = stbi__zreceive(a,3)+3; + else { + STBI_ASSERT(c == 18); + c = stbi__zreceive(a,7)+11; + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + STBI_ASSERT(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[288] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , 288)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filters used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_paeth_first +}; + +static int stbi__paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p-a); + int pb = abs(p-b); + int pc = abs(p-c); + if (pa <= pb && pa <= pc) return a; + if (pb <= pc) return b; + return c; +} + +static stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + img_len = (img_width_bytes + 1) * y; + if (s->img_x == x && s->img_y == y) { + if (raw_len != img_len) return stbi__err("not enough pixels","Corrupt PNG"); + } else { // interlaced: + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + } + + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *prior; + int filter = *raw++; + + if (filter > 4) + return stbi__err("invalid filter","Corrupt PNG"); + + if (depth < 8) { + STBI_ASSERT(img_width_bytes <= x); + cur += x*out_n - img_width_bytes; // store output to the rightmost img_len bytes, so we can decode in place + filter_bytes = 1; + width = img_width_bytes; + } + prior = cur - stride; // bugfix: need to compute this after 'cur +=' computation above + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // handle first byte explicitly + for (k=0; k < filter_bytes; ++k) { + switch (filter) { + case STBI__F_none : cur[k] = raw[k]; break; + case STBI__F_sub : cur[k] = raw[k]; break; + case STBI__F_up : cur[k] = STBI__BYTECAST(raw[k] + prior[k]); break; + case STBI__F_avg : cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); break; + case STBI__F_paeth : cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(0,prior[k],0)); break; + case STBI__F_avg_first : cur[k] = raw[k]; break; + case STBI__F_paeth_first: cur[k] = raw[k]; break; + } + } + + if (depth == 8) { + if (img_n != out_n) + cur[img_n] = 255; // first pixel + raw += img_n; + cur += out_n; + prior += out_n; + } else if (depth == 16) { + if (img_n != out_n) { + cur[filter_bytes] = 255; // first pixel top byte + cur[filter_bytes+1] = 255; // first pixel bottom byte + } + raw += filter_bytes; + cur += output_bytes; + prior += output_bytes; + } else { + raw += 1; + cur += 1; + prior += 1; + } + + // this is a little gross, so that we don't switch per-pixel or per-component + if (depth < 8 || img_n == out_n) { + int nk = (width - 1)*filter_bytes; + #define STBI__CASE(f) \ + case f: \ + for (k=0; k < nk; ++k) + switch (filter) { + // "none" filter turns into a memcpy here; make that explicit. + case STBI__F_none: memcpy(cur, raw, nk); break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],prior[k],prior[k-filter_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes],0,0)); } break; + } + #undef STBI__CASE + raw += nk; + } else { + STBI_ASSERT(img_n+1 == out_n); + #define STBI__CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[filter_bytes]=255,raw+=filter_bytes,cur+=output_bytes,prior+=output_bytes) \ + for (k=0; k < filter_bytes; ++k) + switch (filter) { + STBI__CASE(STBI__F_none) { cur[k] = raw[k]; } break; + STBI__CASE(STBI__F_sub) { cur[k] = STBI__BYTECAST(raw[k] + cur[k- output_bytes]); } break; + STBI__CASE(STBI__F_up) { cur[k] = STBI__BYTECAST(raw[k] + prior[k]); } break; + STBI__CASE(STBI__F_avg) { cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k- output_bytes])>>1)); } break; + STBI__CASE(STBI__F_paeth) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],prior[k],prior[k- output_bytes])); } break; + STBI__CASE(STBI__F_avg_first) { cur[k] = STBI__BYTECAST(raw[k] + (cur[k- output_bytes] >> 1)); } break; + STBI__CASE(STBI__F_paeth_first) { cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k- output_bytes],0,0)); } break; + } + #undef STBI__CASE + + // the loop above sets the high byte of the pixels' alpha, but for + // 16 bit png files we also need the low byte set. we'll do that here. + if (depth == 16) { + cur = a->out + stride*j; // start at the beginning of the row again + for (i=0; i < x; ++i,cur+=output_bytes) { + cur[filter_bytes+1] = 255; + } + } + } + } + + // we make a separate pass to expand bits to pixels; for performance, + // this could run two scanlines behind the above code, so it won't + // intefere with filtering but will still be in the cache. + if (depth < 8) { + for (j=0; j < y; ++j) { + stbi_uc *cur = a->out + stride*j; + stbi_uc *in = a->out + stride*j + x*out_n - img_width_bytes; + // unpack 1/2/4-bit into a 8-bit buffer. allows us to keep the common 8-bit path optimal at minimal cost for 1/2/4-bit + // png guarante byte alignment, if width is not multiple of 8/4/2 we'll decode dummy trailing data that will be skipped in the later loop + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + + // note that the final byte might overshoot and write more data than desired. + // we can allocate enough data that this never writes out of memory, but it + // could also overwrite the next scanline. can it overwrite non-empty data + // on the next scanline? yes, consider 1-pixel-wide scanlines with 1-bit-per-pixel. + // so we need to explicitly clamp the final ones + + if (depth == 4) { + for (k=x*img_n; k >= 2; k-=2, ++in) { + *cur++ = scale * ((*in >> 4) ); + *cur++ = scale * ((*in ) & 0x0f); + } + if (k > 0) *cur++ = scale * ((*in >> 4) ); + } else if (depth == 2) { + for (k=x*img_n; k >= 4; k-=4, ++in) { + *cur++ = scale * ((*in >> 6) ); + *cur++ = scale * ((*in >> 4) & 0x03); + *cur++ = scale * ((*in >> 2) & 0x03); + *cur++ = scale * ((*in ) & 0x03); + } + if (k > 0) *cur++ = scale * ((*in >> 6) ); + if (k > 1) *cur++ = scale * ((*in >> 4) & 0x03); + if (k > 2) *cur++ = scale * ((*in >> 2) & 0x03); + } else if (depth == 1) { + for (k=x*img_n; k >= 8; k-=8, ++in) { + *cur++ = scale * ((*in >> 7) ); + *cur++ = scale * ((*in >> 6) & 0x01); + *cur++ = scale * ((*in >> 5) & 0x01); + *cur++ = scale * ((*in >> 4) & 0x01); + *cur++ = scale * ((*in >> 3) & 0x01); + *cur++ = scale * ((*in >> 2) & 0x01); + *cur++ = scale * ((*in >> 1) & 0x01); + *cur++ = scale * ((*in ) & 0x01); + } + if (k > 0) *cur++ = scale * ((*in >> 7) ); + if (k > 1) *cur++ = scale * ((*in >> 6) & 0x01); + if (k > 2) *cur++ = scale * ((*in >> 5) & 0x01); + if (k > 3) *cur++ = scale * ((*in >> 4) & 0x01); + if (k > 4) *cur++ = scale * ((*in >> 3) & 0x01); + if (k > 5) *cur++ = scale * ((*in >> 2) & 0x01); + if (k > 6) *cur++ = scale * ((*in >> 1) & 0x01); + } + if (img_n != out_n) { + int q; + // insert alpha = 255 + cur = a->out + stride*j; + if (img_n == 1) { + for (q=x-1; q >= 0; --q) { + cur[q*2+1] = 255; + cur[q*2+0] = cur[q]; + } + } else { + STBI_ASSERT(img_n == 3); + for (q=x-1; q >= 0; --q) { + cur[q*4+3] = 255; + cur[q*4+2] = cur[q*3+2]; + cur[q*4+1] = cur[q*3+1]; + cur[q*4+0] = cur[q*3+0]; + } + } + } + } + } else if (depth == 16) { + // force the image data from big-endian to platform-native. + // this is done in a separate pass due to the decoding relying + // on the data being untouched, but could probably be done + // per-line during decode if care is taken. + stbi_uc *cur = a->out; + stbi__uint16 *cur16 = (stbi__uint16*)cur; + + for(i=0; i < x*y*out_n; ++i,cur16++,cur+=2) { + *cur16 = (cur[0] << 8) | cur[1]; + } + } + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load = 0; +static int stbi__de_iphone_flag = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + p[0] = p[2] * 255 / a; + p[1] = p[1] * 255 / a; + p[2] = t * 255 / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); if (s->img_x > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); + s->img_y = stbi__get32be(s); if (s->img_y > (1 << 24)) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + if (scan == STBI__SCAN_header) return 1; + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + if (z->depth == 16) { + for (k = 0; k < s->img_n; ++k) tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n; ++k) tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { s->img_n = pal_img_n; return 1; } + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } + STBI_FREE(z->expanded); z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth < 8) + ri->bits_per_channel = 8; + else + ri->bits_per_channel = p->depth; + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) n += 16, z >>= 16; + if (z >= 0x00100) n += 8, z >>= 8; + if (z >= 0x00010) n += 4, z >>= 4; + if (z >= 0x00004) n += 2, z >>= 2; + if (z >= 0x00002) n += 1, z >>= 1; + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +static int stbi__shiftsigned(int v, int shift, int bits) +{ + int result; + int z=0; + + if (shift < 0) v <<= -shift; + else v >>= shift; + result = v; + + z = bits; + while (z < 8) { + result += v >> z; + z += bits; + } + return result; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; +} stbi__bmp_data; + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (info->bpp == 1) return stbi__errpuc("monochrome", "BMP type not supported: 1-bit"); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - 14 - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - 14 - info.hsz) >> 2; + } + + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - 14 - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - 14 - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i], p1[i] = p2[i], p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if(is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // else: fall-through + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fall-through + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out, *old_out; // output buffer (always 4 components) + int flags, bgindex, ratio, transparent, eflags, delay; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[4096]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + p = &g->out[g->cur_x + g->cur_y]; + c = &g->color_table[g->codes[code].suffix * 4]; + + if (c[3] >= 128) { + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) return stbi__errpuc("no clear code", "Corrupt GIF"); + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 4096) return stbi__errpuc("too many codes", "Corrupt GIF"); + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +static void stbi__fill_gif_background(stbi__gif *g, int x0, int y0, int x1, int y1) +{ + int x, y; + stbi_uc *c = g->pal[g->bgindex]; + for (y = y0; y < y1; y += 4 * g->w) { + for (x = x0; x < x1; x += 4) { + stbi_uc *p = &g->out[y + x]; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = 0; + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp) +{ + int i; + stbi_uc *prev_out = 0; + + if (g->out == 0 && !stbi__gif_header(s, g, comp,0)) + return 0; // stbi__g_failure_reason set by stbi__gif_header + + if (!stbi__mad3sizes_valid(g->w, g->h, 4, 0)) + return stbi__errpuc("too large", "GIF too large"); + + prev_out = g->out; + g->out = (stbi_uc *) stbi__malloc_mad3(4, g->w, g->h, 0); + if (g->out == 0) return stbi__errpuc("outofmem", "Out of memory"); + + switch ((g->eflags & 0x1C) >> 2) { + case 0: // unspecified (also always used on 1st frame) + stbi__fill_gif_background(g, 0, 0, 4 * g->w, 4 * g->w * g->h); + break; + case 1: // do not dispose + if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h); + g->old_out = prev_out; + break; + case 2: // dispose to background + if (prev_out) memcpy(g->out, prev_out, 4 * g->w * g->h); + stbi__fill_gif_background(g, g->start_x, g->start_y, g->max_x, g->max_y); + break; + case 3: // dispose to previous + if (g->old_out) { + for (i = g->start_y; i < g->max_y; i += 4 * g->w) + memcpy(&g->out[i + g->start_x], &g->old_out[i + g->start_x], g->max_x - g->start_x); + } + break; + } + + for (;;) { + switch (stbi__get8(s)) { + case 0x2C: /* Image Descriptor */ + { + int prev_trans = -1; + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + if (g->transparent >= 0 && (g->eflags & 0x01)) { + prev_trans = g->pal[g->transparent][3]; + g->pal[g->transparent][3] = 0; + } + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (o == NULL) return NULL; + + if (prev_trans != -1) + g->pal[g->transparent][3] = (stbi_uc) prev_trans; + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + if (stbi__get8(s) == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = stbi__get16le(s); + g->transparent = stbi__get8(s); + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) + stbi__skip(s, len); + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } + + STBI_NOTUSED(req_comp); +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + memset(g, 0, sizeof(*g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, g, comp, req_comp); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g->w; + *y = g->h; + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g->w, g->h); + } + else if (g->out) + STBI_FREE(g->out); + STBI_FREE(g); + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if (count > nleft) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + stbi__rewind( s ); + if (p == NULL) + return 0; + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) *comp = info.ma ? 4 : 3; + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + if (stbi__get16be(s) != 8) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) +// Does not support 16-bit-per-channel + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n)) + return 0; + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + stbi__getn(s, out, s->img_n * s->img_x * s->img_y); + + if (req_comp && req_comp != s->img_n) { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + + if (maxv > 255) + return stbi__err("max value > 255", "PPM image not 8-bit"); + else + return 1; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +*/ diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt new file mode 100644 index 0000000000..2d092e11dc --- /dev/null +++ b/source/CMakeLists.txt @@ -0,0 +1,332 @@ +cmake_minimum_required(VERSION 3.1) +project(xlnt VERSION 1.5.0) + +set(CMAKE_CXX_STANDARD ${XLNT_CXX_LANG}) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CXX_EXTENSIONS OFF) + +# Project metadata +set(PROJECT_VENDOR "Thomas Fussell") +set(PROJECT_CONTACT "thomas.fussell@gmail.com") +set(PROJECT_URL "https://github.com/tfussell/xlnt") +set(PROJECT_DESCRIPTION "cross-platform user-friendly xlsx library for C++11") + +# Commonly used project directories +set(XLNT_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/..) +set(XLNT_INCLUDE_DIR ${XLNT_ROOT_DIR}/include) +set(XLNT_SOURCE_DIR ${XLNT_ROOT_DIR}/source) +set(THIRD_PARTY_DIR ${XLNT_ROOT_DIR}/third-party) + +# Include libstudxml library +add_subdirectory(${THIRD_PARTY_DIR}/libstudxml.build + ${CMAKE_CURRENT_BINARY_DIR}/third-party/libstudxml) + +if(COVERAGE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") +endif() + +# Non-target-specific compiler settings +if(MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") # level 4 warnings + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP") # multi-processor compilation +elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") # all warnings + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra") # extra warnings + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas") # ignore MSVC and Clang pragmas + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-maybe-uninitialized") # GCC diagnostic with lots of false positives +elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weverything") # all warnings + # blacklist warnings that are not relevant + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat") # ignore warnings about C++98 compatibility + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-c++98-compat-pedantic") # ignore pedantic warnings about C++98 compatibility + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-padded") # ignore padding warnings + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-documentation-unknown-command") # ignore unknown commands in Javadoc-style comments + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas") # ignore Windows and GCC pragmas + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-warning-option") # ignore Windows and GCC pragmas + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-newline-eof") # no longer an issue with post-c++11 standards which mandate include add a newline if neccesary + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-covered-switch-default") # default is often added to switches for completeness or to cover future alternatives + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-exit-time-destructors") # this is just a warning to notify that the destructor will run during exit + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces") # Wmissing-field-initializers has less false positives +endif() + +if(STATIC_CRT) + include(${XLNT_ROOT_DIR}/cmake/ucm.cmake) + ucm_set_runtime(STATIC) +endif() + +if(APPLE) + # Prevent a warning about deployment target not being set by setting it to current OSX version + execute_process(COMMAND "sw_vers -productVersion | awk -F'.' '{print $1\".\"$2}'" + OUTPUT_VARIABLE OSX_VERSION) + set(CMAKE_OSX_DEPLOYMENT_TARGET ${OSX_VERSION}) +endif() + +file(GLOB ROOT_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/*.hpp) +file(GLOB CELL_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/cell/*.hpp) +file(GLOB CELL_SOURCES ${XLNT_SOURCE_DIR}/cell/*.cpp) +file(GLOB DRAWING_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/drawing/*.hpp) +file(GLOB DRAWING_SOURCES ${XLNT_SOURCE_DIR}/drawing/*.cpp) +file(GLOB CHARTS_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/charts/*.hpp) +file(GLOB CHARTS_SOURCES ${XLNT_SOURCE_DIR}/charts/*.cpp) +file(GLOB CHARTSHEET_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/chartsheet/*.hpp) +file(GLOB CHARTSHEET_SOURCES ${XLNT_SOURCE_DIR}/chartsheet/*.cpp) +file(GLOB DRAWING_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/drawing/*.hpp) +file(GLOB DRAWING_SOURCES ${XLNT_SOURCE_DIR}/drawing/*.cpp) +file(GLOB FORMULA_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/formula/*.hpp) +file(GLOB FORMULA_SOURCES ${XLNT_SOURCE_DIR}/formula/*.cpp) +file(GLOB PACKAGING_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/packaging/*.hpp) +file(GLOB PACKAGING_SOURCES ${XLNT_SOURCE_DIR}/packaging/*.cpp) +file(GLOB STYLES_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/styles/*.hpp) +file(GLOB STYLES_SOURCES ${XLNT_SOURCE_DIR}/styles/*.cpp) +file(GLOB UTILS_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/utils/*.hpp) +file(GLOB UTILS_SOURCES ${XLNT_SOURCE_DIR}/utils/*.cpp) +file(GLOB WORKBOOK_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/workbook/*.hpp) +file(GLOB WORKBOOK_SOURCES ${XLNT_SOURCE_DIR}/workbook/*.cpp) +file(GLOB WORKSHEET_HEADERS ${XLNT_INCLUDE_DIR}/xlnt/worksheet/*.hpp) +file(GLOB WORKSHEET_SOURCES ${XLNT_SOURCE_DIR}/worksheet/*.cpp) +file(GLOB MINIZ_HEADERS ${THIRD_PARTY_DIR}/miniz/*.h) +file(GLOB MINIZ_SOURCES ${THIRD_PARTY_DIR}/miniz/*.c) + +file(GLOB DETAIL_ROOT_HEADERS ${XLNT_SOURCE_DIR}/detail/*.hpp) +file(GLOB DETAIL_ROOT_SOURCES ${XLNT_SOURCE_DIR}/detail/*.cpp) +file(GLOB DETAIL_CRYPTOGRAPHY_HEADERS ${XLNT_SOURCE_DIR}/detail/cryptography/*.hpp) +file(GLOB DETAIL_CRYPTOGRAPHY_SOURCES ${XLNT_SOURCE_DIR}/detail/cryptography/*.c*) +file(GLOB DETAIL_EXTERNAL_HEADERS ${XLNT_SOURCE_DIR}/detail/external/*.hpp) +file(GLOB DETAIL_HEADER_FOOTER_HEADERS ${XLNT_SOURCE_DIR}/detail/header_footer/*.hpp) +file(GLOB DETAIL_HEADER_FOOTER_SOURCES ${XLNT_SOURCE_DIR}/detail/header_footer/*.cpp) +file(GLOB DETAIL_IMPLEMENTATIONS_HEADERS ${XLNT_SOURCE_DIR}/detail/implementations/*.hpp) +file(GLOB DETAIL_IMPLEMENTATIONS_SOURCES ${XLNT_SOURCE_DIR}/detail/implementations/*.cpp) +file(GLOB DETAIL_NUMBER_FORMAT_HEADERS ${XLNT_SOURCE_DIR}/detail/number_format/*.hpp) +file(GLOB DETAIL_NUMBER_FORMAT_SOURCES ${XLNT_SOURCE_DIR}/detail/number_format/*.cpp) +file(GLOB DETAIL_SERIALIZATION_HEADERS ${XLNT_SOURCE_DIR}/detail/serialization/*.hpp) +file(GLOB DETAIL_SERIALIZATION_SOURCES ${XLNT_SOURCE_DIR}/detail/serialization/*.cpp) + + +set(DETAIL_HEADERS ${DETAIL_ROOT_HEADERS} ${DETAIL_CRYPTOGRAPHY_HEADERS} + ${DETAIL_EXTERNAL_HEADERS} ${DETAIL_HEADER_FOOTER_HEADERS} + ${DETAIL_IMPLEMENTATIONS_HEADERS} ${DETAIL_NUMBER_FORMAT_HEADERS} + ${DETAIL_SERIALIZATION_HEADERS}) +set(DETAIL_SOURCES ${DETAIL_ROOT_SOURCES} ${DETAIL_CRYPTOGRAPHY_SOURCES} + ${DETAIL_EXTERNAL_SOURCES} ${DETAIL_HEADER_FOOTER_SOURCES} + ${DETAIL_IMPLEMENTATIONS_SOURCES} ${DETAIL_NUMBER_FORMAT_SOURCES} + ${DETAIL_SERIALIZATION_SOURCES}) + +set(XLNT_HEADERS ${ROOT_HEADERS} ${CELL_HEADERS} ${CHARTS_HEADERS} + ${CHARTSHEET_HEADERS} ${DRAWING_HEADERS} ${FORMULA_HEADERS} + ${PACKAGING_HEADERS} ${STYLES_HEADERS} ${UTILS_HEADERS} + ${WORKBOOK_HEADERS} ${WORKSHEET_HEADERS} ${DETAIL_HEADERS} ${DETAIL_CRYPTO_HEADERS} + ${DRAWING_HEADERS} ${MINIZ_HEADERS}) +set(XLNT_SOURCES ${CELL_SOURCES} ${CHARTS_SOURCES} ${CHARTSHEET_SOURCES} + ${DRAWING_SOURCES} ${FORMULA_SOURCES} ${PACKAGING_SOURCES} + ${STYLES_SOURCES} ${UTILS_SOURCES} ${WORKBOOK_SOURCES} + ${WORKSHEET_SOURCES} ${DETAIL_SOURCES} ${DETAIL_CRYPTO_SOURCES} + ${DRAWING_SOURCES} ${MINIZ_SOURCES}) + +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + # Set a default CMAKE_INSTALL_PREFIX if one wasn't specified + + if(MSVC) + # No good place to install on Windows so just install to cmake build directory in /installed + set(DEFAULT_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/installed") + else() + # Install to /usr/local on other platforms + set(DEFAULT_INSTALL_PREFIX "/usr/local") + endif() + + # Apply the variable and save to cache + set(CMAKE_INSTALL_PREFIX ${DEFAULT_INSTALL_PREFIX} + CACHE PATH "default install path" FORCE) +endif() + +# Append "d" to the name of the compiled library +set(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "Set debug library postfix") + +include(GNUInstallDirs) + +set(XLNT_INC_DEST_DIR ${CMAKE_INSTALL_INCLUDEDIR} + CACHE PATH "Default location to install include files") +set(XLNT_LIB_DEST_DIR ${CMAKE_INSTALL_LIBDIR} + CACHE PATH "Default location to install library files") +set(XLNT_BIN_DEST_DIR ${CMAKE_INSTALL_BINDIR} + CACHE PATH "Default location to install runtime files") +set(XLNT_MAN_DEST_DIR ${CMAKE_INSTALL_MANDIR} + CACHE PATH "Default location to install runtime files") +set(XLNT_CMAKE_CFG_DEST_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} + CACHE PATH "Default location to install CMake config files") + +if(NOT STATIC) + # Compile shared library + add_library(xlnt SHARED + ${XLNT_HEADERS} + ${XLNT_SOURCES} + $) + + target_compile_definitions(xlnt PRIVATE XLNT_SHARED=1) + + # Set SO version (for symbolic links like libxlnt.so.1.4 and libxlnt.so.1) + set_target_properties(xlnt + PROPERTIES + VERSION ${PROJECT_VERSION} + SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH} + INSTALL_NAME_DIR "${XLNT_LIB_DEST_DIR}") +else() + # Compile static library + add_library(xlnt STATIC ${XLNT_HEADERS} ${XLNT_SOURCES} $) + target_compile_definitions(xlnt PUBLIC XLNT_STATIC=1) +endif() + +# requires cmake 3.8+ +#target_compile_features(xlnt PUBLIC cxx_std_${XLNT_CXX_LANG}) + +# Includes +target_include_directories(xlnt + PUBLIC + $ + $ + PRIVATE + ${XLNT_SOURCE_DIR} + ${XLNT_SOURCE_DIR}/../third-party/libstudxml + ${XLNT_SOURCE_DIR}/../third-party/miniz + ${XLNT_SOURCE_DIR}/../third-party/utfcpp) + +# Platform- and file-specific settings, MSVC +if(MSVC) + target_compile_definitions(xlnt PRIVATE _CRT_SECURE_NO_WARNINGS=1) + + if(NOT STATIC) + target_compile_definitions(xlnt PRIVATE XLNT_EXPORT=1) + endif() + + set_target_properties(xlnt PROPERTIES + COMPILE_FLAGS "/wd\"4251\" /wd\"4275\" /wd\"4068\"") + set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/detail/serialization/miniz.cpp + PROPERTIES + COMPILE_FLAGS "/wd\"4244\" /wd\"4334\" /wd\"4127\"") + set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/detail/cryptography/aes.cpp + PROPERTIES + COMPILE_FLAGS "/wd\"4996\"") +else() + # Platform- and file-specific settings, Clang + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/detail/serialization/miniz.cpp + PROPERTIES + COMPILE_FLAGS "-Wno-undef") + set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/detail/serialization/zstream.cpp + PROPERTIES + COMPILE_FLAGS "-Wno-undef -Wno-shorten-64-to-32") + endif() + + # Platform- and file-specific settings, GCC + if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") + set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/detail/serialization/miniz.cpp + PROPERTIES + COMPILE_FLAGS "-Wno-strict-aliasing") + endif() +endif() + +# Group files into pseudo-folders in IDEs +source_group(xlnt FILES ${ROOT_HEADERS}) +source_group(cell FILES ${CELL_HEADERS} ${CELL_SOURCES}) +source_group(detail FILES ${DETAIL_ROOT_HEADERS} ${DETAIL_ROOT_SOURCES}) +source_group(detail\\cryptography FILES ${DETAIL_CRYPTOGRAPHY_HEADERS} ${DETAIL_CRYPTOGRAPHY_SOURCES}) +source_group(detail\\external FILES ${DETAIL_EXTERNAL_HEADERS}) +source_group(detail\\header_footer FILES ${DETAIL_HEADER_FOOTER_HEADERS} ${DETAIL_HEADER_FOOTER_SOURCES}) +source_group(detail\\implementations FILES ${DETAIL_IMPLEMENTATIONS_HEADERS} ${DETAIL_IMPLEMENTATIONS_SOURCES}) +source_group(detail\\number_format FILES ${DETAIL_NUMBER_FORMAT_HEADERS} ${DETAIL_NUMBER_FORMAT_SOURCES}) +source_group(detail\\serialization FILES ${DETAIL_SERIALIZATION_HEADERS} ${DETAIL_SERIALIZATION_SOURCES}) +source_group(drawing FILES ${DRAWING_HEADERS} ${DRAWING_SOURCES}) +source_group(packaging FILES ${PACKAGING_HEADERS} ${PACKAGING_SOURCES}) +source_group(styles FILES ${STYLES_HEADERS} ${STYLES_SOURCES}) +source_group(utils FILES ${UTILS_HEADERS} ${UTILS_SOURCES}) +source_group(workbook FILES ${WORKBOOK_HEADERS} ${WORKBOOK_SOURCES}) +source_group(worksheet FILES ${WORKSHEET_HEADERS} ${WORKSHEET_SOURCES}) +source_group(third-party\\miniz FILES ${MINIZ_HEADERS} ${MINIZ_SOURCES}) + +# Install library +install(TARGETS xlnt EXPORT XlntTargets + LIBRARY DESTINATION ${XLNT_LIB_DEST_DIR} + ARCHIVE DESTINATION ${XLNT_LIB_DEST_DIR} + RUNTIME DESTINATION ${XLNT_BIN_DEST_DIR}) + +install(EXPORT XlntTargets + FILE XlntTargets.cmake + NAMESPACE xlnt:: + DESTINATION ${XLNT_CMAKE_CFG_DEST_DIR}) + +include(CMakePackageConfigHelpers) + +set(XLNT_INCLUDE_INSTALL_DIR ${XLNT_INC_DEST_DIR}) +if(CMAKE_INSTALL_PREFIX) + set(XLNT_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/${XLNT_INCLUDE_INSTALL_DIR}) +endif() + +#See https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html +configure_package_config_file(../cmake/XlntConfig.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/XlntConfig.cmake + INSTALL_DESTINATION ${XLNT_CMAKE_CFG_DEST_DIR} + PATH_VARS XLNT_INCLUDE_DIR) + +write_basic_package_version_file(XlntConfigVersion.cmake + COMPATIBILITY ExactVersion) + +install(FILES + ${CMAKE_CURRENT_BINARY_DIR}/XlntConfig.cmake + ${CMAKE_CURRENT_BINARY_DIR}/XlntConfigVersion.cmake + DESTINATION ${XLNT_CMAKE_CFG_DEST_DIR}) + +# Install include directory +install(DIRECTORY ${XLNT_INCLUDE_DIR}/xlnt + DESTINATION ${XLNT_INC_DEST_DIR} + PATTERN ".DS_Store" EXCLUDE) + +# Install LICENSE.md +install(FILES ${XLNT_ROOT_DIR}/docs/xlnt.3 +DESTINATION ${XLNT_MAN_DEST_DIR}/man3) + +if(NOT TARGET uninstall) + # Configure uninstall + configure_file("${XLNT_ROOT_DIR}/cmake/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE @ONLY) + + # Add uninstall target + add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) +endif() + +if(NOT MSVC) + # Set pkg-config variables + set(PKG_CONFIG_LIBDIR ${XLNT_LIB_DEST_DIR}) + set(PKG_CONFIG_INCLUDEDIR ${XLNT_INC_DEST_DIR}) + set(PKG_CONFIG_LIBS "-L\${libdir} -lxlnt") + set(PKG_CONFIG_CFLAGS "-I\${includedir}") + + # Replace variables in pkg-config template + configure_file("${XLNT_ROOT_DIR}/cmake/pkg-config.pc.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/xlnt.pc") + + # pkg-config install + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/xlnt.pc" + DESTINATION ${XLNT_LIB_DEST_DIR}/pkgconfig) +endif() + +if(RELEASE) + set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR}) + set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR}) + set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH}) + set(CPACK_GENERATOR "TGZ") + set(CPACK_PACKAGE_NAME "xlnt") + set(CPACK_SUFFIX "${CMAKE_SYSTEM_NAME}") + if ("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "Win32") + string(CONCAT CPACK_SUFFIX ${CPACK_SUFFIX} "-x86") + else() + string(CONCAT CPACK_SUFFIX ${CPACK_SUFFIX} "-x64") + endif() + if(STATIC) + string(CONCAT CPACK_SUFFIX ${CPACK_SUFFIX} "-static") + endif() + string(TOLOWER "${CPACK_SUFFIX}" CPACK_SUFFIX) + set(CPACK_SYSTEM_NAME "${CPACK_SUFFIX}") + include(CPack) +endif() diff --git a/source/cell/cell.cpp b/source/cell/cell.cpp new file mode 100644 index 0000000000..f3d69a0879 --- /dev/null +++ b/source/cell/cell.cpp @@ -0,0 +1,1023 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + +std::pair cast_numeric(const std::string &s) +{ + xlnt::detail::number_serialiser ser; + ptrdiff_t len_convert; + double result = ser.deserialise(s, &len_convert); + return (len_convert != static_cast(s.size())) + ? std::make_pair(false, 0.0) + : std::make_pair(true, result); +} + +std::pair cast_percentage(const std::string &s) +{ + if (s.back() == '%') + { + auto number = cast_numeric(s.substr(0, s.size() - 1)); + + if (number.first) + { + return {true, number.second / 100}; + } + } + + return {false, 0.0}; +} + +std::pair cast_time(const std::string &s) +{ + xlnt::time result; + + std::vector time_components; + std::size_t prev = 0; + auto colon_index = s.find(':'); + + while (colon_index != std::string::npos) + { + time_components.push_back(s.substr(prev, colon_index - prev)); + prev = colon_index + 1; + colon_index = s.find(':', colon_index + 1); + } + + time_components.push_back(s.substr(prev, colon_index - prev)); + + if (time_components.size() < 2 || time_components.size() > 3) + { + return {false, result}; + } + + std::vector numeric_components; + xlnt::detail::number_serialiser ser; + for (auto component : time_components) + { + if (component.empty() || (component.substr(0, component.find('.')).size() > 2)) + { + return {false, result}; + } + + for (auto d : component) + { + if (!(d >= '0' && d <= '9') && d != '.') + { + return {false, result}; + } + } + auto numeric = ser.deserialise(component); + + numeric_components.push_back(numeric); + } + + result.hour = static_cast(numeric_components[0]); + result.minute = static_cast(numeric_components[1]); + + if (std::fabs(static_cast(result.minute) - numeric_components[1]) > std::numeric_limits::epsilon()) + { + result.minute = result.hour; + result.hour = 0; + result.second = static_cast(numeric_components[1]); + result.microsecond = static_cast((numeric_components[1] - result.second) * 1E6); + } + else if (numeric_components.size() > 2) + { + result.second = static_cast(numeric_components[2]); + result.microsecond = static_cast((numeric_components[2] - result.second) * 1E6); + } + + return {true, result}; +} + +} // namespace + +namespace xlnt { + +const std::unordered_map &cell::error_codes() +{ + static const auto codes = std::unordered_map{ + {"#NULL!", 0}, + {"#DIV/0!", 1}, + {"#VALUE!", 2}, + {"#REF!", 3}, + {"#NAME?", 4}, + {"#NUM!", 5}, + {"#N/A!", 6}}; + + return codes; +} + +std::string cell::check_string(const std::string &to_check) +{ + // so we can modify it + std::string s = to_check; + + if (s.size() == 0) + { + return s; + } + else if (s.size() > 32767) + { + s = s.substr(0, 32767); // max string length in Excel + } + + for (char c : s) + { + if (c >= 0 && (c <= 8 || c == 11 || c == 12 || (c >= 14 && c <= 31))) + { + throw illegal_character(c); + } + } + + return s; +} + +cell::cell(detail::cell_impl *d) + : d_(d) +{ +} + +bool cell::garbage_collectible() const +{ + return d_->is_garbage_collectible(); +} + +void cell::value(std::nullptr_t) +{ + clear_value(); +} + +void cell::value(bool boolean_value) +{ + d_->type_ = type::boolean; + d_->value_numeric_ = boolean_value ? 1.0 : 0.0; +} + +void cell::value(int int_value) +{ + d_->value_numeric_ = static_cast(int_value); + d_->type_ = type::number; +} + +void cell::value(unsigned int int_value) +{ + d_->value_numeric_ = static_cast(int_value); + d_->type_ = type::number; +} + +void cell::value(long long int int_value) +{ + d_->value_numeric_ = static_cast(int_value); + d_->type_ = type::number; +} + +void cell::value(unsigned long long int int_value) +{ + d_->value_numeric_ = static_cast(int_value); + d_->type_ = type::number; +} + +void cell::value(float float_value) +{ + d_->value_numeric_ = static_cast(float_value); + d_->type_ = type::number; +} + +void cell::value(double float_value) +{ + d_->value_numeric_ = static_cast(float_value); + d_->type_ = type::number; +} + +void cell::value(const std::string &s) +{ + value(rich_text(check_string(s))); +} + +void cell::value(const rich_text &text) +{ + check_string(text.plain_text()); + + d_->type_ = type::shared_string; + d_->value_numeric_ = static_cast(workbook().add_shared_string(text)); +} + +void cell::value(const char *c) +{ + value(std::string(c)); +} + +void cell::value(const cell c) +{ + d_->type_ = c.d_->type_; + d_->value_numeric_ = c.d_->value_numeric_; + d_->value_text_ = c.d_->value_text_; + d_->hyperlink_ = c.d_->hyperlink_; + d_->formula_ = c.d_->formula_; + d_->format_ = c.d_->format_; +} + +void cell::value(const date &d) +{ + d_->type_ = type::number; + d_->value_numeric_ = d.to_number(base_date()); + number_format(number_format::date_yyyymmdd2()); +} + +void cell::value(const datetime &d) +{ + d_->type_ = type::number; + d_->value_numeric_ = d.to_number(base_date()); + number_format(number_format::date_datetime()); +} + +void cell::value(const time &t) +{ + d_->type_ = type::number; + d_->value_numeric_ = t.to_number(); + number_format(number_format::date_time6()); +} + +void cell::value(const timedelta &t) +{ + d_->type_ = type::number; + d_->value_numeric_ = t.to_number(); + number_format(xlnt::number_format("[hh]:mm:ss")); +} + +row_t cell::row() const +{ + return d_->row_; +} + +column_t cell::column() const +{ + return d_->column_; +} + +column_t::index_t cell::column_index() const +{ + return d_->column_.index; +} + +void cell::merged(bool merged) +{ + d_->is_merged_ = merged; +} + +bool cell::is_merged() const +{ + return d_->is_merged_; +} + +bool cell::phonetics_visible() const +{ + return d_->phonetics_visible_; +} + +void cell::show_phonetics(bool phonetics) +{ + d_->phonetics_visible_ = phonetics; +} + +bool cell::is_date() const +{ + return data_type() == type::number + && has_format() + && number_format().is_date_format(); +} + +cell_reference cell::reference() const +{ + return {d_->column_, d_->row_}; +} + +bool cell::operator==(const cell &comparand) const +{ + return d_ == comparand.d_; +} + +bool cell::operator!=(const cell &comparand) const +{ + return d_ != comparand.d_; +} + +cell &cell::operator=(const cell &rhs) = default; + +hyperlink cell::hyperlink() const +{ + return xlnt::hyperlink(&d_->hyperlink_.get()); +} + +void cell::hyperlink(const std::string &url, const std::string &display) +{ + if (url.empty()) + { + throw invalid_parameter(); + } + + auto ws = worksheet(); + auto &manifest = ws.workbook().manifest(); + + d_->hyperlink_ = detail::hyperlink_impl(); + + // check for existing relationships + auto relationships = manifest.relationships(ws.path(), relationship_type::hyperlink); + auto relation = std::find_if(relationships.cbegin(), relationships.cend(), + [&url](xlnt::relationship rel) { return rel.target().path().string() == url; }); + if (relation != relationships.end()) + { + d_->hyperlink_.get().relationship = *relation; + } + else + { // register a new relationship + auto rel_id = manifest.register_relationship( + uri(ws.path().string()), + relationship_type::hyperlink, + uri(url), + target_mode::external); + // TODO: make manifest::register_relationship return the created relationship instead of rel id + d_->hyperlink_.get().relationship = manifest.relationship(ws.path(), rel_id); + } + // if a value is already present, the display string is ignored + if (has_value()) + { + d_->hyperlink_.get().display.set(to_string()); + } + else + { + d_->hyperlink_.get().display.set(display.empty() ? url : display); + value(hyperlink().display()); + } +} + +void cell::hyperlink(xlnt::cell target, const std::string &display) +{ + // TODO: should this computed value be a method on a cell? + const auto cell_address = target.worksheet().title() + "!" + target.reference().to_string(); + + d_->hyperlink_ = detail::hyperlink_impl(); + d_->hyperlink_.get().relationship = xlnt::relationship("", relationship_type::hyperlink, + uri(""), uri(cell_address), target_mode::internal); + // if a value is already present, the display string is ignored + if (has_value()) + { + d_->hyperlink_.get().display.set(to_string()); + } + else + { + d_->hyperlink_.get().display.set(display.empty() ? cell_address : display); + value(hyperlink().display()); + } +} + +void cell::hyperlink(xlnt::range target, const std::string &display) +{ + // TODO: should this computed value be a method on a cell? + const auto range_address = target.target_worksheet().title() + "!" + target.reference().to_string(); + + d_->hyperlink_ = detail::hyperlink_impl(); + d_->hyperlink_.get().relationship = xlnt::relationship("", relationship_type::hyperlink, + uri(""), uri(range_address), target_mode::internal); + + // if a value is already present, the display string is ignored + if (has_value()) + { + d_->hyperlink_.get().display.set(to_string()); + } + else + { + d_->hyperlink_.get().display.set(display.empty() ? range_address : display); + value(hyperlink().display()); + } +} + +void cell::formula(const std::string &formula) +{ + if (formula.empty()) + { + return clear_formula(); + } + + if (formula[0] == '=') + { + d_->formula_ = formula.substr(1); + } + else + { + d_->formula_ = formula; + } + + worksheet().register_calc_chain_in_manifest(); +} + +bool cell::has_formula() const +{ + return d_->formula_.is_set(); +} + +std::string cell::formula() const +{ + return d_->formula_.get(); +} + +void cell::clear_formula() +{ + if (has_formula()) + { + d_->formula_.clear(); + worksheet().garbage_collect_formulae(); + } +} + +std::string cell::error() const +{ + if (d_->type_ != type::error) + { + throw xlnt::exception("called error() when cell type is not error"); + } + return value(); +} + +void cell::error(const std::string &error) +{ + if (error.length() == 0 || error[0] != '#') + { + throw invalid_data_type(); + } + + d_->value_text_.plain_text(error, false); + d_->type_ = type::error; +} + +cell cell::offset(int column, int row) +{ + return worksheet().cell(reference().make_offset(column, row)); +} + +worksheet cell::worksheet() +{ + return xlnt::worksheet(d_->parent_); +} + +const worksheet cell::worksheet() const +{ + return xlnt::worksheet(d_->parent_); +} + +workbook &cell::workbook() +{ + return worksheet().workbook(); +} + +const workbook &cell::workbook() const +{ + return worksheet().workbook(); +} + +std::pair cell::anchor() const +{ + double left = 0; + + for (column_t column_index = 1; column_index <= d_->column_ - 1; column_index++) + { + left += worksheet().column_width(column_index); + } + + double top = 0; + + for (row_t row_index = 1; row_index <= d_->row_ - 1; row_index++) + { + top += worksheet().row_height(row_index); + } + + return {static_cast(left), static_cast(top)}; +} + +cell::type cell::data_type() const +{ + return d_->type_; +} + +void cell::data_type(type t) +{ + d_->type_ = t; +} + +number_format cell::computed_number_format() const +{ + return xlnt::number_format(); +} + +font cell::computed_font() const +{ + return xlnt::font(); +} + +fill cell::computed_fill() const +{ + return xlnt::fill(); +} + +border cell::computed_border() const +{ + return xlnt::border(); +} + +alignment cell::computed_alignment() const +{ + return xlnt::alignment(); +} + +protection cell::computed_protection() const +{ + return xlnt::protection(); +} + +void cell::clear_value() +{ + d_->value_numeric_ = 0; + d_->value_text_.clear(); + d_->type_ = cell::type::empty; + clear_formula(); +} + +template <> +XLNT_API bool cell::value() const +{ + return d_->value_numeric_ != 0.0; +} + +template <> +XLNT_API int cell::value() const +{ + return static_cast(d_->value_numeric_); +} + +template <> +XLNT_API long long int cell::value() const +{ + return static_cast(d_->value_numeric_); +} + +template <> +XLNT_API unsigned int cell::value() const +{ + return static_cast(d_->value_numeric_); +} + +template <> +XLNT_API unsigned long long cell::value() const +{ + return static_cast(d_->value_numeric_); +} + +template <> +XLNT_API float cell::value() const +{ + return static_cast(d_->value_numeric_); +} + +template <> +XLNT_API double cell::value() const +{ + return static_cast(d_->value_numeric_); +} + +template <> +XLNT_API time cell::value() const +{ + return time::from_number(d_->value_numeric_); +} + +template <> +XLNT_API datetime cell::value() const +{ + return datetime::from_number(d_->value_numeric_, base_date()); +} + +template <> +XLNT_API date cell::value() const +{ + return date::from_number(static_cast(d_->value_numeric_), base_date()); +} + +template <> +XLNT_API timedelta cell::value() const +{ + return timedelta::from_number(d_->value_numeric_); +} + +void cell::alignment(const class alignment &alignment_) +{ + auto new_format = has_format() ? modifiable_format() : workbook().create_format(); + format(new_format.alignment(alignment_, optional(true))); +} + +void cell::border(const class border &border_) +{ + auto new_format = has_format() ? modifiable_format() : workbook().create_format(); + format(new_format.border(border_, optional(true))); +} + +void cell::fill(const class fill &fill_) +{ + auto new_format = has_format() ? modifiable_format() : workbook().create_format(); + format(new_format.fill(fill_, optional(true))); +} + +void cell::font(const class font &font_) +{ + auto new_format = has_format() ? modifiable_format() : workbook().create_format(); + format(new_format.font(font_, optional(true))); +} + +void cell::number_format(const class number_format &number_format_) +{ + auto new_format = has_format() ? modifiable_format() : workbook().create_format(); + format(new_format.number_format(number_format_, optional(true))); +} + +void cell::protection(const class protection &protection_) +{ + auto new_format = has_format() ? modifiable_format() : workbook().create_format(); + format(new_format.protection(protection_, optional(true))); +} + +template <> +XLNT_API std::string cell::value() const +{ + return value().plain_text(); +} + +template <> +XLNT_API rich_text cell::value() const +{ + if (data_type() == cell::type::shared_string) + { + return workbook().shared_strings(static_cast(d_->value_numeric_)); + } + + return d_->value_text_; +} + +bool cell::has_value() const +{ + return d_->type_ != cell::type::empty; +} + +std::string cell::to_string() const +{ + auto nf = computed_number_format(); + + switch (data_type()) + { + case cell::type::empty: + return ""; + case cell::type::date: + case cell::type::number: + return nf.format(value(), base_date()); + case cell::type::inline_string: + case cell::type::shared_string: + case cell::type::formula_string: + case cell::type::error: + return nf.format(value()); + case cell::type::boolean: + return value() == 0.0 ? "FALSE" : "TRUE"; + } + + return ""; +} + +bool cell::has_format() const +{ + return d_->format_.is_set(); +} + +void cell::format(const class format new_format) +{ + if (has_format()) + { + format().d_->references -= format().d_->references > 0 ? 1 : 0; + } + + ++new_format.d_->references; + d_->format_ = new_format.d_; +} + +calendar cell::base_date() const +{ + return workbook().base_date(); +} + +bool operator==(std::nullptr_t, const cell &cell) +{ + return cell.data_type() == cell::type::empty; +} + +bool operator==(const cell &cell, std::nullptr_t) +{ + return nullptr == cell; +} + +XLNT_API std::ostream &operator<<(std::ostream &stream, const xlnt::cell &cell) +{ + return stream << cell.to_string(); +} + +void cell::value(const std::string &value_string, bool infer_type) +{ + value(value_string); + + if (!infer_type || value_string.empty()) + { + return; + } + + if (value_string.front() == '=' && value_string.size() > 1) + { + formula(value_string); + return; + } + + if (value_string.front() == '#' && value_string.size() > 1) + { + error(value_string); + return; + } + + auto percentage = cast_percentage(value_string); + + if (percentage.first) + { + d_->value_numeric_ = percentage.second; + d_->type_ = cell::type::number; + number_format(xlnt::number_format::percentage()); + } + else + { + auto time = cast_time(value_string); + + if (time.first) + { + d_->type_ = cell::type::number; + number_format(number_format::date_time6()); + d_->value_numeric_ = time.second.to_number(); + } + else + { + auto numeric = cast_numeric(value_string); + + if (numeric.first) + { + d_->value_numeric_ = numeric.second; + d_->type_ = cell::type::number; + } + } + } +} + +void cell::clear_format() +{ + if (d_->format_.is_set()) + { + format().d_->references -= format().d_->references > 0 ? 1 : 0; + d_->format_.clear(); + } +} + +void cell::clear_style() +{ + if (has_format()) + { + modifiable_format().clear_style(); + } +} + +void cell::style(const class style &new_style) +{ + auto new_format = has_format() ? format() : workbook().create_format(); + + new_format.border(new_style.border()); + new_format.fill(new_style.fill()); + new_format.font(new_style.font()); + new_format.number_format(new_style.number_format()); + + format(new_format.style(new_style)); +} + +void cell::style(const std::string &style_name) +{ + style(workbook().style(style_name)); +} + +style cell::style() +{ + if (!has_format() || !format().has_style()) + { + throw invalid_attribute(); + } + + auto f = format(); + + return f.style(); +} + +const style cell::style() const +{ + if (!has_format() || !format().has_style()) + { + throw invalid_attribute(); + } + + return format().style(); +} + +bool cell::has_style() const +{ + return has_format() && format().has_style(); +} + +format cell::modifiable_format() +{ + if (!d_->format_.is_set()) + { + throw invalid_attribute(); + } + + return xlnt::format(d_->format_.get()); +} + +const format cell::format() const +{ + if (!d_->format_.is_set()) + { + throw invalid_attribute(); + } + + return xlnt::format(d_->format_.get()); +} + +alignment cell::alignment() const +{ + return format().alignment(); +} + +border cell::border() const +{ + return format().border(); +} + +fill cell::fill() const +{ + return format().fill(); +} + +font cell::font() const +{ + return format().font(); +} + +number_format cell::number_format() const +{ + return format().number_format(); +} + +protection cell::protection() const +{ + return format().protection(); +} + +bool cell::has_hyperlink() const +{ + return d_->hyperlink_.is_set(); +} + +// comment + +bool cell::has_comment() +{ + return d_->comment_.is_set(); +} + +void cell::clear_comment() +{ + if (has_comment()) + { + d_->parent_->comments_.erase(reference().to_string()); + d_->comment_.clear(); + } +} + +class comment cell::comment() +{ + if (!has_comment()) + { + throw xlnt::exception("cell has no comment"); + } + + return *d_->comment_.get(); +} + +void cell::comment(const std::string &text, const std::string &author) +{ + comment(xlnt::comment(text, author)); +} + +void cell::comment(const std::string &text, const class font &comment_font, const std::string &author) +{ + comment(xlnt::comment(xlnt::rich_text(text, comment_font), author)); +} + +void cell::comment(const class comment &new_comment) +{ + if (has_comment()) + { + *d_->comment_.get() = new_comment; + } + else + { + d_->parent_->comments_[reference().to_string()] = new_comment; + d_->comment_.set(&d_->parent_->comments_[reference().to_string()]); + } + + // offset comment 5 pixels down and 5 pixels right of the top right corner of the cell + auto cell_position = anchor(); + cell_position.first += static_cast(width()) + 5; + cell_position.second += 5; + + d_->comment_.get()->position(cell_position.first, cell_position.second); + + worksheet().register_comments_in_manifest(); +} + +double cell::width() const +{ + return worksheet().column_width(column()); +} + +double cell::height() const +{ + return worksheet().row_height(row()); +} + +} // namespace xlnt diff --git a/source/cell/cell_reference.cpp b/source/cell/cell_reference.cpp new file mode 100644 index 0000000000..246e972346 --- /dev/null +++ b/source/cell/cell_reference.cpp @@ -0,0 +1,282 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include + +#include +#include +#include + +#include + +namespace xlnt { + +std::size_t cell_reference_hash::operator()(const cell_reference &k) const +{ + return k.row() * constants::max_column().index + k.column_index(); +} + +cell_reference &cell_reference::make_absolute(bool absolute_column, bool absolute_row) +{ + column_absolute(absolute_column); + row_absolute(absolute_row); + + return *this; +} + +cell_reference::cell_reference() + : cell_reference(1, 1) +{ +} + +cell_reference::cell_reference(const std::string &string) +{ + auto split = split_reference(string, absolute_column_, absolute_row_); + + column(split.first); + row(split.second); +} + +cell_reference::cell_reference(const char *reference_string) + : cell_reference(std::string(reference_string)) +{ +} + +cell_reference::cell_reference(column_t column_index, row_t row) + : column_(column_index), row_(row), absolute_row_(false), absolute_column_(false) +{ + if (row_ == 0 + || column_ == 0 + || !(row_ <= constants::max_row()) + || !(column_ <= constants::max_column())) + { + throw invalid_cell_reference(column_, row_); + } +} + +range_reference cell_reference::operator,(const xlnt::cell_reference &other) const +{ + return range_reference(*this, other); +} + +std::string cell_reference::to_string() const +{ + std::string string_representation; + + if (absolute_column_) + { + string_representation.append("$"); + } + + string_representation.append(column_.column_string()); + + if (absolute_row_) + { + string_representation.append("$"); + } + + string_representation.append(std::to_string(row_)); + + return string_representation; +} + +range_reference cell_reference::to_range() const +{ + return range_reference(column_, row_, column_, row_); +} + +std::pair cell_reference::split_reference(const std::string &reference_string) +{ + bool ignore1, ignore2; + return split_reference(reference_string, ignore1, ignore2); +} + +std::pair cell_reference::split_reference( + const std::string &reference_string, bool &absolute_column, bool &absolute_row) +{ + absolute_column = false; + absolute_row = false; + + // Convert a coordinate string like 'B12' to a tuple ('B', 12) + bool column_part = true; + + std::string column_string; + + for (auto character : reference_string) + { + auto upper = static_cast(std::toupper(static_cast(character))); + + if (std::isalpha(character)) + { + if (column_part) + { + column_string.append(1, upper); + } + else + { + throw invalid_cell_reference(reference_string); + } + } + else if (character == '$') + { + if (column_part) + { + if (column_string.empty()) + { + column_string.append(1, upper); + } + else + { + column_part = false; + } + } + } + else + { + if (column_part) + { + column_part = false; + } + else if (!std::isdigit(character)) + { + throw invalid_cell_reference(reference_string); + } + } + } + + std::string row_string = reference_string.substr(column_string.length()); + + if (row_string.length() == 0) + { + throw invalid_cell_reference(reference_string); + } + + if (column_string[0] == '$') + { + absolute_column = true; + column_string = column_string.substr(1); + } + + if (row_string[0] == '$') + { + absolute_row = true; + row_string = row_string.substr(1); + } + + return {column_string, std::stoi(row_string)}; +} + +bool cell_reference::column_absolute() const +{ + return absolute_column_; +} + +void cell_reference::column_absolute(bool absolute_column) +{ + absolute_column_ = absolute_column; +} + +bool cell_reference::row_absolute() const +{ + return absolute_row_; +} + +void cell_reference::row_absolute(bool absolute_row) +{ + absolute_row_ = absolute_row; +} + +column_t cell_reference::column() const +{ + return column_; +} + +void cell_reference::column(const std::string &column_string) +{ + column_ = column_t(column_string); +} + +column_t::index_t cell_reference::column_index() const +{ + return column_.index; +} + +void cell_reference::column_index(column_t column) +{ + column_ = column; +} + +row_t cell_reference::row() const +{ + return row_; +} + +void cell_reference::row(row_t row) +{ + row_ = row; +} + +bool cell_reference::operator==(const std::string &reference_string) const +{ + return *this == cell_reference(reference_string); +} + +bool cell_reference::operator==(const char *reference_string) const +{ + return *this == std::string(reference_string); +} + +bool cell_reference::operator!=(const cell_reference &comparand) const +{ + return !(*this == comparand); +} + +bool cell_reference::operator!=(const std::string &reference_string) const +{ + return *this != cell_reference(reference_string); +} + +bool cell_reference::operator!=(const char *reference_string) const +{ + return *this != std::string(reference_string); +} + +cell_reference cell_reference::make_offset(int column_offset, int row_offset) const +{ + // TODO: check for overflow/underflow + auto relative_column = static_cast(static_cast(column_.index) + column_offset); + auto relative_row = static_cast(static_cast(row_) + row_offset); + + return cell_reference(relative_column, relative_row); +} + +bool cell_reference::operator==(const cell_reference &comparand) const +{ + return comparand.column_ == column_ + && comparand.row_ == row_ + && absolute_column_ == comparand.absolute_column_ + && absolute_row_ == comparand.absolute_row_; +} + +} // namespace xlnt diff --git a/source/cell/comment.cpp b/source/cell/comment.cpp new file mode 100644 index 0000000000..c6a162c575 --- /dev/null +++ b/source/cell/comment.cpp @@ -0,0 +1,120 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file +#include + +namespace xlnt { + +comment::comment() + : comment("", "") +{ +} + +comment::comment(const rich_text &text, const std::string &author) + : text_(text), author_(author) +{ +} + +comment::comment(const std::string &text, const std::string &author) + : text_(), author_(author) +{ + text_.plain_text(text, false); +} + +rich_text comment::text() const +{ + return text_; +} + +std::string comment::plain_text() const +{ + return text_.plain_text(); +} + +std::string comment::author() const +{ + return author_; +} + +void comment::hide() +{ + visible_ = false; +} + +void comment::show() +{ + visible_ = true; +} + +void comment::position(int left, int top) +{ + left_ = left; + top_ = top; +} + +void comment::size(int width, int height) +{ + width_ = width; + height_ = height; +} + +bool comment::visible() const +{ + return visible_; +} + +int comment::left() const +{ + return left_; +} + +int comment::top() const +{ + return top_; +} + +int comment::width() const +{ + return width_; +} + +int comment::height() const +{ + return height_; +} + +bool comment::operator==(const comment &other) const +{ + // not comparing top/left as this is set on a per cell basis + return text_ == other.text_ + && author_ == other.author_ + && width_ == other.width_ + && height_ == other.height_; +} + +bool comment::operator!=(const comment &other) const +{ + return !(*this == other); +} + +} // namespace xlnt diff --git a/source/cell/hyperlink.cpp b/source/cell/hyperlink.cpp new file mode 100644 index 0000000000..00c73798d7 --- /dev/null +++ b/source/cell/hyperlink.cpp @@ -0,0 +1,116 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include +#include + +namespace xlnt { + +hyperlink::hyperlink(detail::hyperlink_impl *d) + : d_(d) +{ +} + +relationship hyperlink::relationship() const +{ + if (!external()) + { + throw xlnt::exception("only external hyperlinks have associated relationships"); + } + + return d_->relationship; +} + +std::string hyperlink::url() const +{ + if (!external()) + { + throw xlnt::exception("only external hyperlinks have associated urls"); + } + + return d_->relationship.target().to_string(); +} + +std::string hyperlink::target_range() const +{ + if (external()) + { + throw xlnt::exception("only internal hyperlinks have a target range"); + } + + return d_->relationship.target().to_string(); +} + +bool hyperlink::external() const +{ + return d_->relationship.target_mode() == target_mode::external; +} + +bool hyperlink::has_display() const +{ + return d_->display.is_set(); +} + +void hyperlink::display(const std::string &value) +{ + d_->display.set(value); +} + +const std::string &hyperlink::display() const +{ + return d_->display.get(); +} + +bool hyperlink::has_tooltip() const +{ + return d_->tooltip.is_set(); +} + +void hyperlink::tooltip(const std::string &value) +{ + d_->tooltip.set(value); +} + +const std::string &hyperlink::tooltip() const +{ + return d_->tooltip.get(); +} + +bool hyperlink::has_location() const +{ + return d_->location.is_set(); +} + +void hyperlink::location(const std::string &value) +{ + d_->location.set(value); +} + +const std::string &hyperlink::location() const +{ + return d_->location.get(); +} + +} // namespace xlnt diff --git a/source/cell/index_types.cpp b/source/cell/index_types.cpp new file mode 100644 index 0000000000..409f43f36c --- /dev/null +++ b/source/cell/index_types.cpp @@ -0,0 +1,299 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file +#include + +#include +#include +#include + +namespace xlnt { + +column_t::index_t column_t::column_index_from_string(const std::string &column_string) +{ + if (column_string.length() > 3 || column_string.empty()) + { + throw invalid_column_index(); + } + + column_t::index_t column_index = 0; + int place = 1; + + for (int i = static_cast(column_string.length()) - 1; i >= 0; i--) + { + if (!std::isalpha(column_string[static_cast(i)])) + { + throw invalid_column_index(); + } + + auto char_index = std::toupper(column_string[static_cast(i)]) - 'A'; + + column_index += static_cast((char_index + 1) * place); + place *= 26; + } + + return column_index; +} + +// Convert a column number into a column letter (3 -> 'C') +// Right shift the column col_idx by 26 to find column letters in reverse +// order.These numbers are 1 - based, and can be converted to ASCII +// ordinals by adding 64. +std::string column_t::column_string_from_index(column_t::index_t column_index) +{ + // these indicies corrospond to A->ZZZ and include all allowed + // columns + if (column_index < constants::min_column() || column_index > constants::max_column()) + { + throw invalid_column_index(); + } + + int temp = static_cast(column_index); + std::string column_letter = ""; + + while (temp > 0) + { + int quotient = temp / 26, remainder = temp % 26; + + // check for exact division and borrow if needed + if (remainder == 0) + { + quotient -= 1; + remainder = 26; + } + + column_letter = std::string(1, char(remainder + 64)) + column_letter; + temp = quotient; + } + + return column_letter; +} + +column_t::column_t() + : index(1) +{ +} + +column_t::column_t(index_t column_index) + : index(column_index) +{ +} + +column_t::column_t(const std::string &column_string) + : index(column_index_from_string(column_string)) +{ +} + +column_t::column_t(const char *column_string) + : column_t(std::string(column_string)) +{ +} + +std::string column_t::column_string() const +{ + return column_string_from_index(index); +} + +column_t &column_t::operator=(const std::string &rhs) +{ + return *this = column_t(rhs); +} + +column_t &column_t::operator=(const char *rhs) +{ + return *this = column_t(rhs); +} + +bool column_t::operator==(const column_t &other) const +{ + return index == other.index; +} + +bool column_t::operator!=(const column_t &other) const +{ + return !(*this == other); +} + +bool column_t::operator==(int other) const +{ + return *this == column_t(static_cast(other)); +} + +bool column_t::operator==(index_t other) const +{ + return *this == column_t(other); +} + +bool column_t::operator==(const std::string &other) const +{ + return *this == column_t(other); +} + +bool column_t::operator==(const char *other) const +{ + return *this == column_t(other); +} + +bool column_t::operator!=(int other) const +{ + return !(*this == other); +} + +bool column_t::operator!=(index_t other) const +{ + return !(*this == other); +} + +bool column_t::operator!=(const std::string &other) const +{ + return !(*this == other); +} + +bool column_t::operator!=(const char *other) const +{ + return !(*this == other); +} + +bool column_t::operator>(const column_t &other) const +{ + return index > other.index; +} + +bool column_t::operator>=(const column_t &other) const +{ + return index >= other.index; +} + +bool column_t::operator<(const column_t &other) const +{ + return index < other.index; +} + +bool column_t::operator<=(const column_t &other) const +{ + return index <= other.index; +} + +bool column_t::operator>(const column_t::index_t &other) const +{ + return index > other; +} + +bool column_t::operator>=(const column_t::index_t &other) const +{ + return index >= other; +} + +bool column_t::operator<(const column_t::index_t &other) const +{ + return index < other; +} + +bool column_t::operator<=(const column_t::index_t &other) const +{ + return index <= other; +} + +column_t &column_t::operator++() +{ + index++; + return *this; +} + +column_t &column_t::operator--() +{ + index--; + return *this; +} + +column_t column_t::operator++(int) +{ + column_t copy(index); + ++(*this); + return copy; +} + +column_t column_t::operator--(int) +{ + column_t copy(index); + --(*this); + return copy; +} + +column_t operator+(column_t lhs, const column_t &rhs) +{ + lhs += rhs; + return lhs; +} + +column_t operator-(column_t lhs, const column_t &rhs) +{ + lhs -= rhs; + return lhs; +} + +column_t &column_t::operator+=(const column_t &rhs) +{ + index += rhs.index; + return *this; +} + +column_t &column_t::operator-=(const column_t &rhs) +{ + index -= rhs.index; + return *this; +} + +bool operator>(const column_t::index_t &left, const column_t &right) +{ + return column_t(left) > right; +} + +bool operator>=(const column_t::index_t &left, const column_t &right) +{ + return column_t(left) >= right; +} + +bool operator<(const column_t::index_t &left, const column_t &right) +{ + return column_t(left) < right; +} + +bool operator<=(const column_t::index_t &left, const column_t &right) +{ + return column_t(left) <= right; +} + +void swap(column_t &left, column_t &right) +{ + using std::swap; + swap(left.index, right.index); +} + +std::size_t column_hash::operator()(const column_t &k) const +{ + static std::hash hasher; + return hasher(k.index); +} + +} // namespace xlnt diff --git a/source/cell/phonetic_run.cpp b/source/cell/phonetic_run.cpp new file mode 100644 index 0000000000..991ddf45f5 --- /dev/null +++ b/source/cell/phonetic_run.cpp @@ -0,0 +1,39 @@ +// Copyright (c) 2014-2020 +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include +#include + +namespace xlnt { + +bool phonetic_run::operator==(const phonetic_run &other) const +{ + return std::tie(text, start, end, preserve_space) == std::tie(other.text, other.start, other.end, other.preserve_space); +} + +bool phonetic_run::operator!=(const phonetic_run &other) const +{ + return !(*this == other); +} + +} // namespace xlnt diff --git a/source/cell/rich_text.cpp b/source/cell/rich_text.cpp new file mode 100644 index 0000000000..1db754de00 --- /dev/null +++ b/source/cell/rich_text.cpp @@ -0,0 +1,172 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// Copyright (c) 2010-2015 openpyxl +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file +#include + +#include +#include + +namespace { +bool has_trailing_whitespace(const std::string &s) +{ + return !s.empty() && (s.front() == ' ' || s.back() == ' '); +}; +} // namespace + +namespace xlnt { + +rich_text::rich_text(const std::string &plain_text) + : rich_text(rich_text_run{plain_text, optional(), has_trailing_whitespace(plain_text)}) +{ +} + +rich_text::rich_text(const std::string &plain_text, const class font &text_font) + : rich_text(rich_text_run{plain_text, optional(text_font), has_trailing_whitespace(plain_text)}) +{ +} + +rich_text::rich_text(const rich_text &other) +{ + *this = other; +} + +rich_text &rich_text::operator=(const rich_text &rhs) +{ + clear(); + runs_ = rhs.runs_; + phonetic_runs_ = rhs.phonetic_runs_; + phonetic_properties_ = rhs.phonetic_properties_; + return *this; +} + +rich_text::rich_text(const rich_text_run &single_run) +{ + add_run(single_run); +} + +void rich_text::clear() +{ + runs_.clear(); + phonetic_runs_.clear(); + phonetic_properties_.clear(); +} + +void rich_text::plain_text(const std::string &s, bool preserve_space = false) +{ + clear(); + add_run(rich_text_run{s, {}, preserve_space}); +} + +std::string rich_text::plain_text() const +{ + if (runs_.size() == 1) + { + return runs_.begin()->first; + } + + return std::accumulate(runs_.begin(), runs_.end(), std::string(), + [](const std::string &a, const rich_text_run &run) { return a + run.first; }); +} + +std::vector rich_text::runs() const +{ + return runs_; +} + +void rich_text::runs(const std::vector &new_runs) +{ + runs_ = new_runs; +} + +void rich_text::add_run(const rich_text_run &t) +{ + runs_.push_back(t); +} + +std::vector rich_text::phonetic_runs() const +{ + return phonetic_runs_; +} + +void rich_text::phonetic_runs(const std::vector &new_phonetic_runs) +{ + phonetic_runs_ = new_phonetic_runs; +} + +void rich_text::add_phonetic_run(const phonetic_run &r) +{ + phonetic_runs_.push_back(r); +} + +bool rich_text::has_phonetic_properties() const +{ + return phonetic_properties_.is_set(); +} + +const phonetic_pr &rich_text::phonetic_properties() const +{ + return phonetic_properties_.get(); +} + +void rich_text::phonetic_properties(const phonetic_pr &phonetic_props) +{ + phonetic_properties_.set(phonetic_props); +} + +bool rich_text::operator==(const rich_text &rhs) const +{ + if (runs_.size() != rhs.runs_.size()) return false; + + for (std::size_t i = 0; i < runs_.size(); i++) + { + if (runs_[i] != rhs.runs_[i]) return false; + } + + if (phonetic_runs_.size() != rhs.phonetic_runs_.size()) return false; + + for (std::size_t i = 0; i < phonetic_runs_.size(); i++) + { + if (phonetic_runs_[i] != rhs.phonetic_runs_[i]) return false; + } + + if (phonetic_properties_ != rhs.phonetic_properties_) return false; + + return true; +} + +bool rich_text::operator==(const std::string &rhs) const +{ + return *this == rich_text(rhs); +} + +bool rich_text::operator!=(const rich_text &rhs) const +{ + return !(*this == rhs); +} + +bool rich_text::operator!=(const std::string &rhs) const +{ + return !(*this == rhs); +} + +} // namespace xlnt diff --git a/source/cell/rich_text_run.cpp b/source/cell/rich_text_run.cpp new file mode 100644 index 0000000000..cc4e3caf07 --- /dev/null +++ b/source/cell/rich_text_run.cpp @@ -0,0 +1,38 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include + +namespace xlnt { + +bool rich_text_run::operator==(const rich_text_run &other) const +{ + return first == other.first && second == other.second; +} + +bool rich_text_run::operator!=(const rich_text_run &other) const +{ + return !(*this == other); +} + +} // namespace xlnt diff --git a/source/detail/binary.hpp b/source/detail/binary.hpp new file mode 100644 index 0000000000..2da15471a4 --- /dev/null +++ b/source/detail/binary.hpp @@ -0,0 +1,327 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#pragma once + +#include +#include +#include +#include + +#include + +namespace xlnt { +namespace detail { + +using byte = std::uint8_t; + +template +class binary_reader +{ +public: + binary_reader() = delete; + + binary_reader(const std::vector &vector) + : vector_(&vector), + data_(nullptr), + size_(0) + { + } + + binary_reader(const T *source_data, std::size_t size) + : vector_(nullptr), + data_(source_data), + size_(size) + { + } + + binary_reader(const binary_reader &other) = default; + + binary_reader &operator=(const binary_reader &other) + { + vector_ = other.vector_; + offset_ = other.offset_; + data_ = other.data_; + + return *this; + } + + ~binary_reader() + { + } + + const T *data() const + { + return vector_ == nullptr ? data_ : vector_->data(); + } + + void offset(std::size_t offset) + { + offset_ = offset; + } + + std::size_t offset() const + { + return offset_; + } + + void reset() + { + offset_ = 0; + } + + template + U read() + { + return read_reference(); + } + + template + const U *read_pointer() + { + const auto result = reinterpret_cast(data() + offset_); + offset_ += sizeof(U) / sizeof(T); + + return result; + } + + template + const U &read_reference() + { + return *read_pointer(); + } + + template + std::vector as_vector() const + { + auto result = std::vector(bytes() / sizeof(U), U()); + std::memcpy(result.data(), data(), bytes()); + + return result; + } + + template + std::vector read_vector(std::size_t count) + { + auto result = std::vector(count, U()); + std::memcpy(result.data(), data() + offset_, count * sizeof(U)); + offset_ += count * sizeof(T) / sizeof(U); + + return result; + } + + std::size_t count() const + { + return vector_ != nullptr ? vector_->size() : size_; + } + + std::size_t bytes() const + { + return count() * sizeof(T); + } + +private: + std::size_t offset_ = 0; + const std::vector *vector_; + const T *data_; + const std::size_t size_; +}; + +template +class binary_writer +{ +public: + binary_writer(std::vector &bytes) + : data_(&bytes) + { + } + + binary_writer(const binary_writer &other) + { + *this = other; + } + + ~binary_writer() + { + } + + binary_writer &operator=(const binary_writer &other) + { + data_ = other.data_; + offset_ = other.offset_; + + return *this; + } + + std::vector &data() + { + return *data_; + } + + // Make the bytes of the data pointed to by this writer equivalent to those in the given vector + // sizeof(U) should be a multiple of sizeof(T) + template + void assign(const std::vector &ints) + { + resize(ints.size() * sizeof(U)); + std::memcpy(data_->data(), ints.data(), bytes()); + } + + // Make the bytes of the data pointed to by this writer equivalent to those in the given string + // sizeof(U) should be a multiple of sizeof(T) + template + void assign(const std::basic_string &string) + { + resize(string.size() * sizeof(U)); + std::memcpy(data_->data(), string.data(), bytes()); + } + + void offset(std::size_t new_offset) + { + offset_ = new_offset; + } + + std::size_t offset() const + { + return offset_; + } + + void reset() + { + offset_ = 0; + data_->clear(); + } + + template + void write(U value) + { + const auto num_bytes = sizeof(U); + const auto remaining_bytes = bytes() - offset() * sizeof(T); + + if (remaining_bytes < num_bytes) + { + extend((num_bytes - remaining_bytes) / sizeof(T)); + } + + std::memcpy(data_->data() + offset(), &value, num_bytes); + offset_ += num_bytes / sizeof(T); + } + + std::size_t count() const + { + return data_->size(); + } + + std::size_t bytes() const + { + return count() * sizeof(T); + } + + void resize(std::size_t new_size, byte fill = 0) + { + data_->resize(new_size, fill); + } + + void extend(std::size_t amount, byte fill = 0) + { + data_->resize(count() + amount, fill); + } + + std::vector::iterator iterator() + { + return data_->begin() + static_cast(offset()); + } + + template + void append(const std::vector &data) + { + binary_reader reader(data); + append(reader, data.size() * sizeof(U)); + } + + template + void append(binary_reader &reader, std::size_t reader_element_count) + { + const auto num_bytes = sizeof(U) * reader_element_count; + const auto remaining_bytes = bytes() - offset() * sizeof(T); + + if (remaining_bytes < num_bytes) + { + extend((num_bytes - remaining_bytes) / sizeof(T)); + } + + if ((reader.offset() + reader_element_count) * sizeof(U) > reader.bytes()) + { + throw xlnt::exception("reading past end"); + } + + std::memcpy(data_->data() + offset_, reader.data() + reader.offset(), reader_element_count * sizeof(U)); + offset_ += reader_element_count * sizeof(U) / sizeof(T); + } + +private: + std::vector *data_; + std::size_t offset_ = 0; +}; + +template +std::vector string_to_bytes(const std::basic_string &string) +{ + std::vector bytes; + binary_writer writer(bytes); + writer.assign(string); + + return bytes; +} + +template +T read(std::istream &in) +{ + T result; + in.read(reinterpret_cast(&result), sizeof(T)); + + return result; +} + +template +std::vector read_vector(std::istream &in, std::size_t count) +{ + std::vector result(count, T()); + in.read(reinterpret_cast(&result[0]), + static_cast(sizeof(T) * count)); + + return result; +} + +template +std::basic_string read_string(std::istream &in, std::size_t count) +{ + std::basic_string result(count, T()); + in.read(reinterpret_cast(&result[0]), + static_cast(sizeof(T) * count)); + + return result; +} + +} // namespace detail +} // namespace xlnt diff --git a/source/detail/constants.cpp b/source/detail/constants.cpp new file mode 100644 index 0000000000..4fe31bb81d --- /dev/null +++ b/source/detail/constants.cpp @@ -0,0 +1,175 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#include + +#include +#include +#include + +namespace xlnt { + +row_t constants::min_row() +{ + return 1; +} + +row_t constants::max_row() +{ + return std::numeric_limits::max(); +} + +const column_t constants::min_column() +{ + return column_t(1); +} + +const column_t constants::max_column() +{ + return column_t(std::numeric_limits::max()); +} + +// constants +const path constants::package_properties() +{ + return path("docProps"); +} + +const path constants::package_xl() +{ + return path("/xl"); +} + +const path constants::package_root_rels() +{ + return path(std::string("_rels")); +} + +const path constants::package_theme() +{ + return package_xl().append("theme"); +} + +const path constants::package_worksheets() +{ + return package_xl().append("worksheets"); +} + +const path constants::package_drawings() +{ + return package_xl().append("drawings"); +} + +const path constants::part_content_types() +{ + return path("[Content_Types].xml"); +} + +const path constants::part_root_relationships() +{ + return package_root_rels().append(".rels"); +} + +const path constants::part_core() +{ + return package_properties().append("core.xml"); +} + +const path constants::part_app() +{ + return package_properties().append("app.xml"); +} + +const path constants::part_workbook() +{ + return package_xl().append("workbook.xml"); +} + +const path constants::part_styles() +{ + return package_xl().append("styles.xml"); +} + +const path constants::part_theme() +{ + return package_theme().append("theme1.xml"); +} + +const path constants::part_shared_strings() +{ + return package_xl().append("sharedStrings.xml"); +} + +const std::unordered_map &constants::namespaces() +{ + static const std::unordered_map namespaces = + std::unordered_map{ + {"spreadsheetml", "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}, + {"content-types", "http://schemas.openxmlformats.org/package/2006/content-types"}, + {"relationships", "http://schemas.openxmlformats.org/package/2006/relationships"}, + {"drawingml", "http://schemas.openxmlformats.org/drawingml/2006/main"}, + {"workbook", "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}, + {"core-properties", "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"}, + {"extended-properties", "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"}, + {"custom-properties", "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"}, + + {"encryption", "http://schemas.microsoft.com/office/2006/encryption"}, + {"encryption-password", "http://schemas.microsoft.com/office/2006/keyEncryptor/password"}, + {"encryption-certificate", "http://schemas.microsoft.com/office/2006/keyEncryptor/certificate"}, + + {"dc", "http://purl.org/dc/elements/1.1/"}, + {"dcterms", "http://purl.org/dc/terms/"}, + {"dcmitype", "http://purl.org/dc/dcmitype/"}, + {"mc", "http://schemas.openxmlformats.org/markup-compatibility/2006"}, + {"mx", "http://schemas.microsoft.com/office/mac/excel/2008/main"}, + {"r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"}, + {"thm15", "http://schemas.microsoft.com/office/thememl/2012/main"}, + {"vt", "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"}, + {"x14", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"}, + {"x14ac", "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac"}, + {"x15", "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main"}, + {"x15ac", "http://schemas.microsoft.com/office/spreadsheetml/2010/11/ac"}, + {"xml", "http://www.w3.org/XML/1998/namespace"}, + {"xsi", "http://www.w3.org/2001/XMLSchema-instance"}, + + {"a", "http://schemas.openxmlformats.org/drawingml/2006/main"}, + {"xdr", "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"}, + + {"loext", "http://schemas.libreoffice.org/"}}; + + return namespaces; +} + +const std::string &constants::ns(const std::string &id) +{ + auto match = namespaces().find(id); + + if (match == namespaces().end()) + { + throw xlnt::exception("bad namespace"); + } + + return match->second; +} + +} // namespace xlnt diff --git a/source/detail/constants.hpp b/source/detail/constants.hpp new file mode 100644 index 0000000000..16acadeac4 --- /dev/null +++ b/source/detail/constants.hpp @@ -0,0 +1,138 @@ +// Copyright (c) 2014-2021 Thomas Fussell +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE +// +// @license: http://www.opensource.org/licenses/mit-license.php +// @author: see AUTHORS file + +#pragma once + +#include +#include + +#include +#include +#include + +namespace xlnt { + +struct XLNT_API constants +{ + ///

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