From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mx2.suse.de (mx2.suse.de [195.135.220.15]) by sourceware.org (Postfix) with ESMTPS id 1DD883857817 for ; Fri, 16 Oct 2020 14:04:54 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 1DD883857817 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=suse.cz Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mliska@suse.cz X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.221.27]) by mx2.suse.de (Postfix) with ESMTP id 3A76BB2EF; Fri, 16 Oct 2020 14:04:52 +0000 (UTC) Subject: [PATCH v2] Add if-chain to switch conversion pass. From: =?UTF-8?Q?Martin_Li=c5=a1ka?= To: Richard Biener Cc: David Malcolm , Jakub Jelinek , GCC Patches , Jan Hubicka References: <2c3db526-cac6-4eeb-4afb-12024f8d5af2@suse.cz> <20191104144851.GJ4650@tucnak> <6169f91a-4884-55f5-c76f-ea1dae11d996@suse.cz> <35eb0279-77d8-36f8-3ab7-afb9ae97fdb3@suse.cz> <42c91f11-c1a6-3ae4-08da-0a0b77f63b80@suse.cz> <72541e13d26f92577637b8f0e23d82435f35ddea.camel@redhat.com> <46e9e574-80f8-3cce-3fcf-dbc8205e74ae@suse.cz> Message-ID: <0f418e79-d46b-5577-ebdf-dbc29eed8057@suse.cz> Date: Fri, 16 Oct 2020 16:04:51 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.3.2 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------D752A7F6E5E0BA5BF719A360" Content-Language: en-US X-Spam-Status: No, score=-10.7 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_SHORT, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 16 Oct 2020 14:05:03 -0000 This is a multi-part message in MIME format. --------------D752A7F6E5E0BA5BF719A360 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Hello. There's another version of the patch that should be based on what I discussed with Richi and Jakub: - the first patch introduces a new option -fbit-tests that analogue to -fjump-tables and will control the new if-to-switch conversion pass - the second patch adds the pass - I share code with tree-ssa-reassoc.c (range_entry and init_range_entry) - a local discovery phase is run first - later than these local BBs are chained into a candidate list for the conversion I'm also sending transformed chains for 'make all-host' (620 transformations). Patch can bootstrap on x86_64-linux-gnu and survives regression tests. Thoughts? Thanks, Martin --------------D752A7F6E5E0BA5BF719A360 Content-Type: text/x-patch; charset=UTF-8; name="0002-Add-if-chain-to-switch-conversion-pass.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0002-Add-if-chain-to-switch-conversion-pass.patch" >From 69b043dfe5a741ca5b0d9536a0b59b1d5066d47f Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Fri, 28 Aug 2020 10:26:13 +0200 Subject: [PATCH 2/2] Add if-chain to switch conversion pass. gcc/ChangeLog: PR tree-optimization/14799 PR ipa/88702 * Makefile.in: Add gimple-if-to-switch.o. * dbgcnt.def (DEBUG_COUNTER): Add new debug counter. * passes.def: Include new pass_if_to_switch pass. * timevar.def (TV_TREE_IF_TO_SWITCH): New timevar. * tree-pass.h (make_pass_if_to_switch): New. * tree-ssa-reassoc.c (struct operand_entry): Move to the header. (dump_range_entry): Move to header file. (debug_range_entry): Likewise. (no_side_effect_bb): Make it global. * tree-switch-conversion.h (simple_cluster::simple_cluster): Add inline for couple of functions in order to prevent error about multiple defined symbols. * gimple-if-to-switch.cc: New file. * tree-ssa-reassoc.h: New file. gcc/testsuite/ChangeLog: PR tree-optimization/14799 PR ipa/88702 * gcc.dg/tree-ssa/pr96480.c: Disable if-to-switch conversion. * gcc.dg/tree-ssa/reassoc-32.c: Likewise. * g++.dg/tree-ssa/if-to-switch-1.C: New test. * gcc.dg/tree-ssa/if-to-switch-1.c: New test. * gcc.dg/tree-ssa/if-to-switch-2.c: New test. * gcc.dg/tree-ssa/if-to-switch-3.c: New test. * gcc.dg/tree-ssa/if-to-switch-4.c: New test. * gcc.dg/tree-ssa/if-to-switch-5.c: New test. * gcc.dg/tree-ssa/if-to-switch-6.c: New test. * gcc.dg/tree-ssa/if-to-switch-7.c: New test. * gcc.dg/tree-ssa/if-to-switch-8.c: New test. --- gcc/Makefile.in | 1 + gcc/dbgcnt.def | 1 + gcc/gimple-if-to-switch.cc | 565 ++++++++++++++++++ gcc/passes.def | 1 + .../g++.dg/tree-ssa/if-to-switch-1.C | 25 + .../gcc.dg/tree-ssa/if-to-switch-1.c | 35 ++ .../gcc.dg/tree-ssa/if-to-switch-2.c | 11 + .../gcc.dg/tree-ssa/if-to-switch-3.c | 11 + .../gcc.dg/tree-ssa/if-to-switch-4.c | 36 ++ .../gcc.dg/tree-ssa/if-to-switch-5.c | 12 + .../gcc.dg/tree-ssa/if-to-switch-6.c | 42 ++ .../gcc.dg/tree-ssa/if-to-switch-7.c | 25 + .../gcc.dg/tree-ssa/if-to-switch-8.c | 27 + gcc/testsuite/gcc.dg/tree-ssa/pr96480.c | 2 +- gcc/testsuite/gcc.dg/tree-ssa/reassoc-32.c | 2 +- gcc/timevar.def | 1 + gcc/tree-pass.h | 1 + gcc/tree-ssa-reassoc.c | 27 +- gcc/tree-ssa-reassoc.h | 48 ++ gcc/tree-switch-conversion.h | 24 +- 20 files changed, 865 insertions(+), 32 deletions(-) create mode 100644 gcc/gimple-if-to-switch.cc create mode 100644 gcc/testsuite/g++.dg/tree-ssa/if-to-switch-1.C create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-1.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-2.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-3.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-4.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-5.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-6.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-7.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-8.c create mode 100644 gcc/tree-ssa-reassoc.h diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 5a8fb0d7612..c7ecda54df2 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1361,6 +1361,7 @@ OBJS = \ gimple-array-bounds.o \ gimple-builder.o \ gimple-expr.o \ + gimple-if-to-switch.o \ gimple-iterator.o \ gimple-fold.o \ gimple-laddress.o \ diff --git a/gcc/dbgcnt.def b/gcc/dbgcnt.def index 07946a85ecc..c8d41065a94 100644 --- a/gcc/dbgcnt.def +++ b/gcc/dbgcnt.def @@ -170,6 +170,7 @@ DEBUG_COUNTER (if_after_combine) DEBUG_COUNTER (if_after_reload) DEBUG_COUNTER (if_conversion) DEBUG_COUNTER (if_conversion_tree) +DEBUG_COUNTER (if_to_switch) DEBUG_COUNTER (ipa_cp_bits) DEBUG_COUNTER (ipa_mod_ref) DEBUG_COUNTER (ipa_sra_params) diff --git a/gcc/gimple-if-to-switch.cc b/gcc/gimple-if-to-switch.cc new file mode 100644 index 00000000000..25ef45175a7 --- /dev/null +++ b/gcc/gimple-if-to-switch.cc @@ -0,0 +1,565 @@ +/* If-elseif-else to switch conversion pass + Copyright (C) 2020 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +/* Algorithm of the pass runs in the following steps: + a) We walk basic blocks in DOMINATOR order so that we first reach + a first condition of a future switch. + b) We follow false edges of a if-else-chain and we record chain + of GIMPLE conditions. These blocks are only used for comparison + of a common SSA_NAME and we do not allow any side effect. + c) We remove all basic blocks (except first) of such chain and + GIMPLE switch replaces the condition in the first basic block. + d) We move all GIMPLE statements in the removed blocks into the + first one. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "backend.h" +#include "rtl.h" +#include "tree.h" +#include "gimple.h" +#include "tree-pass.h" +#include "ssa.h" +#include "gimple-pretty-print.h" +#include "fold-const.h" +#include "gimple-iterator.h" +#include "tree-cfg.h" +#include "tree-dfa.h" +#include "tree-cfgcleanup.h" +#include "alias.h" +#include "tree-ssa-loop.h" +#include "diagnostic.h" +#include "cfghooks.h" +#include "tree-into-ssa.h" +#include "cfganal.h" +#include "dbgcnt.h" +#include "target.h" +#include "alloc-pool.h" +#include "tree-switch-conversion.h" +#include "tree-ssa-reassoc.h" + +using namespace tree_switch_conversion; + +struct condition_info +{ + typedef vec> mapping_vec; + + condition_info (gcond *cond): m_cond (cond), m_bb (gimple_bb (cond)), + m_forwarder_bb (NULL), m_ranges (), m_true_edge (NULL), m_false_edge (NULL), + m_true_edge_phi_mapping (), m_false_edge_phi_mapping () + { + m_ranges.create (0); + } + + /* Recond PHI mapping for an original edge E and save these into + vector VEC. */ + void record_phi_mapping (edge e, mapping_vec *vec); + + gcond *m_cond; + basic_block m_bb; + basic_block m_forwarder_bb; + vec m_ranges; + edge m_true_edge; + edge m_false_edge; + mapping_vec m_true_edge_phi_mapping; + mapping_vec m_false_edge_phi_mapping; +}; + +/* Recond PHI mapping for an original edge E and save these into vector VEC. */ + +void +condition_info::record_phi_mapping (edge e, mapping_vec *vec) +{ + for (gphi_iterator gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); + gsi_next (&gsi)) + { + gphi *phi = gsi.phi (); + if (!virtual_operand_p (gimple_phi_result (phi))) + { + tree arg = PHI_ARG_DEF_FROM_EDGE (phi, e); + vec->safe_push (std::make_pair (phi, arg)); + } + } +} + +/* Master structure for one if to switch conversion candidate. */ + +struct if_chain +{ + /* Default constructor. */ + if_chain (): m_entries () + { + m_entries.create (2); + } + + /* Default destructor. */ + ~if_chain () + { + m_entries.release (); + } + + /* Verify that all case ranges do not overlap. */ + bool check_non_overlapping_cases (); + + /* Return true when the switch can be expanded with a jump table or + a bit test (at least partially). */ + bool is_beneficial (); + + /* If chain entries. */ + vec m_entries; +}; + +/* Compare two case ranges by minimum value. */ + +static int +range_cmp (const void *a, const void *b) +{ + const range_entry *re1 = *(const range_entry * const *) a; + const range_entry *re2 = *(const range_entry * const *) b; + + return tree_int_cst_compare (re1->low, re2->low); +} + +/* Verify that all case ranges do not overlap. */ + +bool +if_chain::check_non_overlapping_cases () +{ + auto_vec all_ranges; + for (unsigned i = 0; i < m_entries.length (); i++) + for (unsigned j = 0; j < m_entries[i]->m_ranges.length (); j++) + all_ranges.safe_push (&m_entries[i]->m_ranges[j]); + + all_ranges.qsort (range_cmp); + + for (unsigned i = 0; i < all_ranges.length () - 1; i++) + { + range_entry *left = all_ranges[i]; + range_entry *right = all_ranges[i + 1]; + if (tree_int_cst_le (left->low, right->low) + && tree_int_cst_le (right->low, left->high)) + return false; + } + + return true; +} + +/* Compare clusters by minimum value. */ + +static int +cluster_cmp (const void *a, const void *b) +{ + simple_cluster *sc1 = *(simple_cluster * const *) a; + simple_cluster *sc2 = *(simple_cluster * const *) b; + + return tree_int_cst_compare (sc1->get_low (), sc2->get_high ()); +} + +/* Dump constructed CLUSTERS with prefix MESSAGE. */ + +static void +dump_clusters (vec *clusters, const char *message) +{ + if (dump_file) + { + fprintf (dump_file, ";; %s: ", message); + for (unsigned i = 0; i < clusters->length (); i++) + (*clusters)[i]->dump (dump_file, dump_flags & TDF_DETAILS); + fprintf (dump_file, "\n"); + } +} + +/* Return true when the switch can be expanded with a jump table or + a bit test (at least partially). */ + +bool +if_chain::is_beneficial () +{ + profile_probability prob = profile_probability::uninitialized (); + + auto_vec clusters; + clusters.create (m_entries.length ()); + + for (unsigned i = 0; i < m_entries.length (); i++) + { + condition_info *info = m_entries[i]; + for (unsigned j = 0; j < info->m_ranges.length (); j++) + { + range_entry *range = &info->m_ranges[j]; + basic_block bb = info->m_true_edge->dest; + bool has_forwarder = !info->m_true_edge_phi_mapping.is_empty (); + clusters.safe_push (new simple_cluster (range->low, range->high, + NULL_TREE, bb, prob, + has_forwarder)); + } + } + + /* Sort clusters and merge them. */ + auto_vec filtered_clusters; + filtered_clusters.create (16); + clusters.qsort (cluster_cmp); + simple_cluster *left = static_cast (clusters[0]); + filtered_clusters.safe_push (left); + + for (unsigned i = 1; i < clusters.length (); i++) + { + simple_cluster *right = static_cast (clusters[i]); + tree type = TREE_TYPE (left->get_low ()); + tree pos_one = build_int_cst (type, 1); + if (!left->m_has_forward_bb + && !right->m_has_forward_bb + && left->m_case_bb == right->m_case_bb) + { + tree next = int_const_binop (PLUS_EXPR, left->get_high (), pos_one); + if (tree_int_cst_equal (next, right->get_low ())) + { + left->set_high (right->get_high ()); + continue; + } + } + + left = static_cast (clusters[i]); + filtered_clusters.safe_push (left); + } + + dump_clusters (&filtered_clusters, "Canonical GIMPLE case clusters"); + + vec output + = jump_table_cluster::find_jump_tables (filtered_clusters); + bool r = output.length () < filtered_clusters.length (); + if (r) + dump_clusters (&output, "JT can be built"); + output.release (); + if (r) + return true; + + output = bit_test_cluster::find_bit_tests (filtered_clusters); + r = output.length () < filtered_clusters.length (); + if (r) + dump_clusters (&output, "BT can be built"); + output.release (); + return r; +} + +/* Build case label with MIN and MAX values of a given basic block DEST. */ + +static tree +build_case_label (tree index_type, tree min, tree max, basic_block dest) +{ + if (min != NULL_TREE && index_type != TREE_TYPE (min)) + min = fold_convert (index_type, min); + if (max != NULL_TREE && index_type != TREE_TYPE (max)) + max = fold_convert (index_type, max); + + tree label = gimple_block_label (dest); + return build_case_label (min, min == max ? NULL_TREE : max, label); +} + +/* Compare two integer constants. */ + +static int +label_cmp (const void *a, const void *b) +{ + const_tree l1 = *(const const_tree *) a; + const_tree l2 = *(const const_tree *) b; + + return tree_int_cst_compare (CASE_LOW (l1), CASE_LOW (l2)); +} + +/* Convert a given if CHAIN into a switch GIMPLE statement. */ + +static void +convert_if_conditions_to_switch (if_chain *chain) +{ + if (!dbg_cnt (if_to_switch)) + return; + + auto_vec labels; + unsigned entries = chain->m_entries.length (); + condition_info *first_cond = chain->m_entries[0]; + condition_info *last_cond = chain->m_entries[entries - 1]; + + edge default_edge = last_cond->m_false_edge; + basic_block default_bb = default_edge->dest; + + gimple_stmt_iterator gsi = gsi_for_stmt (first_cond->m_cond); + tree index_type = TREE_TYPE (first_cond->m_ranges[0].exp); + for (unsigned i = 0; i < entries; i++) + { + condition_info *info = chain->m_entries[i]; + basic_block case_bb = info->m_true_edge->dest; + + /* Create a forwarder block if needed. */ + if (!info->m_true_edge_phi_mapping.is_empty ()) + { + info->m_forwarder_bb = split_edge (info->m_true_edge); + case_bb = info->m_forwarder_bb; + } + + for (unsigned j = 0; j < info->m_ranges.length (); j++) + labels.safe_push (build_case_label (index_type, + info->m_ranges[j].low, + info->m_ranges[j].high, + case_bb)); + default_bb = info->m_false_edge->dest; + + if (i == 0) + { + remove_edge (first_cond->m_true_edge); + remove_edge (first_cond->m_false_edge); + } + else + delete_basic_block (info->m_bb); + + make_edge (first_cond->m_bb, case_bb, 0); + } + + labels.qsort (label_cmp); + + edge e = find_edge (first_cond->m_bb, default_bb); + if (e == NULL) + e = make_edge (first_cond->m_bb, default_bb, 0); + gswitch *s + = gimple_build_switch (first_cond->m_ranges[0].exp, + build_case_label (index_type, NULL_TREE, + NULL_TREE, default_bb), + labels); + + gsi_remove (&gsi, true); + gsi_insert_before (&gsi, s, GSI_NEW_STMT); + + if (dump_file) + { + fprintf (dump_file, "Expanded into a new gimple STMT: "); + print_gimple_stmt (dump_file, s, 0, TDF_SLIM); + putc ('\n', dump_file); + } + + /* Fill up missing PHI node arguments. */ + for (unsigned i = 0; i < chain->m_entries.length (); ++i) + { + condition_info *info = chain->m_entries[i]; + for (unsigned j = 0; j < info->m_true_edge_phi_mapping.length (); ++j) + { + std::pair item = info->m_true_edge_phi_mapping[j]; + add_phi_arg (item.first, item.second, + single_succ_edge (info->m_forwarder_bb), + UNKNOWN_LOCATION); + } + } + + /* Fill up missing PHI nodes for the default BB. */ + for (unsigned j = 0; j < last_cond->m_false_edge_phi_mapping.length (); ++j) + { + std::pair item = last_cond->m_false_edge_phi_mapping[j]; + add_phi_arg (item.first, item.second, e, UNKNOWN_LOCATION); + } +} + +/* Identify an index variable used in BB in a GIMPLE condition. + Save information about the condition into CONDITIONS_IN_BBS. */ + +static void +find_conditions (basic_block bb, + hash_map *conditions_in_bbs) +{ + gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb); + if (gsi_end_p (gsi)) + return; + + gcond *cond = dyn_cast (gsi_stmt (gsi)); + if (cond == NULL) + return; + + if (!no_side_effect_bb (bb)) + return; + + tree lhs = gimple_cond_lhs (cond); + tree rhs = gimple_cond_rhs (cond); + tree_code code = gimple_cond_code (cond); + + condition_info info (cond); + + gassign *def; + if (code == NE_EXPR + && TREE_CODE (lhs) == SSA_NAME + && (def = dyn_cast (SSA_NAME_DEF_STMT (lhs))) != NULL + && integer_zerop (rhs)) + { + enum tree_code rhs_code = gimple_assign_rhs_code (def); + if (rhs_code == BIT_IOR_EXPR) + { + info.m_ranges.safe_grow (2, true); + init_range_entry (&info.m_ranges[0], gimple_assign_rhs1 (def), NULL); + init_range_entry (&info.m_ranges[1], gimple_assign_rhs2 (def), NULL); + } + } + else + { + info.m_ranges.safe_grow (1, true); + init_range_entry (&info.m_ranges[0], NULL_TREE, cond); + } + + /* All identified ranges must have equal expression and IN_P flag. */ + if (!info.m_ranges.is_empty ()) + { + edge true_edge, false_edge; + tree expr = info.m_ranges[0].exp; + bool in_p = info.m_ranges[0].in_p; + + extract_true_false_edges_from_block (bb, &true_edge, &false_edge); + info.m_true_edge = in_p ? true_edge : false_edge; + info.m_false_edge = in_p ? false_edge : true_edge; + + for (unsigned i = 0; i < info.m_ranges.length (); ++i) + if (info.m_ranges[i].exp == NULL_TREE + || info.m_ranges[i].low == NULL_TREE + || info.m_ranges[i].high == NULL_TREE) + return; + + for (unsigned i = 1; i < info.m_ranges.length (); ++i) + if (info.m_ranges[i].exp != expr + || info.m_ranges[i].in_p != in_p) + return; + + info.record_phi_mapping (info.m_true_edge, + &info.m_true_edge_phi_mapping); + info.record_phi_mapping (info.m_false_edge, + &info.m_false_edge_phi_mapping); + conditions_in_bbs->put (bb, info); + } + +} + +namespace { + +const pass_data pass_data_if_to_switch = +{ + GIMPLE_PASS, /* type */ + "iftoswitch", /* name */ + OPTGROUP_NONE, /* optinfo_flags */ + TV_TREE_IF_TO_SWITCH, /* tv_id */ + ( PROP_cfg | PROP_ssa ), /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_cleanup_cfg | TODO_update_ssa /* todo_flags_finish */ +}; + +class pass_if_to_switch : public gimple_opt_pass +{ +public: + pass_if_to_switch (gcc::context *ctxt) + : gimple_opt_pass (pass_data_if_to_switch, ctxt) + {} + + /* opt_pass methods: */ + virtual bool gate (function *) + { + return (jump_table_cluster::is_enabled () + || bit_test_cluster::is_enabled ()); + } + + virtual unsigned int execute (function *); + +}; // class pass_if_to_switch + +unsigned int +pass_if_to_switch::execute (function *fun) +{ + auto_vec all_candidates; + hash_map conditions_in_bbs; + + basic_block bb; + FOR_EACH_BB_FN (bb, fun) + find_conditions (bb, &conditions_in_bbs); + + int *rpo = XNEWVEC (int, n_basic_blocks_for_fn (fun)); + unsigned n = pre_and_rev_post_order_compute_fn (fun, NULL, rpo, false); + + auto_bitmap seen_bbs; + for (int i = n - 1; i >= 0; --i) + { + basic_block bb = BASIC_BLOCK_FOR_FN (fun, rpo[i]); + if (bitmap_bit_p (seen_bbs, bb->index)) + continue; + + bitmap_set_bit (seen_bbs, bb->index); + condition_info *info = conditions_in_bbs.get (bb); + if (info) + { + if_chain *chain = new if_chain (); + chain->m_entries.safe_push (info); + /* Try to find a chain starting in this BB. */ + while (true) + { + if (!single_pred_p (gimple_bb (info->m_cond))) + break; + edge e = single_pred_edge (gimple_bb (info->m_cond)); + condition_info *info2 = conditions_in_bbs.get (e->src); + if (!info2 || info->m_ranges[0].exp != info2->m_ranges[0].exp) + break; + + chain->m_entries.safe_push (info2); + bitmap_set_bit (seen_bbs, e->src->index); + info = info2; + } + + chain->m_entries.reverse (); + if (chain->m_entries.length () >= 3 + && chain->check_non_overlapping_cases () + && chain->is_beneficial ()) + { + gcond *cond = chain->m_entries[0]->m_cond; + expanded_location loc = expand_location (gimple_location (cond)); + if (dump_file) + { + fprintf (dump_file, "Condition chain (at %s:%d) with %d BBs " + "transformed into a switch statement.\n", + loc.file, loc.line, + chain->m_entries.length ()); + } + all_candidates.safe_push (chain); + } + } + } + + for (unsigned i = 0; i < all_candidates.length (); i++) + { + convert_if_conditions_to_switch (all_candidates[i]); + delete all_candidates[i]; + } + + free (rpo); + free_dominance_info (CDI_DOMINATORS); + + if (!all_candidates.is_empty ()) + mark_virtual_operands_for_renaming (fun); + + return 0; +} + +} // anon namespace + +gimple_opt_pass * +make_pass_if_to_switch (gcc::context *ctxt) +{ + return new pass_if_to_switch (ctxt); +} diff --git a/gcc/passes.def b/gcc/passes.def index f865bdc19ac..10d7eeb091b 100644 --- a/gcc/passes.def +++ b/gcc/passes.def @@ -93,6 +93,7 @@ along with GCC; see the file COPYING3. If not see NEXT_PASS (pass_phiopt, true /* early_p */); NEXT_PASS (pass_modref); NEXT_PASS (pass_tail_recursion); + NEXT_PASS (pass_if_to_switch); NEXT_PASS (pass_convert_switch); NEXT_PASS (pass_cleanup_eh); NEXT_PASS (pass_profile); diff --git a/gcc/testsuite/g++.dg/tree-ssa/if-to-switch-1.C b/gcc/testsuite/g++.dg/tree-ssa/if-to-switch-1.C new file mode 100644 index 00000000000..0f9c8d35ff9 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/if-to-switch-1.C @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +void fancy_abort(const char *, int, const char *); + +enum machine_mode +{ + MODE_FLOAT, + MODE_DECIMAL_FLOAT, + MODE_COMPLEX_INT, + MODE_COMPLEX_FLOAT, + MODE_VECTOR_BOOL, + MODE_VECTOR_FLOAT +} extern const mode_class; + +void tree_node() { + if (mode_class) + mode_class == MODE_FLOAT || mode_class == MODE_DECIMAL_FLOAT || + mode_class == MODE_COMPLEX_FLOAT || mode_class == MODE_VECTOR_FLOAT + ? fancy_abort("aaa", 2, __FUNCTION__), + 0 : 0; + int g = 0; +} + +/* { dg-final { scan-tree-dump "Condition chain \\(at .*\\) with 3 BBs transformed into a switch statement." "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-1.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-1.c new file mode 100644 index 00000000000..94a0db649e4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-1.c @@ -0,0 +1,35 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int global; +int foo (); + +int main(int argc, char **argv) +{ + if (argc == 1) + foo (); + else if (argc == 2) + { + global += 1; + } + else if (argc == 3) + { + foo (); + foo (); + } + else if (argc == 4) + { + foo (); + } + else if (argc == 5) + { + global = 2; + } + else + global -= 123; + + global -= 12; + return 0; +} + +/* { dg-final { scan-tree-dump "Condition chain \\(at .*if-to-switch-1.c:9\\) with 5 BBs transformed into a switch statement." "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-2.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-2.c new file mode 100644 index 00000000000..b114e74ac37 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-2.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int IsHTMLWhitespaceNoRange(int aChar) +{ + return aChar == 0x0001 || aChar == 0x000A || + aChar == 0x000C || aChar == 0x000E || + aChar == 0x0020; +} + +/* { dg-final { scan-tree-dump "Condition chain \\(at .*if-to-switch-2.c:7\\) with 3 BBs transformed into a switch statement." "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-3.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-3.c new file mode 100644 index 00000000000..e157039e75b --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-3.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int IsHTMLWhitespace(int aChar) +{ + return aChar == 0x0009 || aChar == 0x000A || + aChar == 0x000C || aChar == 0x000D || + aChar == 0x0020 || aChar == 0x0030; +} + +/* { dg-final { scan-tree-dump "Condition chain \\(at .*if-to-switch-3.c:8\\) with 3 BBs transformed into a switch statement." "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-4.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-4.c new file mode 100644 index 00000000000..3ae006f6ca2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-4.c @@ -0,0 +1,36 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int global; +int foo (); + +int main(int argc, char **argv) +{ + if (argc == 1) + foo (); + else if (argc == 2) + { + global += 1; + } + else if (argc == 3) + { + foo (); + foo (); + } + else if (argc == 4) + { + foo (); + } + /* This will be removed with EVRP. */ + else if (argc == 1) + { + global = 2; + } + else + global -= 123; + + global -= 12; + return 0; +} + +/* { dg-final { scan-tree-dump-not "Condition chain" "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-5.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-5.c new file mode 100644 index 00000000000..46ea5b627c8 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-5.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int crud (unsigned char c) +{ + return (((((((((((int) c == 46) || (int) c == 44) + || (int) c == 58) || (int) c == 59) || (int) c == 60) + || (int) c == 62) || (int) c == 34) || (int) c == 92) + || (int) c == 39) != 0); +} + +/* { dg-final { scan-tree-dump "Condition chain \\(at .*if-to-switch-5.c:9\\) with 5 BBs transformed into a switch statement." "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-6.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-6.c new file mode 100644 index 00000000000..7af323ae251 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-6.c @@ -0,0 +1,42 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int global; +int foo (); + +int main(int argc, char **argv) +{ + if (argc >= 1 && argc <= 10) + foo (); + else if (argc == 12) + { + global += 1; + } + else if (argc == 13) + { + foo (); + foo (); + } + else if (argc == 14) + { + foo (); + } + /* This will be removed with EVRP. */ + else if (argc == 5) + { + global = 2; + } + /* This will be removed with EVRP. */ + else if (argc >= 7 && argc <= 9) + { + global = 2; + } + + else + global -= 123; + + global -= 12; + return 0; +} + +/* { dg-final { scan-tree-dump-not "Condition chain" "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-7.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-7.c new file mode 100644 index 00000000000..1a919bf025a --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-7.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int global; + +int foo(int a) +{ + int x = 0; + for (unsigned i = 0; i < a; i++) + { + if (a == 2) + { + global += 123; + x = 1; + } + else if (a == 3) + x = 2; + else if (a == 10) + x = 3; + } + + return x; +} + +/* { dg-final { scan-tree-dump-not "Condition chain " "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-8.c b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-8.c new file mode 100644 index 00000000000..a5f1a1eae18 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/if-to-switch-8.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-iftoswitch" } */ + +int global; +int global1; +int global2; +int global3; + +int foo(int a, int b) +{ + int x = 0; + for (unsigned i = 0; i < a; i++) + { + if (b == 1) + global += 2; + else if (a == 2) + global = 123; + else if (a == 3) + global1 = 1234; + else if (a == 10) + global2 = 12345; + else if (a == 1) + global2 = 123456; + } +} + +/* { dg-final { scan-tree-dump-not "Condition chain" "iftoswitch" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr96480.c b/gcc/testsuite/gcc.dg/tree-ssa/pr96480.c index f2a91ef9909..cc04721c1df 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr96480.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr96480.c @@ -1,6 +1,6 @@ /* PR tree-optimization/96480 */ /* { dg-do compile } */ -/* { dg-options "-O2 -fdump-tree-optimized" } */ +/* { dg-options "-O2 -fdump-tree-optimized -fno-bit-tests" } */ /* { dg-final { scan-tree-dump " = _\[0-9]* <= 3;" "optimized" } } */ int v[4]; diff --git a/gcc/testsuite/gcc.dg/tree-ssa/reassoc-32.c b/gcc/testsuite/gcc.dg/tree-ssa/reassoc-32.c index 944362ad076..093e7a57a27 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/reassoc-32.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/reassoc-32.c @@ -1,6 +1,6 @@ /* { dg-do run { target { ! "m68k*-*-* mmix*-*-* bfin*-*-* v850*-*-* moxie*-*-* cris*-*-* m32c*-*-* fr30*-*-* mcore*-*-* powerpc*-*-* xtensa*-*-*"} } } */ -/* { dg-options "-O2 -fno-inline -fdump-tree-reassoc1-details --param logical-op-non-short-circuit=1" } */ +/* { dg-options "-O2 -fno-inline -fdump-tree-reassoc1-details --param logical-op-non-short-circuit=1 -fno-bit-tests" } */ /* { dg-additional-options "-mbranch-cost=2" { target branch_cost } } */ diff --git a/gcc/timevar.def b/gcc/timevar.def index 08c21c04009..ee87718f3e4 100644 --- a/gcc/timevar.def +++ b/gcc/timevar.def @@ -292,6 +292,7 @@ DEFTIMEVAR (TV_VAR_TRACKING , "variable tracking") DEFTIMEVAR (TV_VAR_TRACKING_DATAFLOW , "var-tracking dataflow") DEFTIMEVAR (TV_VAR_TRACKING_EMIT , "var-tracking emit") DEFTIMEVAR (TV_TREE_IFCOMBINE , "tree if-combine") +DEFTIMEVAR (TV_TREE_IF_TO_SWITCH , "if to switch conversion") DEFTIMEVAR (TV_TREE_UNINIT , "uninit var analysis") DEFTIMEVAR (TV_PLUGIN_INIT , "plugin initialization") DEFTIMEVAR (TV_PLUGIN_RUN , "plugin execution") diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h index 62e5b696cab..f8adb902345 100644 --- a/gcc/tree-pass.h +++ b/gcc/tree-pass.h @@ -374,6 +374,7 @@ extern gimple_opt_pass *make_pass_empty_loop (gcc::context *ctxt); extern gimple_opt_pass *make_pass_graphite (gcc::context *ctxt); extern gimple_opt_pass *make_pass_graphite_transforms (gcc::context *ctxt); extern gimple_opt_pass *make_pass_if_conversion (gcc::context *ctxt); +extern gimple_opt_pass *make_pass_if_to_switch (gcc::context *ctxt); extern gimple_opt_pass *make_pass_loop_distribution (gcc::context *ctxt); extern gimple_opt_pass *make_pass_vectorize (gcc::context *ctxt); extern gimple_opt_pass *make_pass_simduid_cleanup (gcc::context *ctxt); diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index a2ca1713d4b..96765bdd3f2 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -51,6 +51,7 @@ along with GCC; see the file COPYING3. If not see #include "builtins.h" #include "gimplify.h" #include "case-cfn-macros.h" +#include "tree-ssa-reassoc.h" /* This is a simple global reassociation pass. It is, in part, based on the LLVM pass of the same name (They do some things more/less @@ -188,15 +189,6 @@ static struct int pows_created; } reassociate_stats; -/* Operator, rank pair. */ -struct operand_entry -{ - unsigned int rank; - unsigned int id; - tree op; - unsigned int count; - gimple *stmt_to_insert; -}; static object_allocator operand_entry_pool ("operand entry pool"); @@ -226,7 +218,7 @@ static bool reassoc_stmt_dominates_stmt_p (gimple *, gimple *); /* Wrapper around gsi_remove, which adjusts gimple_uid of debug stmts possibly added by gsi_remove. */ -bool +static bool reassoc_remove_stmt (gimple_stmt_iterator *gsi) { gimple *stmt = gsi_stmt (*gsi); @@ -2406,18 +2398,7 @@ optimize_ops_list (enum tree_code opcode, For more information see comments above fold_test_range in fold-const.c, this implementation is for GIMPLE. */ -struct range_entry -{ - tree exp; - tree low; - tree high; - bool in_p; - bool strict_overflow_p; - unsigned int idx, next; -}; -void dump_range_entry (FILE *file, struct range_entry *r); -void debug_range_entry (struct range_entry *r); /* Dump the range entry R to FILE, skipping its expression if SKIP_EXP. */ @@ -2447,7 +2428,7 @@ debug_range_entry (struct range_entry *r) an SSA_NAME and STMT argument is ignored, otherwise STMT argument should be a GIMPLE_COND. */ -static void +void init_range_entry (struct range_entry *r, tree exp, gimple *stmt) { int in_p; @@ -4284,7 +4265,7 @@ suitable_cond_bb (basic_block bb, basic_block test_bb, basic_block *other_bb, range test optimization, all SSA_NAMEs set in the bb are consumed in the bb and there are no PHIs. */ -static bool +bool no_side_effect_bb (basic_block bb) { gimple_stmt_iterator gsi; diff --git a/gcc/tree-ssa-reassoc.h b/gcc/tree-ssa-reassoc.h new file mode 100644 index 00000000000..dc7f59f1eca --- /dev/null +++ b/gcc/tree-ssa-reassoc.h @@ -0,0 +1,48 @@ +/* Reassociation for trees. + Copyright (C) 2020 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#ifndef GCC_SSA_REASSOC_H +#define GCC_SSA_REASSOC_H + +/* Operator, rank pair. */ +struct operand_entry +{ + unsigned int rank; + unsigned int id; + tree op; + unsigned int count; + gimple *stmt_to_insert; +}; + +struct range_entry +{ + tree exp; + tree low; + tree high; + bool in_p; + bool strict_overflow_p; + unsigned int idx, next; +}; + +void dump_range_entry (FILE *file, struct range_entry *r); +void debug_range_entry (struct range_entry *r); +void init_range_entry (struct range_entry *r, tree exp, gimple *stmt); +bool no_side_effect_bb (basic_block bb); + +#endif /* GCC_SSA_REASSOC_H */ diff --git a/gcc/tree-switch-conversion.h b/gcc/tree-switch-conversion.h index 7515e952eb3..62cfde168c8 100644 --- a/gcc/tree-switch-conversion.h +++ b/gcc/tree-switch-conversion.h @@ -48,8 +48,8 @@ class cluster { public: /* Constructor. */ - cluster (tree case_label_expr, basic_block case_bb, profile_probability prob, - profile_probability subtree_prob); + inline cluster (tree case_label_expr, basic_block case_bb, + profile_probability prob, profile_probability subtree_prob); /* Destructor. */ virtual ~cluster () @@ -121,8 +121,9 @@ class simple_cluster: public cluster { public: /* Constructor. */ - simple_cluster (tree low, tree high, tree case_label_expr, - basic_block case_bb, profile_probability prob); + inline simple_cluster (tree low, tree high, tree case_label_expr, + basic_block case_bb, profile_probability prob, + bool has_forward_bb = false); /* Destructor. */ ~simple_cluster () @@ -146,6 +147,11 @@ public: return m_high; } + void set_high (tree high) + { + m_high = high; + } + void debug () { @@ -182,12 +188,16 @@ public: /* True if case is a range. */ bool m_range_p; + + /* True if the case will use a forwarder BB. */ + bool m_has_forward_bb; }; simple_cluster::simple_cluster (tree low, tree high, tree case_label_expr, - basic_block case_bb, profile_probability prob): + basic_block case_bb, profile_probability prob, + bool has_forward_bb): cluster (case_label_expr, case_bb, prob, prob), - m_low (low), m_high (high) + m_low (low), m_high (high), m_has_forward_bb (has_forward_bb) { m_range_p = m_high != NULL; if (m_high == NULL) @@ -271,7 +281,7 @@ public: static inline unsigned int case_values_threshold (void); /* Return whether jump table expansion is allowed. */ - static bool is_enabled (void); + static inline bool is_enabled (void); }; /* A GIMPLE switch statement can be expanded to a short sequence of bit-wise -- 2.28.0 --------------D752A7F6E5E0BA5BF719A360 Content-Type: text/x-patch; charset=UTF-8; name="0001-Add-fbit-tests-option.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0001-Add-fbit-tests-option.patch" >From 7984458480ceadc6b3c43ed952c21d55305bc567 Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Fri, 2 Oct 2020 14:12:06 +0200 Subject: [PATCH 1/2] Add -fbit-tests option. gcc/ChangeLog: * common.opt: Add new -fbit-tests option. * doc/invoke.texi: Document the option. * tree-switch-conversion.c (bit_test_cluster::find_bit_tests): Use the option. * tree-switch-conversion.h (is_enabled): New function. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/switch-4.c: New test. --- gcc/common.opt | 4 ++++ gcc/doc/invoke.texi | 8 +++++++- gcc/testsuite/gcc.dg/tree-ssa/switch-4.c | 25 ++++++++++++++++++++++++ gcc/tree-switch-conversion.c | 3 +++ gcc/tree-switch-conversion.h | 6 ++++++ 5 files changed, 45 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/switch-4.c diff --git a/gcc/common.opt b/gcc/common.opt index 7e789d1c47f..aa3d75c2357 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -1936,6 +1936,10 @@ fjump-tables Common Var(flag_jump_tables) Init(1) Optimization Use jump tables for sufficiently large switch statements. +fbit-tests +Common Var(flag_bit_tests) Init(1) Optimization +Use bit tests for sufficiently large switch statements. + fkeep-inline-functions Common Report Var(flag_keep_inline_functions) Generate code for functions even if they are fully inlined. diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 631a119181c..9ee62197b51 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -635,7 +635,7 @@ Objective-C and Objective-C++ Dialects}. -fno-gnu-unique @gol -finhibit-size-directive -fcommon -fno-ident @gol -fpcc-struct-return -fpic -fPIC -fpie -fPIE -fno-plt @gol --fno-jump-tables @gol +-fno-jump-tables -fno-bit-tests @gol -frecord-gcc-switches @gol -freg-struct-return -fshort-enums -fshort-wchar @gol -fverbose-asm -fpack-struct[=@var{n}] @gol @@ -15879,6 +15879,12 @@ building code that forms part of a dynamic linker and cannot reference the address of a jump table. On some targets, jump tables do not require a GOT and this option is not needed. +@item -fno-bit-tests +@opindex fno-bit-tests +@opindex fbit-tests +Do not use bit tests for switch statements even where it would be +more efficient than other code generation strategies. + @item -ffixed-@var{reg} @opindex ffixed Treat the register named @var{reg} as a fixed register; generated code diff --git a/gcc/testsuite/gcc.dg/tree-ssa/switch-4.c b/gcc/testsuite/gcc.dg/tree-ssa/switch-4.c new file mode 100644 index 00000000000..5953ef34e9b --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/switch-4.c @@ -0,0 +1,25 @@ +/* { dg-do compile { target { { x86_64-*-* aarch64-*-* ia64-*-* powerpc64-*-* } && lp64 } } } */ +/* { dg-options "-O2 -fno-bit-tests -fdump-tree-switchlower1" } */ + +int global; + +int foo (int x) +{ + switch (x) { + case 0: + case 10: + return 1; + case 20: + case 30: + case 62: + return 2; + case 1000: + case 1010: + case 1025 ... 1030: + return 1; + default: + return 0; + } +} + +/* { dg-final { scan-tree-dump-not "BT:" "switchlower1" } } */ diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c index 03a1fe632d0..426462e856b 100644 --- a/gcc/tree-switch-conversion.c +++ b/gcc/tree-switch-conversion.c @@ -1310,6 +1310,9 @@ jump_table_cluster::is_beneficial (const vec &, vec bit_test_cluster::find_bit_tests (vec &clusters) { + if (!is_enabled ()) + return clusters.copy (); + unsigned l = clusters.length (); auto_vec min; min.reserve (l + 1); diff --git a/gcc/tree-switch-conversion.h b/gcc/tree-switch-conversion.h index dbfd9eecba2..7515e952eb3 100644 --- a/gcc/tree-switch-conversion.h +++ b/gcc/tree-switch-conversion.h @@ -411,6 +411,12 @@ public: basic_block case_bb, profile_probability prob); + /* Return whether bit test expansion is allowed. */ + static inline bool is_enabled (void) + { + return flag_bit_tests; + } + /* True when the jump table handles an entire switch statement. */ bool m_handles_entire_switch; -- 2.28.0 --------------D752A7F6E5E0BA5BF719A360 Content-Type: text/plain; charset=UTF-8; name="if-to-switch-v2.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="if-to-switch-v2.txt" Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9saWJj cHAvaW5pdC5jOjU1NSkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9saWJjcHAvbWFjcm8uYzo4MTkpIHdpdGggMTAgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2xpYmNwcC9tYWNyby5jOjExNzApIHdpdGggNSBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvbGliY3BwL2V4cHIuYzozNzEpIHdpdGggNSBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvbGliY3BwL2V4cHIuYzozOTEp IHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvbGliY3BwL2V4 cHIuYzo0MTEpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv bGliY3BwL2V4cHIuYzo0MzEpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvbGliY3BwL2xleC5jOjIzNDEpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvbGliY3BwL2xleC5jOjE4NTYpIHdpdGggMTQgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2xpYmNwcC9sZXguYzo0MTQ3KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2xpYmRlY251bWJlci9kZWND b250ZXh0LmM6MzU4KSB3aXRoIDEzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9saWJkZWNudW1iZXIvZGVjTnVtYmVyLmM6MzMyMikgd2l0aCAxMCBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvbGliY3BwL2luaXQuYzo1NTUpIHdpdGggNyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvbGliY3BwL21hY3JvLmM6ODE5 KSB3aXRoIDEwIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9saWJjcHAv bWFjcm8uYzoxMTcwKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2xpYmNwcC9leHByLmM6MzcxKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2xpYmNwcC9leHByLmM6MzkxKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2xpYmNwcC9leHByLmM6NDExKSB3aXRoIDUgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2xpYmNwcC9leHByLmM6NDMxKSB3aXRo IDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2xpYmNwcC9sZXguYzoy MzQxKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2xpYmNw cC9sZXguYzoxODU2KSB3aXRoIDE0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9saWJjcHAvbGV4LmM6NDE0Nykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2Mvc2ltcGxpZnktcnR4LmM6MjI3NCkgd2l0aCA0IEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvc2ltcGxpZnktcnR4LmM6MjI3Mikg d2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvc2ltcGxp ZnktcnR4LmM6MjI5NCkgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jZmdjbGVhbnVwLmM6MTIzOSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY2ZnY2xlYW51cC5jOjExNzMpIHdpdGggMyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NmZ2NsZWFudXAuYzox MTczKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9y dGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2dvZHVtcC5jOjI0Nikgd2l0aCA2IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvZ29kdW1wLmM6MjM5KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3JlZ2Nwcm9wLmM6Nzg4KSB3aXRoIDQgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9zY2hlZC1kZXBzLmM6NDI3Nykg d2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6 ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9z Y2hlZC1kZXBzLmM6NDczMikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2Mvc2NoZWQtZGVwcy5jOjI5MjIpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUtdmVjdC1nZW5lcmljLmM6MTI5Nikgd2l0 aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS12ZWN0 LWdlbmVyaWMuYzoyMTA0KSB3aXRoIDExIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDoyNzQ4KSB3aXRoIDQgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjI3 NDgpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L2kzODYubWQ6Mjc0OCkgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDoyNzQ4KSB3aXRoIDQgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zeW5j Lm1kOjI3ODEpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2NvbmZpZy9pMzg2L3N5bmMubWQ6MjgwNikgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3luYy5tZDoyODMzKSB3aXRo IDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4 Ni9zeW5jLm1kOjI5MjkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L3N5bmMubWQ6Mjk1NCkgd2l0aCAzIEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3luYy5tZDozNDYy KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25m aWcvaTM4Ni9zeW5jLm1kOjM0ODcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvaXBhLXV0aWxzLmM6MzY0KSB3aXRoIDQgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy90cmVlLmg6NTEzOCkgd2l0aCAzIEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRo IDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQp IHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUt Y2hyZWMuYzo5NTApIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL3RyZWUtZGF0YS1yZWYuYzo3MTApIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyYW5zLW1lbS5jOjM2OSkgd2l0aCA0IEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJhbnMtbWVtLmM6NDE1KSB3aXRo IDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQp IHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5o Ojg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv cnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9kd2FyZjJvdXQuYzo1MzExKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2R3YXJmMm91dC5jOjE5ODc2KSB3aXRoIDMgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9kd2FyZjJvdXQuYzo2MDE5KSB3 aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9kd2FyZjJv dXQuYzoyNTI5NSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvZHdhcmYyb3V0LmM6MjI5ODIpIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS12ZWN0LXN0bXRzLmM6MTAzNzQpIHdpdGgg NSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUtdmVjdC1z dG10cy5jOjcwODkpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9lbWl0LXJ0bC5jOjM4NTkpIHdpdGggMyBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2VtaXQtcnRsLmM6NjQ3Mykgd2l0aCAzIEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZW1pdC1ydGwuYzo2NDcz KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9lbWl0 LXJ0bC5jOjk1Mykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvZW1pdC1ydGwuYzo5NTMpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9kc2UuYzoyNjMzKSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgZ2ltcGxlLW1hdGNoLmM6MjA4MzkpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgZ2ltcGxlLW1hdGNoLmM6 MTgwMjkpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L2kzODYubWQ6NDYxKSB3aXRoIDIxIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDo1OTk2KSB3aXRoIDYg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9p Mzg2Lm1kOjU3MSkgd2l0aCAzMCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6NTcxKSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE5MTc3KSB3 aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2Lm1kOjg4Nikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDo4NzgpIHdpdGggNCBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6Mjk3 Nikgd2l0aCAxNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L2kzODYubWQ6NTAzKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjkyNikgd2l0aCA1IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5t ZDo3NjUpIHdpdGggOSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L2kzODYubWQ6MTEyMSkgd2l0aCAxMCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTExMykgd2l0aCA2 IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYv aTM4Ni5tZDo1NjUpIHdpdGggMTAgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjU1Nykgd2l0aCA2IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3NlLm1kOjE3Mzc0KSB3 aXRoIDEwIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmln L2kzODYvc3NlLm1kOjE3MzY2KSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjU2MCkgd2l0aCAxMCBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6 NTUyKSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9j b25maWcvaTM4Ni9pMzg2Lm1kOjQ4MSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDoxNDQ3Mykgd2l0aCA0IEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvb21wLWxvdy5jOjYzNykg d2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmln L2kzODYvaTM4Ni1leHBhbmQuYzoxNTc0OCkgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni1leHBhbmQuYzoxNTc0Nykg d2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmln L2kzODYvaTM4Ni1leHBhbmQuYzoxNTY2MCkgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni1leHBhbmQuYzoxNTY1OSkg d2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6 ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9j b25maWcvaTM4Ni9pMzg2LWV4cGFuZC5jOjE2OTA5KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LWV4cGFuZC5jOjE3 MTIpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L2kzODYtZXhwYW5kLmM6MjAxMTQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYtZXhwYW5kLmM6NDAx KSB3aXRoIDIyIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29u ZmlnL2kzODYvaTM4Ni1leHBhbmQuYzozODApIHdpdGggMjEgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LWV4cGFuZC5jOjgxMzMp IHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZp Zy9pMzg2L2kzODYtZXhwYW5kLmM6ODEyNykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni1leHBhbmQuYzoyNzA2KSB3 aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2LWV4cGFuZC5jOjI3NDApIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYtZXhwYW5kLmM6MzQ4OCkgd2l0 aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kz ODYvaTM4Ni1leHBhbmQuYzo0MDI2KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LWV4cGFuZC5jOjQ1NzMpIHdpdGgg MyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2 L2kzODYtZXhwYW5kLmM6NjU2Nikgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni1leHBhbmQuYzoxOTQ1Mikgd2l0aCA0 IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3 aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4 ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2dp bXBsZS1zc2Etc3ByaW50Zi5jOjk0NCkgd2l0aCA2IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2MvcmVhZC1tZC5jOjQ3Mikgd2l0aCA0IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy90cmVlLmg6NTEzOCkgd2l0aCAzIEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS1zc2Etc3RydWN0 YWxpYXMuYzo2NjM0KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NmZ2V4cGFuZC5jOjYxNDkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NmZ2V4cGFuZC5jOjQ0NDApIHdpdGggMyBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL21hbmdsZS5jOjE4OTAp IHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUu aDo1MTM4KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jcC9jYWxsLmM6ODgxKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9jcC9zZWFyY2guYzo0NjIpIHdpdGggNyBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3NlYXJjaC5jOjUxOCkgd2l0aCA2IEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3AvbmFtZS1sb29rdXAuYzoyOTg0 KSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC9u YW1lLWxvb2t1cC5jOjI5NDMpIHdpdGggNyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NwL3BhcnNlci5jOjI3NDMpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3BhcnNlci5jOjI3NTYpIHdpdGggNCBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3BhcnNlci5jOjMxMDA5 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC9w YXJzZXIuYzozMjczNykgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvY3AvcGFyc2VyLmM6MzQxMDYpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3BhcnNlci5jOjI4NTY4KSB3aXRoIDQgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC9wYXJzZXIuYzoyNjQyMykg d2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3AvcGFy c2VyLmM6MTgxMTApIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NwL3BhcnNlci5jOjc1MjQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2NwL3BhcnNlci5jOjQxMjE5KSB3aXRoIDcgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC9wYXJzZXIuYzoxMzU0MCkgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3Avc2VtYW50 aWNzLmM6MzU5Nykgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvY3AvZGVjbDIuYzoxMzU4KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jcC9kZWNsMi5jOjU1NzcpIHdpdGggNyBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3R5cGVjay5jOjk0NzMpIHdpdGggNiBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2xhbWJkYS5jOjI3 OCkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3Av bGFtYmRhLmM6MTQ2Nikgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvY3AvbGFtYmRhLmM6Mjg4KSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9jcC9sYW1iZGEuYzozMDApIHdpdGggNiBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2xhbWJkYS5jOjQ1MCkgd2l0aCA3 IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3AvbGFtYmRhLmM6 NDUyKSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9j cC9sYW1iZGEuYzoxNDkwKSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9jcC9sYW1iZGEuYzoxNDk1KSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC90cmVlLmM6NzEpIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2V4cHIuYzoxMTcpIHdpdGggNiBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2V4cHIuYzoxNjkp IHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3B0 LmM6MjY4OTkpIHdpdGggMTcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9jcC9wdC5jOjE4MDY0KSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jcC9wdC5jOjc0NDApIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL3B0LmM6MTMwMTIpIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2RlY2wuYzoyNDk0KSB3aXRoIDcg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC9kZWNsLmM6MjQ5 Mikgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3Av ZGVjbC5jOjkxNCkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvY3AvZGVjbC5jOjkxMSkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvY3AvZGVjbC5jOjM5NjUpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2NvbnN0ZXhwci5jOjU2ODIpIHdpdGggNyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2NvbnN0ZXhwci5j Ojc2NDIpIHdpdGggNyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NwL2NvbnN0ZXhwci5jOjc2NDYpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2NwL2xleC5jOjY5NSkgd2l0aCA2IEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3AvY2xhc3MuYzoxMjUyKSB3aXRoIDcgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jcC9jbGFzcy5jOjEyNTIpIHdp dGggNyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NwL2NsYXNz LmM6MTIyOSkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVu dC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9n Y2Mvb3B0YWJzLXF1ZXJ5Lmg6ODkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL29wdGFicy1saWJmdW5jcy5jOjI0Nykgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvb3B0YWJzLWxpYmZ1bmNzLmM6MjU5 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwu aDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvbHRvL2x0by1sYW5nLmM6MTExMikgd2l0aCAxOCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZ2Vuc3VwcG9ydC5jOjMyNjYpIHdpdGggNyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2dlbnN1cHBvcnQuYzoz MjYxKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9y ZWFkLW1kLmM6NDcyKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy9nZW5hdXRvbWF0YS5jOjk1MSkgd2l0aCA4IEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZ2VucmVjb2cuYzo3MDMpIHdpdGggNCBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2dlbnByZWRzLmM6Nzk0KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdp dGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2dlbmd0eXBl LmM6MjQ5MSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVu dC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9n Y2MvZ2VuZ3R5cGUuaDozNDQpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2dlbnBlZXAuYzoyNTApIHdpdGggNyBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODk2KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy90b3BsZXYuYzoyMjI4KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdp dGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2RjZS5jOjU5 NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJl ZS1zc2EtY2NwLmM6ODU2KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy90cmVlLXNzYS1hbGlhcy5jOjQwODkpIHdpdGggMyBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2RkZy5jOjIzNykgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9sdG8tc3RyZWFtZXItb3V0 LmM6MTkyMikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVu dC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9n Y2MvbHRvLXN0cmVhbWVyLW91dC5jOjE2Mikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvbHRvLXN0cmVhbWVyLW91dC5jOjUyNykgd2l0aCAzIEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRo IDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQp IHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZp Zy9pMzg2L2kzODYuYzoxMzE0Mikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjE5MDMxKSB3aXRoIDE3IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5j OjE5MDMwKSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jb25maWcvaTM4Ni9pMzg2LmM6MTkwMTgpIHdpdGggMTYgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6MTkwMTIpIHdpdGgg NCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2 L2kzODYuYzoxOTAwMykgd2l0aCAxMCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoxOTA0Mikgd2l0aCA4IEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjE5MDYz KSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25m aWcvaTM4Ni9pMzg2LmM6MjA5NjUpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoyMDk2Mykgd2l0aCA1IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5j OjY3NDYpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L2kzODYuYzoxNjM5NSkgd2l0aCAyNCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo2NzI2KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9p Mzg2LmM6MTkyMDEpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoxOTIwMCkgd2l0aCA1IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjIxNTg3KSB3 aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2LmM6MTkyNTQpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoxOTI3OSkgd2l0aCA0IEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjE5 MzAwKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9y dGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2NvbmZpZy9pMzg2L2kzODYuYzozMzI4KSB3aXRoIDIyIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjMzOTIpIHdpdGgg MjEgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4 Ni9pMzg2LmM6Njc5Nykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjY4MDEpIHdpdGggMyBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo2NTk5KSB3 aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2LmM6MTIyNTApIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoxOTYwMykgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjE2 NzUpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L2kzODYuYzo4NTQ2KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6NjYyMykgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5j Ojg1MTIpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L2kzODYuYzo3MTEwKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6NzgyMykgd2l0aCAzIEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4 Ni5jOjg3MzQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2NvbmZpZy9pMzg2L2kzODYuYzo4NDM1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6ODQ2OCkgd2l0aCAz IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYv aTM4Ni5jOjg0NDcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo3MDg1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6NzMwOCkgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kz ODYvaTM4Ni5jOjcyOTUpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo3MTk3KSB3aXRoIDMgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6NzE5Mykg d2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmln L2kzODYvaTM4Ni5jOjcwMDApIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoxODUzKSB3aXRoIDUgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6ODM4 MSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29u ZmlnL2kzODYvaTM4Ni5jOjgzNTkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo4MzIwKSB3aXRoIDMgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2LmM6 ODMwMCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv Y29uZmlnL2kzODYvaTM4Ni5jOjgyODIpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo4MDQ5KSB3aXRoIDQgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2 LmM6ODAzMykgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVu dC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9n Y2MvY29uZmlnL2kzODYvaTM4Ni5jOjgwMTkpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo4MDA2KSB3aXRoIDQg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9p Mzg2LmM6Nzk5Nykgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjc5OTApIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo3OTg0KSB3aXRo IDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4 Ni9pMzg2LmM6NzkzMSkgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjc5MjkpIHdpdGggNCBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo3OTI4KSB3 aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2LmM6Nzk2NCkgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjkxMjgpIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo5MTU3 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25m aWcvaTM4Ni9pMzg2LmM6OTA3Mikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjg5NDcpIHdpdGggMyBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzo4 OTcxKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9j b25maWcvaTM4Ni9pMzg2LmM6MTMwMTcpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoxNjcyNCkgd2l0aCAyMiBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kz ODYuYzoxNjU5OCkgd2l0aCAyMiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYuYzoyODg0KSB3aXRoIDE0IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5jOjM4MzgpIHdp dGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9p Mzg2L3NzZS5tZDoxMTg1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTE4NSkgd2l0aCAzIEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3NlLm1kOjExODUp IHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZp Zy9pMzg2L3NzZS5tZDoxMTg1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTE4NSkgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3NlLm1kOjEx ODUpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L3NzZS5tZDoxMTg1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTE4NSkgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3NlLm1k OjExODUpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L3NzZS5tZDoxMTg1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTE4NSkgd2l0aCAzIEJC cyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWlu IChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvc3Nl Lm1kOjExODUpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2NvbmZpZy9pMzg2L3NzZS5tZDoxMDY3KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTA2Nykgd2l0aCAz IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYv c3NlLm1kOjEwNjcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L3NzZS5tZDoxMDY3KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTA2Nykgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kz ODYvc3NlLm1kOjEwNjcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L3NzZS5tZDoxMDY3KSB3aXRoIDMgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTA2Nykg d2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmln L2kzODYvc3NlLm1kOjEwNjcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L3NzZS5tZDoxMDY3KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9zc2UubWQ6MTA2 Nykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29u ZmlnL2kzODYvc3NlLm1kOjEwNjcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni1mZWF0dXJlcy5jOjU0Nykg d2l0aCAxMCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5o Ojg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv ZXhwbWVkLmM6NjI3Mikgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9yZWFkLXJ0bC1mdW5jdGlvbi5jOjE0MDApIHdpdGggMTAgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy92YXJh c20uYzo3MzA1KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgaW5zbi1kZmF0YWIuYzoyODQwKSB3aXRo IDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4 Ni9pMzg2Lm1kOjM2NjIpIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MzY1OCkgd2l0aCA4IEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDozNjU0 KSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25m aWcvaTM4Ni9pMzg2Lm1kOjM2NTApIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MjQ5Nykgd2l0aCAxMiBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYu bWQ6MjQ1Mykgd2l0aCAxNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTU1MDUpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MjA2NDUpIHdp dGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9p Mzg2L2kzODYubWQ6MjYwMzApIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTY5ODcpIHdpdGggNSBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6 MTY5ODMpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L2kzODYubWQ6MTY5NzkpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTY5NzUpIHdpdGgg NCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2 L2kzODYubWQ6MTY5ODcpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTY5ODMpIHdpdGggNCBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTY5 NzkpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L2kzODYubWQ6MTY5NzUpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxMjgpIHdpdGggNSBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kz ODYubWQ6MTYxMjQpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxMjApIHdpdGggNSBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxMTYp IHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZp Zy9pMzg2L2kzODYubWQ6MTYxMjgpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxMjQpIHdpdGggNCBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYu bWQ6MTYxMjApIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxMTYpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYzODcpIHdp dGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9p Mzg2L2kzODYubWQ6MTYxNTgpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxNTgpIHdpdGggNiBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6 MTYxNzEpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L2NvbmZpZy9pMzg2L2kzODYubWQ6MTYxNzEpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MjM1ODApIHdpdGgg MyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2 L2kzODYubWQ6MjM1MTYpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MjM1MTIpIHdpdGggNCBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MjM1 MDgpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bmZpZy9pMzg2L2kzODYubWQ6MjM1MDQpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6Mjk2NTQpIHdpdGggMyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kz ODYubWQ6Mjk1OTApIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6Mjk1ODYpIHdpdGggNCBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6Mjk1ODIp IHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZp Zy9pMzg2L2kzODYubWQ6Mjk1NzgpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYXNhbi5oOjE2OCkgd2l0aCA5IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9idWlsdGlucy5jOjEyMjA3KSB3aXRo IDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9idWlsdGlucy5j OjQ3MDUpIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvbG9vcC1pdi5jOjE1NjkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3NlLmM6MzM1MCkgd2l0aCA1IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvaXBhLWRldmlydC5jOjEyMzgpIHdpdGggNCBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L3By ZWRpY2F0ZXMubWQ6MTMwOSkgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvcHJlZGljYXRlcy5tZDoxMzEzKSB3aXRoIDUgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9wcmVk aWNhdGVzLm1kOjE3MzkpIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2NvbmZpZy9pMzg2L3ByZWRpY2F0ZXMubWQ6MTgxMSkgd2l0aCA5IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdp dGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4 NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29u ZmlnL2kzODYvaTM4Ni1vcHRpb25zLmM6MTE3Nikgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9naW1wbGUtcHJldHR5LXByaW50LmM6Mzkw KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGxh bmFsLmM6NjE5Mikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9ydGwuaDo4OTYpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2lmY3Z0LmM6MzU5KSB3aXRoIDMgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGgg MyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2dpbXBsZS1leHBy Lmg6OTcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L3RyZWUtb2JqZWN0LXNpemUuYzozMTIpIHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9mb3J0cmFuL2NvbnZlcnQuYzoxMDUpIHdp dGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2ZvcnRyYW4v Y2hlY2suYzo1ODcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2ZvcnRyYW4vcGFyc2UuYzoxODE5KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9mb3J0cmFuL3N5bWJvbC5jOjE3NjYpIHdpdGggNSBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2ZvcnRyYW4vaW50cmlu c2ljLmM6MjA4KSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9mb3J0cmFuL2ludHJpbnNpYy5jOjQ5MjkpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2ZvcnRyYW4vZHVtcC1wYXJzZS10cmVlLmM6MzI2 Mikgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZm9y dHJhbi9yZXNvbHZlLmM6MzMwNykgd2l0aCA2IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvZm9ydHJhbi9zY2FubmVyLmM6MjMyMCkgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZm9ydHJhbi9zY2FubmVyLmM6MjIx NSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZm9y dHJhbi90cmFucy1kZWNsLmM6MjY5Mikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2MvZm9ydHJhbi9leHByLmM6MTExOCkgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZm9ydHJhbi9kZWNsLmM6ODQyMykg d2l0aCA2IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCBnZW5lcmljLW1hdGNoLmM6MTg4NjIpIHdpdGggNiBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgZ2Vu ZXJpYy1tYXRjaC5jOjE2MTM0KSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9zdG9yLWxheW91dC5jOjQ4Nikgd2l0aCA1IEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUtcHJldHR5LXByaW50 LmM6MTc0MCkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVu dC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9n Y2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy90cmVlLmg6NTEzOCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvZm9sZC1jb25zdC5jOjIxMTUpIHdpdGggMyBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2ZvbGQtY29uc3QuYzo4MzMyKSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9mb2xkLWNvbnN0LmM6 ODgzNykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv Zm9sZC1jb25zdC5jOjg3MTkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL3RyZWUtc3NhLWRjZS5jOjk2NCkgd2l0aCAxMiBCQnMgdHJhbnNmb3Jt ZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUv bWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGgg MyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkg d2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZ2ltcGxl LWV4cHIuaDo5Nykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9wcmludC10cmVlLmM6NjkxKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9maXhlZC12YWx1ZS5jOjExMTIpIHdpdGggMyBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2ZpeGVkLXZhbHVlLmM6ODQw KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9maXhl ZC12YWx1ZS5jOjgyNykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvZml4ZWQtdmFsdWUuYzo4OTYpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUuYzoxNDI2MSkgd2l0aCA0IEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS5jOjE0NzUxKSB3aXRoIDMgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy90cmVlLmM6MTQ2NjkpIHdp dGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUuYzox NDY0OCkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv dHJlZS5jOjE0NTYxKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy90cmVlLmM6NzA4Mykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvdHJlZS5jOjEwODQwKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy90cmVlLmM6MTE2OTcpIHdpdGggNSBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY3NlbGliLmM6Mjk2OCkgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9zZWwt c2NoZWQtaXIuYzoyOTg3KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZ2ltcGxlLWV4cHIuaDo5Nykgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29tYmluZS1zdGFjay1hZGouYzox ODkpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Nv bWJpbmUtc3RhY2stYWRqLmM6NDEyKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb21iaW5lLXN0YWNrLWFkai5jOjQwNikgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9sdG8tc3RyZWFtZXIt aW4uYzoxNzEzKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvZHdhcmYyY2ZpLmM6MjU0Nikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg5Nikgd2l0aCAz IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3 aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4 ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3Jl bG9hZC5jOjY1MzYpIHdpdGggNiBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL29wdGFicy1xdWVyeS5jOjczMSkgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS1jYWxsLWNkY2UuYzo1 NjEpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3Ry ZWUtdmVjdC1kYXRhLXJlZnMuYzoxMzYpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDoxOTQzMCkgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kz ODYvaTM4Ni5tZDoxOTQzMCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNo IHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1p bmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDoxOTQzMCkgd2l0aCAzIEJCcyB0cmFu c2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAv aG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDox OTQzMCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv Y29uZmlnL2kzODYvaTM4Ni5tZDoxOTQ0MSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRv IGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4v UHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy90cmVlLXRhaWxjYWxsLmM6NjU2KSB3aXRoIDMg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy90cmVlLXRhaWxjYWxs LmM6NDQwKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jLWZhbWlseS9jLWF0dHJpYnMuYzozNzE3KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jLWZhbWlseS9jLWF0dHJpYnMuYzoxOTYyKSB3aXRo IDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jLWZhbWlseS9j LWxleC5jOjU0NSkgd2l0aCA3IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvYy1mYW1pbHkvYy1mb3JtYXQuYzozNDM5KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jLWZhbWlseS9jLWFkYS1zcGVjLmM6NDY5KSB3 aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jLWZhbWls eS9jLWNvbW1vbi5jOjIzOTQpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRj aCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1t aW5nL2djYzIvZ2NjL2MtZmFtaWx5L2MtY29tbW9uLmM6MjM0OSkgd2l0aCAxOCBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2MtZmFtaWx5L2MtY29tbW9uLmM6 Mjg3Nykgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv Yy1mYW1pbHkvYy1vbXAuYzoyMjQ0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy90cmVlLmg6NTEzOCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYy1mYW1pbHkvYy13YXJuLmM6MTgxOCkgd2l0aCAz IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYy1mYW1pbHkvYy13 YXJuLmM6MTgyNCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvYy1mYW1pbHkvYy13YXJuLmM6MTgzMikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYy1mYW1pbHkvYy13YXJuLmM6MTg0Mykgd2l0aCAz IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYy1mYW1pbHkvYy13 YXJuLmM6MTg0OSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvYy1mYW1pbHkvYy13YXJuLmM6NTEyKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jL2MtcGFyc2VyLmM6Mzg0KSB3aXRoIDUgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jL2MtcGFyc2VyLmM6MTI5OCkg d2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYy9jLXBh cnNlci5jOjEyNjIpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL2MvYy1kZWNsLmM6MTA5NDIpIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL2MvYy1kZWNsLmM6MTA3NzIpIHdpdGggOSBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2MvYy1kZWNsLmM6MTA4MjkpIHdpdGgg MTAgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jL2MtZGVjbC5j OjEwODkwKSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jL2MtZGVjbC5jOjEwOTkzKSB3aXRoIDcgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jL2MtZGVjbC5jOjExMDQyKSB3aXRoIDExIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvYy9naW1wbGUtcGFyc2VyLmM6MTU3OSkgd2l0 aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS5oOjUx MzgpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Mv Yy10eXBlY2suYzo4MDMxKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9nY2MuYzo5MjI0KSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9nY2MuYzozMjU0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9nY2MuYzo3MDIwKSB3aXRoIDcgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3RyZWUtdmVjdC1zbHAuYzo5MDAp IHdpdGggNSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRp dGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5o Ojg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv cnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2x0by1vcHRzLmM6MTA0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQg aW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFy eGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3Bvc3RyZWxvYWQuYzoxNDUyKSB3aXRoIDQgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGgg MyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBj aGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkg d2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcmVsb2Fk MS5jOjY2MTYpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2MvY29tYmluZS5jOjExODkwKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9jb21iaW5lLmM6OTU5Mikgd2l0aCA0IEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29tYmluZS5jOjc1NDkpIHdpdGggMyBC QnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFp biAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbWJpbmUuYzo1OTMw KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb21i aW5lLmM6Njc1MCkgd2l0aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvY29tYmluZS5jOjY3MTIpIHdpdGggNCBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2NvbWJpbmUuYzo2Njk1KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb21iaW5lLmM6MzkzNSkgd2l0aCA2IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29tYmluZS5jOjI3NDUpIHdp dGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlv biBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4 NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29u ZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJl ZS5oOjUxMzgpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1l bnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIv Z2NjL2dpbXBsZS1leHByLmg6OTcpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3 aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dy YW1taW5nL2djYzIvZ2NjL2dpbXBsaWZ5LmM6MTQ1ODkpIHdpdGggMTQgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJh bnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQg L2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL2Vhcmx5LXJlbWF0LmM6MjUxOSkg d2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0 aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcmVjb2cu YzozNTk4KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL3JlY29nLmM6MzI5Mikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvcmVjb2cuYzozMjg5KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9yZWNvZy5jOjMzNzApIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvdHJlZS1zc2Etc2NvcGVkdGFi bGVzLmM6NzQ1KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5tZDoxNjA0Mykgd2l0aCA2IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYvaTM4Ni5t ZDozNjQzKSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jb25maWcvaTM4Ni9pMzg2Lm1kOjM2MzkpIHdpdGggOCBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL2NvbmZpZy9pMzg2L2kzODYubWQ6MzYzNSkgd2l0aCA4 IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvY29uZmlnL2kzODYv aTM4Ni5tZDozNjMxKSB3aXRoIDggQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjI0NDIpIHdpdGggMTIgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjIzOTgp IHdpdGggMTQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25m aWcvaTM4Ni9pMzg2Lm1kOjE1NjUyKSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjIwNjUxKSB3aXRoIDYgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2 Lm1kOjI1OTQ3KSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MTMzKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MTI5KSB3 aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2Lm1kOjE3MTI1KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MTIxKSB3aXRoIDQgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1k OjE3MTMzKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MTI5KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MTI1KSB3aXRo IDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4 Ni9pMzg2Lm1kOjE3MTIxKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3NDA1KSB3aXRoIDUgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3 NDAxKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9j b25maWcvaTM4Ni9pMzg2Lm1kOjE3Mzk3KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MzkzKSB3aXRoIDQg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9p Mzg2Lm1kOjE3NDA1KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3NDAxKSB3aXRoIDQgQkJzIHRyYW5zZm9y bWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21l L21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3Mzk3 KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25m aWcvaTM4Ni9pMzg2Lm1kOjE3MzkzKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE3MDg1KSB3aXRoIDYgQkJz IHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4g KGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2 Lm1kOjE2ODcyKSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVt ZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2My L2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE2ODcyKSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjE2OTI1KSB3 aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcv aTM4Ni9pMzg2Lm1kOjE2OTI1KSB3aXRoIDYgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0 Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFt bWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjIzNzY3KSB3aXRoIDMgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1k OjIzNzAzKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9jb25maWcvaTM4Ni9pMzg2Lm1kOjIzNjk5KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjIzNjk1KSB3aXRo IDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24g Y2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4 Ni9pMzg2Lm1kOjIzNjkxKSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjI5NjMxKSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjI5 NTY3KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpD b25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9j b25maWcvaTM4Ni9pMzg2Lm1kOjI5NTYzKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8g YSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Q cm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9pMzg2Lm1kOjI5NTU5KSB3aXRoIDUg QkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hh aW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9jb25maWcvaTM4Ni9p Mzg2Lm1kOjI5NTU1KSB3aXRoIDUgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3Rh dGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9n Y2MyL2djYy9pcGEtcHJvcC5jOjY3OCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2MvZ2ltcGxlLWV4cHIuaDo5Nykgd2l0aCAzIEJCcyB0cmFuc2Zv cm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9t ZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZ2ltcGxlLXNzYS1pc29sYXRlLXBhdGhz LmM6MjQxKSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50 LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2dj Yy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0 ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2dj YzIvZ2NjL3RyZWUtc3NhLW9wZXJhbmRzLmM6NTg3KSB3aXRoIDQgQkJzIHRyYW5zZm9ybWVk IGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21h cnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNm b3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hv bWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvb3B0YWJzLmM6NzIxNSkgd2l0 aCA0IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvb3B0YWJzLmM6 MjAzMykgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4K Q29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mv b3B0YWJzLmM6MjExNCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0 YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcv Z2NjMi9nY2Mvb3B0YWJzLmM6MTg3NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEg c3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJv Z3JhbW1pbmcvZ2NjMi9nY2Mvb3B0YWJzLmM6MTMxNSkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvb3B0YWJzLmM6MTI3Nykgd2l0aCA1IEJCcyB0 cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChh dCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2Mvb3B0YWJzLmM6MTEwMSkgd2l0 aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy92YXIt dHJhY2tpbmcuYzo3OTkpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBz dGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5n L2djYzIvZ2NjL2RvanVtcC5jOjEwMjYpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBh IHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1By b2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBp bnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4 aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvZ2VuZ3R5cGUuYzoyNDkxKSB3aXRoIDMgQkJzIHRy YW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0 IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9nZW5ndHlwZS5oOjM0NCkgd2l0 aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9u IGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0 KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25k aXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwu aDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQu CkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2Nj L3J0bC5oOjg5Nikgd2l0aCAzIEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRl bWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2Nj Mi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2gg c3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWlu Zy9nY2MyL2djYy9hc2FuLmg6MTY4KSB3aXRoIDkgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBz d2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9n cmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50 byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGlu L1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAzIEJCcyB0cmFuc2Zvcm1l ZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9t YXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3aXRoIDMgQkJzIHRyYW5z Zm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9o b21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4ODQpIHdpdGggMyBCQnMg dHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNvbmRpdGlvbiBjaGFpbiAo YXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3J0bC5oOjg4NCkgd2l0aCAz IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNo YWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9nY2MvcnRsLmg6ODg0KSB3 aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL2djYy9ydGwuaDo4 ODQpIHdpdGggMyBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCkNv bmRpdGlvbiBjaGFpbiAoYXQgL2hvbWUvbWFyeGluL1Byb2dyYW1taW5nL2djYzIvZ2NjL3Ry ZWUtc3NhLXNjY3ZuLmM6NTc3Nykgd2l0aCA1IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dp dGNoIHN0YXRlbWVudC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3Jh bW1pbmcvZ2NjMi9nY2MvZ2ltcGxlLXNzYS1zdHJlbmd0aC1yZWR1Y3Rpb24uYzoyMTM4KSB3 aXRoIDMgQkJzIHRyYW5zZm9ybWVkIGludG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRp b24gY2hhaW4gKGF0IC9ob21lL21hcnhpbi9Qcm9ncmFtbWluZy9nY2MyL3psaWIvZGVmbGF0 ZS5jOjM2Mykgd2l0aCA2IEJCcyB0cmFuc2Zvcm1lZCBpbnRvIGEgc3dpdGNoIHN0YXRlbWVu dC4KQ29uZGl0aW9uIGNoYWluIChhdCAvaG9tZS9tYXJ4aW4vUHJvZ3JhbW1pbmcvZ2NjMi9s aWJpYmVydHkvY3AtZGVtYW5nbGUuYzoxNTYxKSB3aXRoIDkgQkJzIHRyYW5zZm9ybWVkIGlu dG8gYSBzd2l0Y2ggc3RhdGVtZW50LgpDb25kaXRpb24gY2hhaW4gKGF0IC9ob21lL21hcnhp bi9Qcm9ncmFtbWluZy9nY2MyL2xpYmliZXJ0eS9jcC1kZW1hbmdsZS5jOjE1NjEpIHdpdGgg OSBCQnMgdHJhbnNmb3JtZWQgaW50byBhIHN3aXRjaCBzdGF0ZW1lbnQuCg== --------------D752A7F6E5E0BA5BF719A360--